Comment diviser une chaîne séparée par des virgules en C++

Pour une chaîne simple délimitée par des virgules, std::stringstream avec std::getline est un moyen simple de collecter chaque valeur dans un std::vector<std::string>. Si vous devez contrôler la manière dont chaque fragment est extrait, std::string::find et std::string::substr offrent une alternative manuelle. Ces approches divisent sur un délimiteur ; elles n’analysent pas la syntaxe CSV complète, comme les virgules à l’intérieur de champs entre guillemets.

Diviser une chaîne séparée par des virgules avec std::stringstream et std::getline

Incluez <sstream> pour construire un flux à partir de la chaîne d’entrée, et <vector> pour stocker les fragments. Passez la virgule comme troisième argument à std::getline ; chaque appel lit jusqu’à ce délimiteur et place le texte extrait dans item. La boucle ajoute chaque élément au vecteur, puis affiche les valeurs collectées.

Utilisez std::vector<std::string> lorsque le code ultérieur doit indexer les jetons ou les parcourir à nouveau ; il stocke chaque valeur extraite sous forme de chaîne distincte dans l’ordre d’entrée.

#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

Cet exemple utilise une virgule comme délimiteur et stocke les quatre chaînes extraites dans l’ordre. std::getline avec un délimiteur peut produire un élément vide entre des virgules consécutives, tandis qu’un délimiteur tout à la fin ne produit pas d’élément final dans cette boucle. Si votre entrée nécessite un traitement différent pour ces cas, décidez de la signification de chaque position de délimiteur et tenez-en compte dans la logique d’analyse. Les chaînes extraites conservent les espaces qui font partie de l’entrée ; supprimez donc les espaces de chaque élément séparément si les espaces environnants doivent être écartés. Modifiez l’argument du délimiteur lorsque la source utilise un autre caractère unique, comme un point-virgule.

Diviser une chaîne séparée par des virgules avec std::string::find et std::string::substr

Le membre std::string::find localise la virgule suivante, et std::string::substr copie les caractères qui la précèdent. Conservez un index de départ dans l’entrée d’origine au lieu d’effacer les caractères au fur et à mesure. Lorsque find renvoie std::string::npos, il n’y a plus de virgules ; prenez donc le suffixe restant comme élément final et arrêtez-vous.

#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

L’appel final à substr(start) est important : il ajoute le texte situé après la dernière virgule, y compris la dernière valeur lorsqu’il n’y a plus de délimiteurs. Cette version traite également une entrée se terminant par une virgule comme ayant un élément final vide, contrairement à la boucle de flux ci-dessus. Pour une entrée entièrement vide, elle stocke également une chaîne vide ; ajustez donc la condition de la boucle si votre application doit traiter cette entrée comme n’ayant aucune valeur. La recherche commence au caractère qui suit chaque virgule, ce qui évite de modifier l’entrée pendant l’analyse et permet de conserver facilement la chaîne d’origine pour une utilisation ultérieure. Aucune des deux approches ne gère les virgules entre guillemets ni les guillemets échappés ; utilisez un analyseur CSV lorsque ces règles font partie du format d’entrée.