C++ String-Streams: Parsen und Erstellen mit stringstream

Ein Stream, der in einer Zeichenkette lebt

Du kennst bereits cin und cout - Streams, die an Tastatur und Bildschirm angebunden sind. Ein String-Stream ist dieselbe Idee, nur dass die Daten stattdessen in einer std::string im Speicher leben. Du schreibst mit << hinein und ziehst Werte mit >> heraus, genau wie bei den Konsolen-Streams, aber nichts berührt das Terminal.

Diese eine Idee löst zwei alltägliche Probleme: Text in typisierte Werte zu parsen und aus gemischten Bausteinen eine formatierte Zeichenkette zu erstellen. Alles lebt im Header <sstream> und kommt in drei Varianten:

• istringstream - nur lesend, zum Parsen von Eingaben.
• ostringstream - nur schreibend, zum Erstellen von Ausgaben.
• stringstream - in beide Richtungen.

#include <iostream>
#include <sstream>
#include <string>
using namespace std;

int main() {
    stringstream ss;
    ss << "score: " << 42 << ", level: " << 7;

    cout << ss.str() << "\n";   // den gesamten Puffer als Zeichenkette zurückholen
}

ss.str() gibt alles bisher Geschriebene als einfache string zurück. Die <<-Operatoren haben dieselbe int-zu-Text-Formatierung vorgenommen wie cout - du hast das Ergebnis nur erfasst, anstatt es auszugeben.

Parsen: typisierte Werte herausziehen

Die wahre Stärke zeigt sich mit >>. Gib einem Stream etwas Text, und die Extraktion wandelt jedes Token in den von dir angeforderten Typ um, wobei Leerzeichen dazwischen übersprungen werden. So zerlegt man sauber eine Zeile in mehrere typisierte Felder:

#include <iostream>
#include <sstream>
#include <string>
using namespace std;

int main() {
    string line = "Ada 36 5.5";
    istringstream iss(line);

    string name;
    int age;
    double rating;
    iss >> name >> age >> rating;   // jedes >> greift das nächste durch Leerzeichen getrennte Token

    cout << name << " is " << age << " (rated " << rating << ")\n";
}

Jedes >> liest bis zum nächsten Leerzeichen und konvertiert: "Ada" in eine string, "36" in ein int, "5.5" in ein double. Beachte hier das istringstream - der reine Eingabetyp macht deutlich, dass du nur parst.

Zeichenketten in Zahlen umwandeln (sicher)

Eine häufige Aufgabe ist es, eine einzelne Zeichenkette wie "42" in ein int zu verwandeln. Ein stringstream erledigt das und sagt dir, ob der Text tatsächlich eine gültige Zahl war - was atoi nie tut:

#include <iostream>
#include <sstream>
#include <string>
using namespace std;

int main() {
    string text = "123abc";

    stringstream ss(text);
    int value;
    if (ss >> value) {
        cout << "Parsed: " << value << "\n";
    } else {
        cout << "Not a valid number\n";
    }

    cout << "Got " << value << " from \"" << text << "\"\n";
}

Hier liest ss >> value 123, hält beim a an und ist erfolgreich - validiere daher immer die gesamte Zeichenkette, wenn das wichtig ist. Eine robuste Prüfung besteht darin, die Zahl zu lesen und dann zu bestätigen, dass nichts Bedeutsames übrig bleibt. Für unkomplizierte Einzelwert-Umwandlungen sind std::stoi, std::stod und Verwandte (zusammen mit der Typumwandlung behandelt) kürzer; greife zu stringstream, wenn eine Zeichenkette mehrere gemischte Werte trägt.

Eine Zeichenkette an einem Trennzeichen aufteilen

Text aufzuteilen ist die am häufigsten gegoogelte String-Stream-Aufgabe. Kombiniere einen Stream mit std::getline, das bis zu jedem Trennzeichen lesen kann, nicht nur bis zu einem Zeilenumbruch:

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;

int main() {
    string csv = "red,green,blue,yellow";
    stringstream ss(csv);

    vector<string> parts;
    string token;
    while (getline(ss, token, ',')) {   // das dritte Argument ist das Trennzeichen
        parts.push_back(token);
    }

    for (const string& p : parts) cout << "[" << p << "] ";
    cout << "\n";
}

Das Muster while (getline(...)) läuft in einer Schleife, bis der Stream leer ist, denn getline gibt den Stream zurück, und der Stream wird zu false ausgewertet, sobald nichts mehr übrig ist. Lässt du das dritte Argument weg, teilst du stattdessen mit >> an durch Leerzeichen getrennten Tokens auf - wähle das Trennzeichen, das deine Daten verwenden.

Zeichenketten im Speicher erstellen

In die andere Richtung setzt ostringstream eine formatierte Zeichenkette zusammen, ohne das Pufferüberlauf-Risiko von sprintf oder die fragile manuelle Verkettung. Es eignet sich perfekt für Logzeilen, Dateinamen oder Nachrichten, die aus Zahlen und Text zusammengesetzt sind:

#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
using namespace std;

int main() {
    int day = 5, month = 6, year = 2026;

    ostringstream oss;
    oss << year << "-"
        << setw(2) << setfill('0') << month << "-"
        << setw(2) << setfill('0') << day;

    string filename = "backup_" + oss.str() + ".zip";
    cout << filename << "\n";   // backup_2026-06-05.zip
}

Die gesamte <iomanip>-Formatierung, die du mit cout verwenden würdest - setw, setfill, setprecision, hex - funktioniert auf einem String-Stream identisch, sodass du aufgefüllte, festbreitige oder hexadezimale Ausgabe direkt in eine string erfasst bekommst.

Der Stolperstein: vor der Wiederverwendung zurücksetzen

Die Falle, in die jeder tappt, ist, einen Stream ohne Zurücksetzen wiederzuverwenden. Sobald ein Stream das Ende seiner Daten erreicht, rasten seine eof- und fail-Flags ein, und jedes spätere >> tut stillschweigend nichts - kein Fehler, nur veraltete Werte:

stringstream ss("10");
int a, b;
ss >> a;            // a = 10, Stream jetzt am Ende -> eof-Flag gesetzt
ss.str("20");       // neuen Text laden...
ss >> b;            // SCHLÄGT STILL FEHL - die Fehlerflags sind noch gesetzt, b bleibt unverändert

Du musst den Fehlerzustand und den Inhalt löschen. Die richtige Reihenfolge ist zuerst clear(), dann str():

#include <iostream>
#include <sstream>
using namespace std;

int main() {
    stringstream ss("10");
    int a, b;
    ss >> a;

    ss.clear();      // eof/fail-Flags zurücksetzen
    ss.str("20");    // den Puffer ersetzen
    ss >> b;

    cout << a << " " << b << "\n";   // 10 20
}

Zwei verwandte Fehler: ss.clear() setzt die Flags zurück, leert aber den Puffer nicht (dafür ss.str("") verwenden), und ein stringstream, an den du fortlaufend mit << anhängst, wächst immer weiter - erstelle innerhalb einer Schleife einen frischen, statt für jede Iteration einen verschmutzten wiederzuverwenden.

Als Nächstes: Arrays

String-Streams haben dir eine saubere Möglichkeit gegeben, Text in typisierte Werte und wieder zurück zu verwandeln - oft eine ganze Liste davon, wie der vector, den du beim Aufteilen von CSV gefüllt hast. Um feste Sammlungen dieser Werte zu speichern und zu indizieren, brauchst du den grundlegendsten Container der Sprache. Als Nächstes behandeln wir Arrays: wie man sie deklariert, indiziert, über sie iteriert und den Zugriff außerhalb der Grenzen umgeht, der in C++ so viel undefiniertes Verhalten verursacht.