Lire des nombres entiers à partir d'un fichier texte avec le C++ ifstream

Je veux lire le graphe d'adjacence des informations à partir d'un fichier texte et de le stocker dans un vecteur.

  • le fichier a nombre arbitraire de lignes

  • chaque ligne a nombre arbitraire d'entiers terminée par '\n'

par exemple,

First line:
0 1 4
Second line:
1 0 4 3 2
Thrid line:
2 1 3
Fourth line:
3 1 2 4
Fifth line:
4 0 1 3

Si je utiliser getline() pour lire une ligne à la fois, comment dois-je analyser la ligne (chaque ligne est variable nombre d'entiers)?

Des suggestions?

InformationsquelleAutor itnovice | 2011-11-14
  1. 17

    La ligne standard de lecture idiome:

    #include <fstream>
#include <sstream>
#include <string>
#include <vector>


std::ifstream infile("thefile.txt");
std::string line;

while (std::getline(infile, line))
{
  std::istringstream iss(line);
  int n;
  std::vector<int> v;

  while (iss >> n)
  {
    v.push_back(n);
  }

  //do something useful with v
}

    Voici une version d'une ligne à l'aide d'un for boucle. Nous avons besoin d'un auxiliaire de la construction (crédits de @Luc Danton!) qui fait le contraire de std::move:

    namespace std
{
  template <typename T> T & stay(T && t) { return t; }
}

int main()
{
  std::vector<std::vector<int>> vv;

  for (std::string line;
       std::getline(std::cin, line);
       vv.push_back(std::vector<int>(std::istream_iterator<int>(std::stay(std::istringstream(line))),
                                     std::istream_iterator<int>())
                    )
       ) { }

  std::cout << vv << std::endl;
}
    • Cela signifie que, c'est à l'aide de C++11, comme && est disponible uniquement en C++11.
    • Ma version antérieure implique une plus élaboré struct et un const-cast, qui est le C++98. Parlez-moi en privé si vous êtes intéressé, il n'est pas convenable pour la conversation polie 🙂
    • Merci pour votre solution. Quand j'ai imbriqué conteneur STL, dire, vector<vector<int> >, comment puis-je effectuer une itération à travers elle? J'ai essayé le suivant: std::vector<std::vector<int> > iter1; std::vector<int>::iterator iter2; for (iter1 = vv.begin(); iter1 != vv.end(); ++iter1) { for (iter2 = (*vv).begin(); iter2 != (*vv).end(); ++iter2) cout << *iter2 << " "; cout << endl; } Il n'est pas compilé. Quelle est la bonne façon d'itération par un imbriquée conteneur STL. Merci.
    • C'est quelque chose comme ça. for (std::vector<std::vector<int>>::const_iterator it1 = v.begin(), end1 = v.end(); it1 != end1; ++it1) { for ( std::vector<int>::const_iterator it2 = it1->begin(), end2 = it1->end(); it2 != end2; ++it2) { ... } } etc.
    • Merci pour votre réponse. Il fait le travail.
    • Cheers, je suis content. L'utilisation de la première version. La deuxième était uniquement pour "que je sois damné si cela ne peut pas être fait en une seule ligne."
    • "std::stay" Depuis quand est-il permis d'ajouter des noms à std?

    InformationsquelleAutor Kerrek SB
  2. 8

    D'abord lire une ligne à l'aide de std::getline fonction, puis de les utiliser std::stringstream à lire les nombres entiers à partir de la ligne comme:

    std::ifstream file("input.txt");

std::vector<std::vector<int>> vv;
std::string line;
while(std::getline(file, line))
{
    std::stringstream ss(line);
    int i;
    std::vector<int> v;
    while( ss >> i ) 
       v.push_back(i);
    vv.push_back(v);
}

    Vous pouvez également écrire la boucle du corps comme:

    while(std::getline(file, line))
{
    std::stringstream ss(line);
    std::istream_iterator<int> begin(ss), end;
    std::vector<int> v(begin, end);
    vv.push_back(v);
}

    Cela ressemble plus court et mieux. Ou de fusion-les deux dernières lignes:

    while(std::getline(file, line))
{
    std::stringstream ss(line);
    std::istream_iterator<int> begin(ss), end;
    vv.push_back(std::vector<int>(begin, end));
}

    Maintenant, ne pas faire plus court, comme il le ferait moche.

    • Ou même for (std::string line; std::getline(file, line); vv.push_back(std::vector<int>(std::istream_iterator<int>(std::istringstream(line)), std::istream_iterator<int>()))) {}
    • Hehe. Bon. J'aime l'idée de minimiser la portée de line variable.
    • Juste de le tester, mais il pourrait être que vous ne pouvez pas obtenir l'itérateur à partir d'une chaîne temporaire de flux 🙁
    • Pourquoi?
    • L'itérateur ne peut être construit à partir d'un non-référence constante. Donc vous ne pouvez pas construire à partir d'une rvalue, malheureusement.
    • Oh, je vois. Dans ce cas, si vous remplacez std::istringstream(line‌​) avec static_cast<std::stringstream&>(std::stringstream().flush() << line), alors cela fonctionnera. Voir ceci : ideone.com/r0T0X ... mais il est préférable d'éviter ce type de code, à mon avis!
    • Grâce Nawaz. Votre solution est génial.
    • Grâce Nawaz. Votre solution est génial. Je ne suis pas tout à fait sûr de <précédent> <code> std::istream_iterator<int> begin(ss) à la fin;</br> std::vector<int> v(début, fin); </code></prev>. C'est qu'une autre façon de faire <précédent> <code> copie(std::istream_iterator<int>(ss), std::istream_iterator<int>(), back_inserter(v); </code> </prev>?
    • Oui. C'est même comme std::copy version, mais c'est mieux que que comme c'est en utilisant le constructeur de vecteur directement.
    • Ou vous pouvez écrire ++(std::istream_iterator<int>(static_cast<std::stringstream&>(std::stringstream() << 100 <<" " << line))). Tout nombre entier peut être utilisé à la place de 100. J'espère que vous comprenez la logique ici. Code : ideone.com/9tSV5
    • impressionnant -- non, je ne suis pas sûr de comprendre. Pourquoi la valeur de retour non pas une rvalue plus? Peut même être obtenu plus simplement avec une fonction qui retourne une référence à son argument?
    • Il y a beaucoup de choses à considérer : 1) vous ne pouvez pas faire de copie d'un ruisseau, 2), ce qui signifie que vous avez à passer par référence à une fonction libre, 3), puisqu'il est à l'origine d'une rvalue, il ne peut pas être lié à un non-const de référence, mais si vous le lier à un const référence, la fonction ne peut pas retourner une valeur non-const de référence. 4) tous ceci suppose que cela ne peut être réalisé en utilisant une fonction libre. [Suite.].
    • [Suite.] 5), mais comme un membre de la fonction peut être appelée sur une rvalue et la fonction peut retourner une valeur non-const de référence par l'utilisation de return *this, le code fonctionne comme prévu. Maintenant, il existe de nombreuses fonctions de membre qui retourne std::istream&, par exemple std::istream::flush et operator<<(int). C'est pourquoi j'ai donné ces deux exemples.
    • La question est de savoir pourquoi un *this retourné par une fonction membre d'une rvalue soudainement être une lvalue?
    • Plus intrigante question, je pense, est la suivante : comment peut-elle rester une rvalue si le type de retour de la fonction membre est std::istream&? Je pense que c'est voulu par la conception d'une fonction membre peut transformer une rvalue en lvalue.
    • Il devrait donc y avoir un mixin modèle can_use_as_temporary<T>, à partir de laquelle vous dérivez, et qui expose T & lvalue() { return *this; }!
    • Je pense que c'est une bonne fonctionnalité. Je vais lancer un sujet sur ce, avec quelques questions que j'ai dans mon esprit. Permet de voir l'opinion des autres.
    • J'ai hâte que!
    • Merci pour votre réponse. Pouvez-vous expliquer l'utilisation de std::istream_iterator<int> begin(ss) à la fin; " un peu plus? Ce qui se passe lorsque le constructeur de copie de istream_iterator<int> est invoquée? Pourquoi la fin n'est pas initialisé? Comment cela fonctionne? Merci!

    InformationsquelleAutor Nawaz