Flujos de cadenas en C++: análisis y construcción con stringstream

Un flujo que vive en una cadena

Ya conoces cin y cout: flujos conectados al teclado y a la pantalla. Un flujo de cadena es la misma idea, salvo que los datos viven en una std::string en memoria. Escribes en él con << y extraes valores con >>, exactamente igual que con los flujos de consola, pero nada toca la terminal.

Esa única idea resuelve dos problemas cotidianos: analizar texto separándolo en valores tipados y construir una cadena formateada a partir de piezas mezcladas. Todo vive en la cabecera <sstream> y viene en tres variantes:

• istringstream - solo lectura, para analizar entrada.
• ostringstream - solo escritura, para construir salida.
• stringstream - en ambas direcciones.

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

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

    cout << ss.str() << "\n";   // recupera todo el búfer como una cadena
}

ss.str() devuelve todo lo escrito hasta ahora como una string simple. Los operadores << hicieron el mismo formateo de int a texto que hace cout; solo que capturaste el resultado en lugar de imprimirlo.

Análisis: extraer valores tipados

El verdadero poder aparece con >>. Dale algo de texto a un flujo y la extracción convierte cada token al tipo que pidas, saltando los espacios en blanco intermedios. Esta es la forma limpia de dividir una línea en varios 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 >> toma el siguiente token separado por espacios

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

Cada >> lee hasta el siguiente espacio en blanco y convierte: "Ada" a una string, "36" a un int, "5.5" a un double. Fíjate en istringstream aquí: el tipo de solo entrada deja claro que únicamente estás analizando.

Convertir cadenas a números (de forma segura)

Una tarea frecuente es convertir una sola cadena como "42" en un int. Un stringstream lo hace, y además te dice si el texto era realmente un número válido, algo que atoi nunca hace:

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

Aquí ss >> value lee 123, se detiene en la a y tiene éxito, así que valida siempre la cadena completa si eso importa. Una comprobación robusta consiste en leer el número y luego confirmar que no queda nada significativo. Para conversiones sencillas de un solo valor, std::stoi, std::stod y compañía (explicados junto al casteo de tipos) son más cortos; recurre a stringstream cuando una cadena contenga varios valores mezclados.

Dividir una cadena por un delimitador

Dividir texto es la tarea de flujos de cadenas más buscada en Google. Combina un flujo con std::getline, que puede leer hasta cualquier carácter delimitador, no solo un salto de línea:

#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, ',')) {   // el tercer argumento es el delimitador
        parts.push_back(token);
    }

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

El patrón while (getline(...)) itera hasta que el flujo se agota, porque getline devuelve el flujo y este se evalúa como false cuando no queda nada. Quita el tercer argumento y dividirás por tokens separados por espacios con >>; elige el delimitador que use tu información.

Construir cadenas en memoria

En sentido inverso, ostringstream arma una cadena formateada sin el riesgo de desbordamiento de búfer de sprintf ni la frágil concatenación manual. Es perfecto para líneas de registro, nombres de archivo o mensajes compuestos de números y 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
}

Todo el formateo de <iomanip> que usarías con cout - setw, setfill, setprecision, hex - funciona de forma idéntica en un flujo de cadena, así que obtienes salida rellenada, de ancho fijo o en hexadecimal capturada directamente en una string.

El detalle: restablece antes de reutilizar

La trampa que atrapa a todos es reutilizar un flujo sin restablecerlo. Una vez que un flujo llega al final de sus datos, sus indicadores eof y fail se quedan activados, y cada >> posterior no hace nada en silencio: ningún error, solo valores obsoletos:

stringstream ss("10");
int a, b;
ss >> a;            // a = 10, el flujo ahora al final -> indicador eof activado
ss.str("20");       // carga texto nuevo...
ss >> b;            // FALLA EN SILENCIO - los indicadores de error siguen activos, b no cambia

Debes limpiar el estado de error y el contenido. El orden correcto es clear() primero, luego str():

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

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

    ss.clear();      // restablece los indicadores eof/fail
    ss.str("20");    // reemplaza el búfer
    ss >> b;

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

Dos errores relacionados: ss.clear() restablece los indicadores pero no vacía el búfer (usa ss.str("") para eso), y un stringstream al que sigues añadiendo con << seguirá creciendo: crea uno nuevo dentro del bucle en lugar de reutilizar uno sucio en cada iteración.

Siguiente: Arreglos

Los flujos de cadenas te dieron una forma limpia de convertir texto en valores tipados y viceversa, a menudo una lista entera de ellos, como el vector que llenaste al dividir el CSV. Para almacenar e indexar colecciones fijas de esos valores, necesitas el contenedor más fundamental del lenguaje. A continuación veremos los arreglos: cómo declararlos, indexarlos, recorrerlos y evitar el acceso fuera de límites que causa tanto comportamiento indefinido en C++.