Cómo dividir una cadena separada por comas en C++

Para una cadena sencilla delimitada por comas, std::stringstream con std::getline es una forma directa de recopilar cada valor en un std::vector<std::string>. Si necesita controlar cómo se extrae cada fragmento, std::string::find y std::string::substr ofrecen una alternativa manual. Estos enfoques dividen por un delimitador; no analizan la sintaxis CSV completa, como las comas dentro de campos entrecomillados.

Dividir una cadena separada por comas con std::stringstream y std::getline

Incluya <sstream> para construir un flujo a partir de la cadena de entrada y <vector> para almacenar los fragmentos. Pase la coma como tercer argumento a std::getline; cada llamada lee hasta ese delimitador y coloca el texto extraído en item. El bucle añade cada elemento al vector y luego imprime los valores recopilados.

Utilice std::vector<std::string> cuando el código posterior necesite indexar los tokens o iterar sobre ellos de nuevo; almacena cada valor extraído como una cadena independiente en el orden de entrada.

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

int main() {
    const std::string input = "apple,banana,cherry,dates";
    std::stringstream stream(input);
    std::vector<std::string> items;
    std::string item;

    while (std::getline(stream, item, ',')) {
        items.push_back(item);
    }

    for (const std::string& value : items) {
        std::cout << value << '\n';
    }
}

apple
banana
cherry
dates

Este ejemplo utiliza una coma como delimitador y almacena las cuatro cadenas extraídas en orden. std::getline con un delimitador puede producir un elemento vacío entre comas consecutivas, mientras que un delimitador al final no produce un elemento final en este bucle. Si su entrada necesita un tratamiento diferente para estos casos, decida qué debe significar cada posición del delimitador y téngalo en cuenta en la lógica de análisis. Las cadenas extraídas conservan los espacios que forman parte de la entrada, así que recorte cada elemento por separado si deben descartarse los espacios circundantes. Cambie el argumento del delimitador cuando la fuente utilice otro carácter único, como un punto y coma.

Dividir una cadena separada por comas con std::string::find y std::string::substr

El miembro std::string::find localiza la siguiente coma y std::string::substr copia los caracteres anteriores a ella. Mantenga un índice de inicio en la entrada original en lugar de borrar caracteres sobre la marcha. Cuando find devuelve std::string::npos, ya no hay más comas, así que tome el sufijo restante como elemento final y deténgase.

#include <iostream>
#include <string>
#include <vector>

int main() {
    const std::string input = "apple,banana,cherry,dates";
    std::vector<std::string> items;
    std::string::size_type start = 0;

    while (true) {
        const std::string::size_type comma = input.find(',', start);
        if (comma == std::string::npos) {
            items.push_back(input.substr(start));
            break;
        }

        items.push_back(input.substr(start, comma - start));
        start = comma + 1;
    }

    for (const std::string& value : items) {
        std::cout << value << '\n';
    }
}

apple
banana
cherry
dates

La llamada final a substr(start) es importante: añade el texto posterior a la última coma, incluido el último valor cuando ya no hay delimitadores. Esta versión también trata una entrada con una coma final como si tuviera un elemento final vacío, a diferencia del bucle de flujo anterior. Para una entrada completamente vacía, también almacena una cadena vacía, así que ajuste la condición del bucle si su aplicación debe tratar esa entrada como sin valores. La búsqueda comienza en el carácter posterior a cada coma, lo que evita modificar la entrada durante el análisis y facilita conservar la cadena original para un uso posterior. Ninguno de los enfoques gestiona comas entrecomilladas ni comillas escapadas; utilice un analizador CSV cuando esas reglas formen parte del formato de entrada.