C++ String Streams: stringstream Parsing & Building

A Stream That Lives in a String

You already know cin and cout - streams wired to the keyboard and the screen. A string stream is the same idea, except the data lives in an in-memory std::string instead. You write into it with << and pull values out with >>, exactly like the console streams, but nothing touches the terminal.

That single idea solves two everyday problems: parsing text apart into typed values, and building a formatted string out of mixed pieces. Everything lives in the <sstream> header and comes in three flavors:

• istringstream - read-only, for parsing input.
• ostringstream - write-only, for building output.
• stringstream - both directions.

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

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

    cout << ss.str() << "\n";   // pull the whole buffer back out as a string
}

ss.str() returns everything written so far as a plain string. The << operators did the same int-to-text formatting that cout does - you just captured the result instead of printing it.

Parsing: Pull Typed Values Out

The real power shows up with >>. Feed a stream some text and extraction converts each token into the type you ask for, skipping whitespace between them. This is the clean way to break one line into several typed fields:

#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;   // each >> grabs the next whitespace-separated token

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

Each >> reads up to the next whitespace and converts: "Ada" into a string, "36" into an int, "5.5" into a double. Note istringstream here - the input-only type makes it clear you're only parsing.

Converting Strings to Numbers (Safely)

A frequent job is turning a single string like "42" into an int. A stringstream does it, and tells you whether the text was actually a valid number - which atoi never does:

#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";
}

Here ss >> value reads 123, stops at the a, and succeeds - so always validate the whole string if that matters. A robust check is to read the number and then confirm nothing meaningful is left over. For straightforward single-value conversions, std::stoi, std::stod, and friends are shorter; reach for stringstream when one string carries several mixed values.

Splitting a String on a Delimiter

Splitting text is the most-Googled string-stream task. Combine a stream with std::getline, which can read up to any delimiter character, not just a newline:

#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, ',')) {   // third arg is the delimiter
        parts.push_back(token);
    }

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

The while (getline(...)) pattern loops until the stream runs dry, because getline returns the stream and the stream tests as false once there's nothing left. Each token is pushed onto a vector, the natural place to collect a variable number of split pieces. Drop the third argument and you split on whitespace tokens with >> instead - pick whichever delimiter your data uses.

Building Strings in Memory

Going the other way, ostringstream assembles a formatted string without sprintf's buffer-overflow risk or fragile manual concatenation. It's perfect for log lines, file names, or messages stitched from numbers and text:

#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
}

All the <iomanip> formatting you'd use with cout - setw, setfill, setprecision, hex - works identically on a string stream, so you get padded, fixed-width, or hex output captured straight into a string.

The Gotcha: Reset Before Reusing

The trap that bites everyone is reusing a stream without resetting it. Once a stream reaches the end of its data, its eof and fail flags latch on, and every later >> silently does nothing - no error, just stale values:

stringstream ss("10");
int a, b;
ss >> a;            // a = 10, stream now at end -> eof flag set
ss.str("20");       // load new text...
ss >> b;            // FAILS SILENTLY - error flags are still set, b is unchanged

You must clear the error state and the contents. The right order is clear() first, then str():

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

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

    ss.clear();      // reset eof/fail flags
    ss.str("20");    // replace the buffer
    ss >> b;

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

Two related mistakes: ss.clear() resets the flags but does not empty the buffer (use ss.str("") for that), and a stringstream you keep appending to with << will keep growing - create a fresh one inside a loop rather than reusing a dirty one for each iteration.

Next: Arrays

String streams gave you a clean way to turn text into typed values and back again - often a whole list of them, like the vector you filled while splitting CSV. To store and index fixed collections of those values, you need the most fundamental container in the language. Next we'll cover arrays: how to declare them, index into them, loop over them, and sidestep the out-of-bounds access that causes so much undefined behavior in C++.