fichier c++ io & fractionnement par séparateur

J'ai un fichier avec des données énumérées comme suit:

0,       2,    10
10,       8,    10
10,       10,   10
10,       16,   10
15,       10,   16
17,       10,   16

Je veux être en mesure de saisir le fichier et de le diviser en trois tableaux, dans le processus de parage tous les excès des espaces et de la conversion de chaque élément d'entiers.

Pour une raison que je ne peux pas trouver un moyen facile de faire cela en c++. Le seul succès que j'ai eu, c'est par la saisie de chaque ligne dans un tableau, puis regexing tous les espaces, puis de le diviser. L'ensemble de ce processus m'a pris un bon 20-30 lignes de code et une douleur à modifier pour dire un autre séparateur(eg. de l'espace), etc.

C'est le python équivalent de ce que j'aimerais avoir en C++:

f = open('input_hard.dat')
lines =  f.readlines()
f.close()

#declarations
inint, inbase, outbase = [], [], []

#input parsing
for line in lines:
    bits = string.split(line, ',')
    inint.append(int(bits[0].strip()))
    inbase.append(int(bits[1].strip()))
    outbase.append(int(bits[2].strip()))

La facilité d'usage de le faire en python est une des raisons pourquoi j'ai déménagé en premier lieu. Cependant, j'ai besoin de faire cela en C++ maintenant et je détesterais avoir à utiliser mon laid 20-30 ligne de code.

Toute aide serait appréciée, merci!

OriginalL'auteur darudude | 2008-11-06

c++file-io split

4

Il n'y a vraiment rien de mal avec fscanf, ce qui est probablement la solution la plus rapide dans ce cas. Et c'est court et facile à lire que le code python:
```
FILE *fp = fopen("file.dat", "r");
int x, y, z;
std::vector<int> vx, vy, vz;

while (fscanf(fp, "%d, %d, %d", &x, &y, &z) == 3) {
  vx.push_back(x);
  vy.push_back(y);
  vz.push_back(z);
}
fclose(fp);
```
Nice job. Les gens oublient scanf pattern matching. La solution la plus simple est la meilleure.

OriginalL'auteur ididak

Il n'y a pas de réel besoin pour utiliser boost dans cet exemple que les ruisseaux vont faire le tour bien:

int main(int argc, char* argv[])
{
    ifstream file(argv[1]);

    const unsigned maxIgnore = 10;
    const int delim = ',';
    int x,y,z;

    vector<int> vecx, vecy, vecz;

    while (file)
    {
        file >> x;
        file.ignore(maxIgnore, delim);
        file >> y;
        file.ignore(maxIgnore, delim);
        file >> z;

        vecx.push_back(x);
        vecy.push_back(y);
        vecz.push_back(z);
    }
}

Bien que si je devais utiliser boost, je préfère la simplicité de générateur de jetons de regex... 🙂

OriginalL'auteur MattyT

Quelque chose comme:

vector<int> inint;
vector<int> inbase;
vector<int> outbase;
while (fgets(buf, fh)) {
   char *tok = strtok(buf, ", ");
   inint.push_back(atoi(tok));
   tok = strtok(NULL, ", ");
   inbase.push_back(atoi(tok));
   tok = strtok(NULL, ", ");
   outbase.push_back(atoi(tok));
}

Sauf avec la vérification des erreurs.

Je voudrais éviter une telle "C-ish" solution, eh bien, l'esthétique...mais le plus important dans ce cas parce que strtok a quelques sérieux thread-safe questions. Le code est Correct si!

OriginalL'auteur MattSmith

1

std::getline vous permet de lire une ligne de texte, et vous pouvez utiliser une chaîne de flux à analyser la ligne individuelle:
```
string buf;
getline(cin, buf); 
stringstream par(buf);

char buf2[512];
par.getline(buf2, 512, ','); /* Reads until the first token. */
```
Une fois que vous obtenez à la ligne de texte dans la chaîne de caractères, vous pouvez réellement utiliser toute l'analyse de la fonction que vous voulez, même sscanf(buf.c_str(), "%d,%d "%d", &i1, &i2, &i3), en utilisant atoi sur la sous-chaîne par le nombre entier, ou par le biais d'une autre méthode.

Vous pouvez également ignorer les caractères indésirables dans le flux d'entrée, si vous savez qu'ils sont là:
```
if (cin.peek() == ',')
    cin.ignore(1, ',');
cin >> nextInt;  
```
OriginalL'auteur Raymond Martineau

Si vous n'avez pas l'esprit en utilisant les bibliothèques Boost...

#include <string>
#include <vector>
#include <boost/lexical_cast.hpp>
#include <boost/regex.hpp>

std::vector<int> ParseFile(std::istream& in) {
    const boost::regex cItemPattern(" *([0-9]+),?");
    std::vector<int> return_value;

    std::string line;
    while (std::getline(in, line)) {
        string::const_iterator b=line.begin(), e=line.end();
        boost::smatch match;
        while (b!=e && boost::regex_search(b, e, match, cItemPattern)) {
            return_value.push_back(boost::lexical_cast<int>(match[1].str()));
            b=match[0].second;
        };
    };

    return return_value;
}

Qui tire les lignes à partir du flux, puis utilise le Boost::RegEx bibliothèque (avec un groupe de capture) pour extraire chaque nombre de lignes. Automatiquement, il ignore tout ce qui n'est pas un nombre valide, mais qui peut être modifié si vous le souhaitez.

C'est encore sur une vingtaine de lignes avec la #includes, mais vous pouvez l'utiliser pour extraire essentiellement rien à partir du fichier de lignes. C'est un exemple trivial, je suis en utilisant à peu près identiques, code pour extraire les balises et les valeurs facultatives à partir d'un champ de base de données, la seule différence majeure est l'expression régulière.

EDIT: Oups, vous avez voulu que les trois vecteurs distincts. Essayez cette légère modification à la place:

const boost::regex cItemPattern(" *([0-9]+), *([0-9]+), *([0-9]+)");
std::vector<int> vector1, vector2, vector3;

std::string line;
while (std::getline(in, line)) {
    string::const_iterator b=line.begin(), e=line.end();
    boost::smatch match;
    while (b!=e && boost::regex_search(b, e, match, cItemPattern)) {
        vector1.push_back(boost::lexical_cast<int>(match[1].str()));
        vector2.push_back(boost::lexical_cast<int>(match[2].str()));
        vector3.push_back(boost::lexical_cast<int>(match[3].str()));
        b=match[0].second;
    };
};

OriginalL'auteur Head Geek

pourquoi ne pas le même code que dans python 🙂 ?

std::ifstream file("input_hard.dat");
std::vector<int> inint, inbase, outbase;

while (file.good()){
    int val1, val2, val3;
    char delim;
    file >> val1 >> delim >> val2 >> delim >> val3;

    inint.push_back(val1);
    inbase.push_back(val2);
    outbase.push_back(val3);
}

OriginalL'auteur da_m_n

0

Si vous voulez être en mesure de l'échelle est plus difficile avec les formats d'entrée, vous devriez envisager d'esprit, de stimuler l'analyseur bibliothèque du combinateur.

Cette page a un exemple qui presque faire ce que vous avez besoin (avec des nombres réels et d'un vecteur)

OriginalL'auteur David Pierre

Vous devez vous connecter pour publier un commentaire.