Streams de string em C++: análise e construção com stringstream

Um stream que vive em uma string

Você já conhece cin e cout - streams ligados ao teclado e à tela. Um stream de string é a mesma ideia, exceto que os dados vivem em uma std::string na memória. Você escreve nele com << e extrai valores com >>, exatamente como nos streams do console, mas nada toca o terminal.

Essa única ideia resolve dois problemas do dia a dia: analisar texto, separando-o em valores tipados, e construir uma string formatada a partir de pedaços misturados. Tudo vive no cabeçalho <sstream> e vem em três variações:

• istringstream - somente leitura, para analisar entrada.
• ostringstream - somente escrita, para construir saída.
• stringstream - nas duas direções.

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

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

    cout << ss.str() << "\n";   // recupera todo o buffer como uma string
}

ss.str() retorna tudo o que foi escrito até agora como uma string simples. Os operadores << fizeram a mesma formatação de int para texto que o cout faz - você apenas capturou o resultado em vez de imprimi-lo.

Análise: extrair valores tipados

O verdadeiro poder aparece com >>. Forneça algum texto a um stream e a extração converte cada token para o tipo que você pedir, pulando os espaços em branco entre eles. Esta é a maneira limpa de quebrar uma linha em vários campos tipados:

#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;   // cada >> pega o próximo token separado por espaços

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

Cada >> lê até o próximo espaço em branco e converte: "Ada" em uma string, "36" em um int, "5.5" em um double. Repare no istringstream aqui - o tipo somente de entrada deixa claro que você está apenas analisando.

Convertendo strings em números (com segurança)

Uma tarefa frequente é transformar uma única string como "42" em um int. Um stringstream faz isso e informa se o texto era realmente um número válido - algo que atoi nunca faz:

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

Aqui ss >> value lê 123, para no a e tem sucesso - então sempre valide a string inteira se isso for importante. Uma verificação robusta é ler o número e depois confirmar que nada significativo sobrou. Para conversões simples de valor único, std::stoi, std::stod e companhia (explicados junto com a conversão de tipos) são mais curtos; recorra ao stringstream quando uma string carregar vários valores misturados.

Dividindo uma string por um delimitador

Dividir texto é a tarefa de stream de string mais buscada no Google. Combine um stream com std::getline, que pode ler até qualquer caractere delimitador, não apenas uma quebra de linha:

#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, ',')) {   // o terceiro argumento é o delimitador
        parts.push_back(token);
    }

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

O padrão while (getline(...)) repete até o stream se esgotar, porque getline retorna o stream e o stream é avaliado como false quando não sobra nada. Remova o terceiro argumento e você dividirá por tokens separados por espaços com >> - escolha o delimitador que seus dados usam.

Construindo strings na memória

No caminho inverso, ostringstream monta uma string formatada sem o risco de estouro de buffer do sprintf nem a frágil concatenação manual. É perfeito para linhas de log, nomes de arquivo ou mensagens montadas a partir de números e texto:

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

Toda a formatação de <iomanip> que você usaria com cout - setw, setfill, setprecision, hex - funciona de forma idêntica em um stream de string, então você obtém saída preenchida, de largura fixa ou em hexadecimal capturada diretamente em uma string.

A pegadinha: reinicie antes de reutilizar

A armadilha que pega todo mundo é reutilizar um stream sem reiniciá-lo. Quando um stream chega ao fim de seus dados, suas flags eof e fail ficam travadas, e todo >> posterior não faz nada silenciosamente - sem erro, apenas valores obsoletos:

stringstream ss("10");
int a, b;
ss >> a;            // a = 10, o stream agora no fim -> flag eof ativada
ss.str("20");       // carrega novo texto...
ss >> b;            // FALHA SILENCIOSAMENTE - as flags de erro ainda estão ativas, b não muda

Você precisa limpar o estado de erro e o conteúdo. A ordem correta é clear() primeiro, depois str():

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

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

    ss.clear();      // reinicia as flags eof/fail
    ss.str("20");    // substitui o buffer
    ss >> b;

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

Dois erros relacionados: ss.clear() reinicia as flags mas não esvazia o buffer (use ss.str("") para isso), e um stringstream ao qual você continua acrescentando com << vai continuar crescendo - crie um novo dentro do laço em vez de reutilizar um sujo a cada iteração.

A seguir: Arrays

Os streams de string lhe deram uma forma limpa de transformar texto em valores tipados e de volta - muitas vezes uma lista inteira deles, como o vector que você preencheu ao dividir o CSV. Para armazenar e indexar coleções fixas desses valores, você precisa do container mais fundamental da linguagem. A seguir veremos os arrays: como declará-los, indexá-los, percorrê-los e evitar o acesso fora dos limites que causa tanto comportamento indefinido em C++.