C++ · Tekst · sstream

Stringstream, czyli napis jak cin

Masz całą linię tekstu i chcesz wyciągnąć z niej słowa albo liczby? Opakuj ją w strumień i czytaj tymi samymi strzałkami, które znasz z cin.

Napis, który zachowuje się jak cin

Znasz już problem z tematu o wejściu i wyjściu: cin >> s bierze jedno słowo, a getline całą linię. Ale co, jeśli wczytałeś całą linię i teraz chcesz z niej wyciągnąć poszczególne słowa — a nie wiesz z góry, ile ich jest?

stringstream z nagłówka <sstream> rozwiązuje to w jedną linijkę. Opakowuje napis w strumień, z którego czytasz dokładnie tak samo jak z cin — tymi samymi strzałkami >>.

podstawy.cpp
#include <iostream>
#include <sstream>
#include <string>
using namespace std;

int main() {
    string linia = "Ala ma kota i psa";

    stringstream ss(linia);     // opakowujemy napis

    string slowo;
    while (ss >> slowo) {       // jak cin >> slowo!
        cout << "[" << slowo << "]\n";
    }

    return 0;
}
▶ Wyjście programu
[Ala] [ma] [kota] [i] [psa]

Zwróć uwagę na while (ss >> slowo). To ten sam wzorzec, którego używasz do czytania danych do końca — tylko że tutaj „koniec danych” oznacza koniec napisu. Strumień sam wie, kiedy skończyć.

📦

stringstream ss(s);

Opakowuje napis s w strumień. Nagłówek: #include <sstream>.

➡️

ss >> x

Czyta kolejną wartość — dokładnie jak cin >> x. Typ x decyduje, co zostanie wczytane.

⬅️

ss << x

Dopisuje do strumienia. Tak buduje się napis z kawałków i liczb.

📃

ss.str()

Zwraca całą zawartość jako zwykły string.

✂️

getline(ss, s, ';')

Czyta do podanego znaku zamiast do spacji. Tak rozbija się dane rozdzielone przecinkami.

🔄

ss.clear()

Potrzebne, gdy chcesz użyć tego samego strumienia drugi raz.

liczby.cpp
#include <iostream>
#include <sstream>
#include <string>
using namespace std;

int main() {
    string linia;
    getline(cin, linia);        // cala linia liczb

    stringstream ss(linia);

    int x;
    int suma = 0, ile = 0;

    while (ss >> x) {           // wyciagamy liczby
        suma += x;
        ile++;
    }

    cout << "Liczb: " << ile << "\n";
    cout << "Suma:  " << suma << "\n";

    return 0;
}
▶ Wyjście programu
Wejście: 10 20 30 40 Liczb: 4 Suma: 100

To rozwiązuje częsty problem: każdy wiersz ma inną liczbę wartości. Czytasz wiersz przez getline, wrzucasz go do strumienia i wyciągasz tyle liczb, ile tam faktycznie jest.

Rozbijanie, zamiana i budowanie

Poza rozbijaniem linii strumień służy jeszcze do dwóch rzeczy: zamiany tekstu na liczbę i budowania napisu z kawałków. Obie robi się tymi samymi strzałkami, tylko w drugą stronę.

tekst_na_liczbe.cpp
#include <sstream>

string s = "42";
int x;

stringstream ss(s);
ss >> x;                  // teraz x to liczba 42

cout << x * 2 << "\n";    // 84

// do jednej wartosci prosciej jest tak:
int y = stoi("42");
cout << y * 2;
▶ Wyjście programu
84 84
budowanie.cpp
#include <sstream>

stringstream ss;

// dopisujemy kawalek po kawalku
ss << "Wynik: " << 42 << " punktow";
ss << " (" << 95.5 << "%)";

string wynik = ss.str();   // gotowy napis

cout << wynik;
▶ Wyjście programu
Wynik: 42 punktow (95.5%)

Do zamiany jednego napisu na liczbę prościej jest użyć stoi. Strumień opłaca się wtedy, gdy wartości jest wiele albo gdy przemieszane są z tekstem — wtedy jedna pętla załatwia wszystko.

Budowanie napisu przydaje się, gdy chcesz złożyć wynik z liczb i tekstu, a dopiero potem zdecydować, co z nim zrobić. Strumień radzi sobie z liczbami bez to_string — po prostu wrzucasz je strzałkami, jak do cout.

Dane rozdzielone przecinkami

Domyślnie strumień dzieli tekst po spacjach. Ale getline przyjmuje trzeci argument — znak, po którym ma ciąć. Dzięki temu rozbijesz linię po przecinkach, średnikach albo czymkolwiek innym.

przecinki.cpp
#include <sstream>

string linia = "Ala,12,4.75";

stringstream ss(linia);
string pole;

while (getline(ss, pole, ',')) {
    cout << "[" << pole << "]\n";
}
▶ Wyjście programu
[Ala] [12] [4.75]
mieszane.cpp
#include <sstream>

string linia = "2024-03-15";

stringstream ss(linia);
string czesc;
int liczby[3];
int i = 0;

while (getline(ss, czesc, '-')) {
    liczby[i++] = stoi(czesc);
}

cout << "Rok: "     << liczby[0] << "\n";
cout << "Miesiac: " << liczby[1] << "\n";
cout << "Dzien: "   << liczby[2] << "\n";
▶ Wyjście programu
Rok: 2024 Miesiac: 3 Dzien: 15

Uwaga na puste pola: przy dwóch przecinkach obok siebie getline zwróci pusty napis — i dobrze, bo to oznacza brakującą wartość. Jeśli chcesz je pominąć, sprawdź if (!pole.empty()).

I ostatnia pułapka, tym razem przy wielokrotnym użyciu. Gdy przeczytasz strumień do końca, zostaje on w stanie „dane się skończyły”. Żeby użyć go ponownie, trzeba wyczyścić ten stan i podmienić zawartość — dwoma wywołaniami po kolei.

ponowne_uzycie.cpp
#include <iostream>
#include <sstream>
#include <string>
using namespace std;

int main() {
    stringstream ss;
    string linia;

    // trzy linie, kazda o innej dlugosci
    while (getline(cin, linia)) {
        ss.clear();           // kasujemy stan "koniec danych"
        ss.str(linia);        // podmieniamy zawartosc

        int x, suma = 0;
        while (ss >> x) suma += x;

        cout << "Suma wiersza: " << suma << "\n";
    }

    return 0;
}
▶ Wyjście programu
Wejście: 1 2 3 10 20 5 Suma wiersza: 6 Suma wiersza: 30 Suma wiersza: 5

Wszystko, co robi się ze strumieniem

Dziewięć zapisów — cały stringstream. Pierwsze trzy wystarczają do zdecydowanej większości zastosowań.

ZapisCo robiUwaga
stringstream ss(s); Opakowuje napis w strumień. Nagłówek <sstream>
while (ss >> slowo) Rozbija na słowa po spacjach. Jak while (cin >> x)
while (ss >> liczba) Wyciąga liczby z tekstu. Typ zmiennej decyduje
getline(ss, pole, ',') Tnie po własnym znaku. Puste pola też wracają
ss << x << " tekst"; Dopisuje do strumienia. Jak do cout
ss.str() Zwraca całość jako string. Bez argumentu — odczyt
ss.str(nowy) Podmienia zawartość. Z argumentem — zapis
ss.clear() Kasuje stan „koniec danych”. Przed ponownym użyciem
stoi(s) / stod(s) Zamiana jednego napisu na liczbę. Prościej niż strumień

Wiersze siódmy i ósmy chodzą w parze i kolejność ma znaczenie: najpierw ss.clear(), potem ss.str(nowy). Odwrotnie strumień nadal pamięta, że dane się skończyły, i nie wczyta niczego.

Sprawdź się na zadaniach

Sześć zadań od najprostszego. Wszystkie opierają się na tym samym: masz linię tekstu i chcesz wyciągnąć z niej kawałki. Najpierw spróbuj sam.

Łatwe Policz słowa
Wczytaj jedną linię tekstu i wypisz, ile jest w niej słów.
Jak to ugryźć: Linię wczytaj przez getline, wrzuć do strumienia i licz w pętli while (ss >> slowo). Strumień sam pomija wielokrotne spacje.
Pokaż rozwiązanie
policz_slowa.cpp
#include <iostream>
#include <sstream>
#include <string>
using namespace std;

int main() {
    string linia;
    getline(cin, linia);

    stringstream ss(linia);
    string slowo;
    int ile = 0;

    while (ss >> slowo) ile++;

    cout << ile;
    return 0;
}
Łatwe Najdłuższe słowo
Wczytaj linię tekstu i wypisz najdłuższe słowo oraz jego długość. Przy remisie wypisz pierwsze.
Jak to ugryźć: Wzorzec rekordu na słowach. Porównuj slowo.length() z długością dotychczasowego rekordu — warunek > zapewni pierwsze wystąpienie.
Pokaż rozwiązanie
najdluzsze.cpp
#include <iostream>
#include <sstream>
#include <string>
using namespace std;

int main() {
    string linia;
    getline(cin, linia);

    stringstream ss(linia);
    string slowo, najdluzsze = "";

    while (ss >> slowo) {
        if (slowo.length() > najdluzsze.length()) {
            najdluzsze = slowo;
        }
    }

    cout << najdluzsze << " (" << najdluzsze.length() << ")";
    return 0;
}
Łatwe Odwróć kolejność słów
Wczytaj linię tekstu i wypisz jej słowa w odwrotnej kolejności. Dla Ala ma kota odpowiedzią jest kota ma Ala.
Jak to ugryźć: Zbierz słowa do wektora, a potem przejdź go od końca. Strumień robi całą robotę z rozbijaniem — reszta to zwykła pętla.
Pokaż rozwiązanie
odwroc_slowa.cpp
#include <iostream>
#include <sstream>
#include <vector>
#include <string>
using namespace std;

int main() {
    string linia;
    getline(cin, linia);

    stringstream ss(linia);
    vector<string> slowa;
    string s;

    while (ss >> s) slowa.push_back(s);

    for (int i = slowa.size() - 1; i >= 0; i--) {
        cout << slowa[i] << " ";
    }

    return 0;
}
Średnie Sumowanie wierszy
Wczytuj wiersze liczb aż do końca danych. Każdy wiersz może mieć inną liczbę wartości. Dla każdego wypisz jego sumę, a na końcu sumę wszystkiego.
Jak to ugryźć: Pętla while (getline(cin, linia)), a w środku nowy strumień dla każdego wiersza. Możesz też użyć jednego strumienia wielokrotnie, pamiętając o clear() i str() w tej kolejności.
Pokaż rozwiązanie
wiersze.cpp
#include <iostream>
#include <sstream>
#include <string>
using namespace std;

int main() {
    string linia;
    long long calosc = 0;

    while (getline(cin, linia)) {
        stringstream ss(linia);

        int x;
        long long suma = 0;
        while (ss >> x) suma += x;

        cout << suma << "\n";
        calosc += suma;
    }

    cout << "Razem: " << calosc;
    return 0;
}
Średnie Dane po przecinkach
Każdy wiersz zawiera imię, wiek i średnią rozdzielone przecinkami, np. Ala,12,4.75. Wypisz je w czytelnej formie, wyrównane w kolumnach.
Jak to ugryźć: getline(ss, pole, ',') rozbije wiersz po przecinkach. Wiek i średnią zamień na liczby przez stoi i stod, a do kolumn użyj setw.
Pokaż rozwiązanie
csv.cpp
#include <iostream>
#include <sstream>
#include <iomanip>
#include <string>
using namespace std;

int main() {
    string linia;

    while (getline(cin, linia)) {
        stringstream ss(linia);

        string imie, poleWiek, poleSrednia;
        getline(ss, imie, ',');
        getline(ss, poleWiek, ',');
        getline(ss, poleSrednia, ',');

        int wiek = stoi(poleWiek);
        double srednia = stod(poleSrednia);

        cout << left << setw(12) << imie
             << right << setw(4) << wiek
             << fixed << setprecision(2)
             << setw(8) << srednia << "\n";
    }

    return 0;
}
Trudne Parsowanie daty i czasu
Wczytuj wiersze w formacie 2024-03-15 14:30. Dla każdego wypisz dzień, miesiąc, rok, godzinę i minutę jako osobne liczby, a na koniec podaj, ile minut minęło od północy.
Jak to ugryźć: Dwa poziomy rozbijania. Najpierw podziel wiersz na datę i godzinę po spacji, potem każdą z tych części osobnym strumieniem — datę po -, godzinę po :. Minuty od północy to godz * 60 + min.
Pokaż rozwiązanie
data.cpp
#include <iostream>
#include <sstream>
#include <string>
using namespace std;

int main() {
    string linia;

    while (getline(cin, linia)) {
        stringstream ss(linia);

        string czescData, czescCzas;
        ss >> czescData >> czescCzas;

        // data po myslnikach
        stringstream sd(czescData);
        string pole;
        int rok, mies, dzien;
        getline(sd, pole, '-'); rok = stoi(pole);
        getline(sd, pole, '-'); mies = stoi(pole);
        getline(sd, pole, '-'); dzien = stoi(pole);

        // czas po dwukropku
        stringstream sc(czescCzas);
        int godz, minuta;
        getline(sc, pole, ':'); godz = stoi(pole);
        getline(sc, pole, ':'); minuta = stoi(pole);

        cout << dzien << "." << mies << "." << rok
             << "  " << godz << ":" << minuta
             << "  -> " << godz * 60 + minuta << " min\n";
    }

    return 0;
}

Częste błędy i dobre praktyki

📦
Nagłówek <sstream>
To osobny nagłówek — <string> nie wystarczy. Bez niego kompilator nie zna stringstream.
🔄
clear() przed ponownym użyciem
Po dojściu do końca strumień zapamiętuje, że danych zabrakło. Kolejność jest ważna: najpierw ss.clear(), potem ss.str(nowy).
🧹
cin.ignore przed getline
Ten sam problem co zawsze: po cin >> n w kolejce zostaje ENTER. Wywołaj cin.ignore(), zanim sięgniesz po getline.
✂️
Trzeci argument getline
getline(ss, pole, ',') tnie po przecinku zamiast po spacji. Puste pola między separatorami też zostaną zwrócone.
🎯
Do jednej liczby wystarczy stoi
stoi("42") jest krótsze niż tworzenie strumienia. Stringstream opłaca się przy wielu wartościach naraz.
🐢
Nie w bardzo długich pętlach
Tworzenie nowego strumienia dla każdej z miliona linii kosztuje. Przy naprawdę dużych danych czytaj wprost przez cin.

Gotowy na więcej?

Dołącz do T-Olimpians i trenuj z doświadczonymi mentorami. Zbuduj bazę, która prowadzi do finałów OI.