28.4 — Stream classes for strings

In this lesson, you'll learn about string streams - a powerful feature that allows you to perform stream operations on strings in memory. You'll discover how to use std::stringstream, std::istringstream, and std::ostringstream for data conversion, parsing, and formatting.

What are string streams?

String streams allow you to treat strings as streams, enabling you to use all the familiar stream operations (<<, >>, formatting manipulators) on string data stored in memory instead of reading from/writing to external sources like files or the console.

Think of string streams as virtual files that exist only in memory, where you can read from and write to strings using the same techniques you use with std::cin and std::cout.

The header

To use string streams, you need to include the <sstream> header:

#include <iostream>
#include <sstream>
#include <string>

int main()
{
    std::stringstream ss;
    ss << "Hello, " << "World!";
    
    std::string result = ss.str();
    std::cout << result << std::endl;
    
    return 0;
}

Output:

Hello, World!

Types of string streams

std::ostringstream (Output String Stream)

Used for writing data to a string:

#include <iostream>
#include <sstream>
#include <iomanip>

int main()
{
    std::ostringstream oss;
    
    std::string name = "Alice";
    int age = 25;
    double height = 5.6;
    
    oss << "Name: " << name << ", Age: " << age 
        << ", Height: " << std::fixed << std::setprecision(1) << height << " ft";
    
    std::string result = oss.str();
    std::cout << result << std::endl;
    
    return 0;
}

Output:

Name: Alice, Age: 25, Height: 5.6 ft

std::istringstream (Input String Stream)

Used for reading data from a string:

#include <iostream>
#include <sstream>

int main()
{
    std::string data = "42 3.14 Hello World";
    std::istringstream iss(data);
    
    int number;
    double decimal;
    std::string word1, word2;
    
    iss >> number >> decimal >> word1 >> word2;
    
    std::cout << "Number: " << number << std::endl;
    std::cout << "Decimal: " << decimal << std::endl;
    std::cout << "Words: " << word1 << " " << word2 << std::endl;
    
    return 0;
}

Output:

Number: 42
Decimal: 3.14
Words: Hello World

std::stringstream (Bidirectional String Stream)

Can be used for both reading and writing:

#include <iostream>
#include <sstream>

int main()
{
    std::stringstream ss;
    
    // Write to the stream
    ss << "100 200 300";
    
    // Read from the stream
    int a, b, c;
    ss >> a >> b >> c;
    
    std::cout << "Read values: " << a << ", " << b << ", " << c << std::endl;
    std::cout << "Sum: " << (a + b + c) << std::endl;
    
    return 0;
}

Output:

Read values: 100, 200, 300
Sum: 600

Data conversion with string streams

String streams are excellent for converting between different data types:

Converting numbers to strings

#include <iostream>
#include <sstream>
#include <iomanip>

std::string numberToString(int number)
{
    std::ostringstream oss;
    oss << number;
    return oss.str();
}

std::string doubleToString(double value, int precision)
{
    std::ostringstream oss;
    oss << std::fixed << std::setprecision(precision) << value;
    return oss.str();
}

int main()
{
    int age = 25;
    double price = 19.99;
    
    std::string ageStr = numberToString(age);
    std::string priceStr = doubleToString(price, 2);
    
    std::cout << "Age as string: '" << ageStr << "'" << std::endl;
    std::cout << "Price as string: '$" << priceStr << "'" << std::endl;
    
    return 0;
}

Output:

Age as string: '25'
Price as string: '$19.99'

Converting strings to numbers

#include <iostream>
#include <sstream>

template<typename T>
bool stringToNumber(const std::string& str, T& result)
{
    std::istringstream iss(str);
    iss >> result;
    
    // Check if conversion was successful and entire string was consumed
    return !iss.fail() && iss.eof();
}

int main()
{
    std::string numberStr = "42";
    std::string decimalStr = "3.14159";
    std::string invalidStr = "abc123";
    
    int number;
    double decimal;
    int invalid;
    
    if (stringToNumber(numberStr, number))
    {
        std::cout << "Converted '" << numberStr << "' to " << number << std::endl;
    }
    
    if (stringToNumber(decimalStr, decimal))
    {
        std::cout << "Converted '" << decimalStr << "' to " << decimal << std::endl;
    }
    
    if (!stringToNumber(invalidStr, invalid))
    {
        std::cout << "Failed to convert '" << invalidStr << "'" << std::endl;
    }
    
    return 0;
}

Output:

Converted '42' to 42
Converted '3.14159' to 3.14159
Failed to convert 'abc123'

Parsing structured data

String streams are excellent for parsing structured data:

Parsing CSV data

#include <iostream>
#include <sstream>
#include <vector>

std::vector<std::string> splitCSV(const std::string& line)
{
    std::vector<std::string> result;
    std::istringstream iss(line);
    std::string field;
    
    while (std::getline(iss, field, ','))
    {
        result.push_back(field);
    }
    
    return result;
}

int main()
{
    std::string csvLine = "John,Doe,30,Engineer";
    
    std::vector<std::string> fields = splitCSV(csvLine);
    
    std::cout << "Parsed fields:" << std::endl;
    for (size_t i = 0; i < fields.size(); ++i)
    {
        std::cout << i + 1 << ": " << fields[i] << std::endl;
    }
    
    return 0;
}

Output:

Parsed fields:
1: John
2: Doe
3: 30
4: Engineer

Parsing key-value pairs

#include <iostream>
#include <sstream>
#include <map>

std::map<std::string, std::string> parseKeyValue(const std::string& data)
{
    std::map<std::string, std::string> result;
    std::istringstream iss(data);
    std::string line;
    
    while (std::getline(iss, line))
    {
        size_t pos = line.find('=');
        if (pos != std::string::npos)
        {
            std::string key = line.substr(0, pos);
            std::string value = line.substr(pos + 1);
            result[key] = value;
        }
    }
    
    return result;
}

int main()
{
    std::string config = "name=Alice\nage=25\ncity=New York\n";
    
    auto kvPairs = parseKeyValue(config);
    
    std::cout << "Configuration:" << std::endl;
    for (const auto& pair : kvPairs)
    {
        std::cout << pair.first << " = " << pair.second << std::endl;
    }
    
    return 0;
}

Output:

Configuration:
age = 25
city = New York
name = Alice

String stream operations

Clearing and reusing string streams

#include <iostream>
#include <sstream>

int main()
{
    std::stringstream ss;
    
    // First use
    ss << "First message";
    std::cout << "First: " << ss.str() << std::endl;
    
    // Clear content and reset state
    ss.str("");           // Clear the content
    ss.clear();           // Clear any error flags
    
    // Second use
    ss << "Second message";
    std::cout << "Second: " << ss.str() << std::endl;
    
    return 0;
}

Output:

First: First message
Second: Second message

Getting and setting string stream content

#include <iostream>
#include <sstream>

int main()
{
    std::stringstream ss;
    
    // Set initial content
    ss.str("Initial content");
    std::cout << "Initial: " << ss.str() << std::endl;
    
    // Add more content
    ss << " + additional text";
    std::cout << "Modified: " << ss.str() << std::endl;
    
    // Replace content completely
    ss.str("Completely new content");
    std::cout << "Replaced: " << ss.str() << std::endl;
    
    return 0;
}

Output:

Initial: Initial content
Modified: Initial content + additional text
Replaced: Completely new content

Practical applications

Building formatted messages

#include <iostream>
#include <sstream>
#include <iomanip>
#include <vector>

std::string createReport(const std::vector<std::pair<std::string, double>>& sales)
{
    std::ostringstream oss;
    
    oss << "Sales Report" << std::endl;
    oss << "============" << std::endl;
    
    double total = 0;
    for (const auto& sale : sales)
    {
        oss << std::left << std::setw(15) << sale.first 
            << std::right << std::fixed << std::setprecision(2) 
            << "$" << std::setw(8) << sale.second << std::endl;
        total += sale.second;
    }
    
    oss << std::string(24, '-') << std::endl;
    oss << std::left << std::setw(15) << "Total" 
        << std::right << "$" << std::setw(8) << total << std::endl;
    
    return oss.str();
}

int main()
{
    std::vector<std::pair<std::string, double>> sales = {
        {"Product A", 125.50},
        {"Product B", 89.99},
        {"Product C", 200.00}
    };
    
    std::string report = createReport(sales);
    std::cout << report << std::endl;
    
    return 0;
}

Output:

Sales Report
============
Product A      $  125.50
Product B      $   89.99
Product C      $  200.00
------------------------
Total          $  415.49

URL parameter parsing

#include <iostream>
#include <sstream>
#include <map>

std::map<std::string, std::string> parseURL(const std::string& url)
{
    std::map<std::string, std::string> parameters;
    
    size_t questionPos = url.find('?');
    if (questionPos == std::string::npos)
        return parameters;
    
    std::string queryString = url.substr(questionPos + 1);
    std::istringstream iss(queryString);
    std::string pair;
    
    while (std::getline(iss, pair, '&'))
    {
        size_t equalPos = pair.find('=');
        if (equalPos != std::string::npos)
        {
            std::string key = pair.substr(0, equalPos);
            std::string value = pair.substr(equalPos + 1);
            parameters[key] = value;
        }
    }
    
    return parameters;
}

int main()
{
    std::string url = "https://example.com/search?q=C++&category=programming&sort=date";
    
    auto params = parseURL(url);
    
    std::cout << "URL Parameters:" << std::endl;
    for (const auto& param : params)
    {
        std::cout << param.first << " = " << param.second << std::endl;
    }
    
    return 0;
}

Output:

URL Parameters:
category = programming
q = C++
sort = date

String stream vs traditional string operations

Concatenation comparison

#include <iostream>
#include <sstream>
#include <string>

int main()
{
    // Traditional string concatenation
    std::string traditional;
    traditional += "Name: ";
    traditional += "Alice";
    traditional += ", Age: ";
    traditional += std::to_string(25);
    traditional += ", Score: ";
    traditional += std::to_string(95.5);
    
    // String stream approach
    std::ostringstream oss;
    oss << "Name: " << "Alice" << ", Age: " << 25 << ", Score: " << 95.5;
    
    std::cout << "Traditional: " << traditional << std::endl;
    std::cout << "Stream: " << oss.str() << std::endl;
    
    return 0;
}

Output:

Traditional: Name: Alice, Age: 25, Score: 95.5
Stream: Name: Alice, Age: 25, Score: 95.5

Error handling with string streams

#include <iostream>
#include <sstream>

template<typename T>
bool safeExtract(std::istringstream& iss, T& value)
{
    iss >> value;
    return !iss.fail();
}

int main()
{
    std::string data = "42 abc 3.14 true";
    std::istringstream iss(data);
    
    int number;
    int invalidNumber;
    double decimal;
    bool flag;
    
    if (safeExtract(iss, number))
    {
        std::cout << "Successfully read number: " << number << std::endl;
    }
    
    if (!safeExtract(iss, invalidNumber))
    {
        std::cout << "Failed to read invalid number" << std::endl;
        // Clear error state and skip bad input
        iss.clear();
        std::string badInput;
        iss >> badInput;  // Skip the bad input
    }
    
    if (safeExtract(iss, decimal))
    {
        std::cout << "Successfully read decimal: " << decimal << std::endl;
    }
    
    if (safeExtract(iss, flag))
    {
        std::cout << "Successfully read boolean: " << flag << std::endl;
    }
    
    return 0;
}

Output:

Successfully read number: 42
Failed to read invalid number
Successfully read decimal: 3.14
Successfully read boolean: 1

Best practices for string streams

✅ Good practices:

#include <iostream>
#include <sstream>

int main()
{
    // Clear and reuse string streams properly
    std::stringstream ss;
    
    for (int i = 1; i <= 3; ++i)
    {
        ss.str("");        // Clear content
        ss.clear();        // Clear error flags
        
        ss << "Message " << i;
        std::cout << ss.str() << std::endl;
    }
    
    // Use appropriate stream type for the task
    std::ostringstream output_only;  // For output only
    std::istringstream input_only("input data");  // For input only
    
    return 0;
}

❌ Common mistakes:

#include <iostream>
#include <sstream>

int main()
{
    std::stringstream ss;
    
    // Bad: Not clearing between uses
    ss << "First";
    std::cout << ss.str() << std::endl;
    
    ss << " Second";  // Appends to existing content
    std::cout << ss.str() << std::endl;  // Shows "First Second"
    
    // Bad: Not checking extraction success
    std::istringstream iss("abc");
    int number;
    iss >> number;  // This will fail
    std::cout << number << std::endl;  // Undefined behavior!
    
    return 0;
}

Summary

String streams provide powerful in-memory stream operations:

• std::ostringstream for writing data to strings with formatting
• std::istringstream for reading data from strings with parsing
• std::stringstream for bidirectional string operations
• Data conversion between strings and other types
• Structured data parsing for CSV, key-value pairs, etc.
• Formatted string building for reports and messages
• Error handling to ensure robust parsing operations

String streams combine the flexibility of string manipulation with the power of stream formatting, making them invaluable for data processing, configuration parsing, and formatted output generation.

Quiz

1. What's the difference between std::ostringstream, std::istringstream, and std::stringstream?
2. How do you clear both the content and error state of a string stream?
3. What advantage do string streams have over simple string concatenation?
4. How can you check if a string-to-number conversion was successful?
5. When would you choose std::istringstream over direct string parsing methods?

Practice exercises

Apply your string stream knowledge with these exercises:

1. Log Parser: Create a program that parses log entries in the format "TIMESTAMP LEVEL MESSAGE" and extracts each component.

2. Configuration Reader: Build a configuration file parser that reads key-value pairs from a string and handles different data types.

3. Data Formatter: Write a function that takes various data types and creates a formatted string representation suitable for display in a table.

4. Expression Evaluator: Create a simple calculator that parses and evaluates mathematical expressions from strings (e.g., "2 + 3 * 4").