Le découpage d'une ligne d'un fichier csv dans un std::vector?

J'ai une fonction qui va lire un fichier CSV ligne par ligne. Pour chaque ligne, il se divise, la ligne dans un vecteur. Le code pour faire cela est

    std::stringstream ss(sText);
    std::string item;

    while(std::getline(ss, item, ','))
    {
        m_vecFields.push_back(item);
    }

Cela fonctionne très bien sauf quand il lit une ligne où la dernière valeur est vide. Par exemple,

text1,tex2,

Je veux que ce retour d'un vecteur de taille 3, où la troisième valeur est tout simplement vide. Cependant, au lieu de cela elle retourne un vecteur de taille 2. Comment puis-je corriger cela?

double possible de CSV analyseur en C++
non, il n'est pas. Ce code fait exactement la même chose si la ligne se termine par une virgule
N'est pas le problème le délimiteur? std::getline extraits jusqu'à ce que le séparateur est trouvé. Mais pour ce dernier point, il n'y a pas de délimiteur suivant , rien n'est donc extrait et ainsi la boucle while se termine.
tout simplement parce que actuellement accepté de répondre a des défauts, ne signifie pas que la question ne traite pas le même problème de l'espace de manière adéquate - il y a d'autres réponses à travailler et peut être upvoted, et vous pouvez faire un commentaire à propos de problèmes avec des réponses précises.

OriginalL'auteur Jonnster | 2012-07-03

c++csv std vector

bool addEmptyLine = sText.back() == ',';

/* your code here */

if (addEmptyLine) m_vecFields.push_back("");

sText += ',';     //text1, text2,,

/* your code */

assert(m_vecFields.size() == 3);

Oui j'ai juste ajouté un code comme le premier exemple et revint à trouver quelqu'un avait suggéré. Ce n'est pas le plus propre code, mais ça fera l'affaire.

OriginalL'auteur jrok

4

Vous pouvez simplement utiliser boost::split à faire tout cela pour vous.

http://www.boost.org/doc/libs/1_50_0/doc/html/string_algo/usage.html#id3207193

Il a le comportement que vous avez besoin dans une seule ligne.

Exemple boost::split Code
```
#include <iostream>
#include <vector>
#include <boost/algorithm/string.hpp>

using namespace std;

int main()
{
    vector<string> strs;

    boost::split(strs, "please split,this,csv,,line,", boost::is_any_of(","));

    for ( vector<string>::iterator it = strs.begin(); it < strs.end(); it++ )
        cout << "\"" << *it << "\"" << endl;

    return 0;
}
```
Résultats
```
"please split"
"this"
"csv"
""
"line"
""
```
+1 pour les non-réponse théorique.
Acceptez-vous de retirer using namespace std comme une modification?
Pourquoi? using namespace std est une jolie chose normale à faire, n'est-ce pas? Je ne pense pas que la suppression réaliser quelque chose de @Seanny123, mais n'hésitez pas à le faire dans votre propre code.

OriginalL'auteur GrahamS

Vous pouvez utiliser une fonction similaire à ceci:

template <class InIt, class OutIt>
void Split(InIt begin, InIt end, OutIt splits)
{
    InIt current = begin;
    while (begin != end)
    {
        if (*begin == ',')
        {
            *splits++ = std::string(current,begin);
            current = ++begin;
        }
        else
            ++begin;
    }
    *splits++ = std::string(current,begin);
}

Il va parcourir la chaîne et chaque fois qu'il rencontre le délimiteur, il sera extrait de la chaîne et de le stocker dans les criques itérateur.

La partie intéressante est

lorsque le courant == commencer il va insérer une chaîne vide (cas de test: "texte1,tex2")
la dernière insertion des garanties, il y aura toujours le bon nombre d'éléments.
Si il y a une virgule, il va déclencher la puce précédente et ajouter une chaîne vide, sinon il faudra ajouter le dernier élément du vecteur.

Vous pouvez l'utiliser comme ceci:

std::stringstream ss(sText);
std::string item;
std::vector<std::string> m_vecFields;
while(std::getline(ss, item))
{
    Split(item.begin(), item.end(), std::back_inserter(m_vecFields));
}

std::for_each(m_vecFields.begin(), m_vecFields.end(), [](std::string& value)
{
    std::cout << value << std::endl;
});

OriginalL'auteur Julien Lebot

Solution Flexible pour l'analyse de fichiers csv:
où:

source - contenu du fichier CSV

le délimiteur de - CSV séparateur, par exemple. ',' ';'

std::vector<std::string> csv_split(std::string source, char delimeter) {
    std::vector<std::string> ret;
    std::string word = "";
    int start = 0;

    bool inQuote = false;
    for(int i=0; i<source.size(); ++i){
        if(inQuote == false && source[i] == '"'){
            inQuote = true;
            continue;
        }
        if(inQuote == true && source[i] == '"'){
            if(source.size() > i && source[i+1] == '"'){
                ++i;
            } else {
                inQuote = false;
                continue;
            }
        }

        if(inQuote == false && source[i] == delimeter){
            ret.push_back(word);
            word = "";
        } else {
            word += source[i];
        }
    }
    ret.push_back(word);

    return ret;
}

OriginalL'auteur Markoj

2

C++11, c'est extrêmement facile à manipuler, même échappé des virgules à l'aide regex_token_iterator:
```
std::stringstream ss(sText);
std::string item;
const regex re{"((?:[^\\\\,]|\\\\.)*?)(?:,|$)"};

std::getline(ss, item)

m_vecFields.insert(m_vecFields.end(), sregex_token_iterator(item.begin(), item.end(), re, 1), sregex_token_iterator());
```
D'ailleurs si vous avez simplement voulu construire un vector<string> à partir d'un CSV string comme item, vous pourriez faire:
```
const regex re{"((?:[^\\\\,]|\\\\.)*?)(?:,|$)"};
vector<string> m_vecFields{sregex_token_iterator(item.begin(), item.end(), re, 1), sregex_token_iterator()};
```
[Live Exemple]

Quelques explication rapide de la regex est probablement dans l'ordre. (?:[^\\\\,]|\\\\.) correspond à des caractères d'échappement ou de la non-',' caractères. (Voir ici pour plus d'info: https://stackoverflow.com/a/7902016/2642059) Le *? signifie qu'il n'est pas un gourmand match de, de sorte qu'il s'arrête à la première ',' atteint. Tout ce qui est imbriquée dans une capture, qui est sélectionné par le dernier paramètre, la 1, à regex_token_iterator. Enfin, (?:,|$) va correspondre à l' ','-séparateur ou à la fin de la string.

De rendre cette norme CSV reader ignorer les éléments vides, l'expression régulière peut être modifié seulement des chaînes de caractères avec plus d'un caractère.
```
const regex re{"((?:[^\\\\,]|\\\\.)+?)(?:,|$)"};
```
Avis de la '+' a maintenant remplacé le '*' indiquant 1 ou plusieurs caractères sont requis. Ce sera l'empêcher de correspondant à votre item chaîne qui se termine par un ','. Vous pouvez en voir un exemple ici: http://ideone.com/W4n44W

OriginalL'auteur Jonathan Mee

Vous devez vous connecter pour publier un commentaire.

Exemple boost::split Code

Résultats

De rendre cette norme CSV reader ignorer les éléments vides, l'expression régulière peut être modifié seulement des chaînes de caractères avec plus d'un caractère.