compter le nombre de lignes dans un fichier texte

Je suis en train de lire les lignes hors de fichier texte, et je me demande si c'est une bonne façon de procéder? J'ai dû écrire la fonction numberoflines diminution de la number_of_lines variable par un car à l'intérieur de la boucle while, pour chaque ligne il lire il ajoute 2 à la number_of_lines variable.

#include <iostream>
#include <fstream>
using namespace std;

int number_of_lines = 0;

void numberoflines();
int main(){
    string line;
    ifstream myfile("textexample.txt");

    if(myfile.is_open()){
        while(!myfile.eof()){
            getline(myfile,line);
            cout<< line << endl;
            number_of_lines++;
        }
        myfile.close();
    }
    numberoflines();

}

void numberoflines(){
    number_of_lines--;
    cout<<"number of lines in text file: " << number_of_lines << endl;
}

Est-il des autres plus facile de mieux?

source d'informationauteur silent

  1. 47

    Votre hack de décrémenter le comte à la fin correspond à un hack.

    De loin préférable d'écrire votre boucle correctement en premier lieu, de sorte qu'il ne prend pas en compte la dernière ligne deux fois.

    int main() { 
    int number_of_lines = 0;
    std::string line;
    std::ifstream myfile("textexample.txt");

    while (std::getline(myfile, line))
        ++number_of_lines;
    std::cout << "Number of lines in text file: " << number_of_lines;
    return 0;
}

    Personnellement, je pense que dans ce cas, C-code de style est parfaitement acceptable:

    int main() {
    unsigned int number_of_lines = 0;
    FILE *infile = fopen("textexample.txt", "r");
    int ch;

    while (EOF != (ch=getc(infile)))
        if ('\n' == ch)
            ++number_of_lines;
    printf("%u\n", number_of_lines);
    return 0;
}

    Edit: bien sûr, C++ vous permettra aussi de faire quelque chose d'un peu similaire:

    int main() {
    std::ifstream myfile("textexample.txt");

    //new lines will be skipped unless we stop it from happening:    
    myfile.unsetf(std::ios_base::skipws);

    //count the newlines with an algorithm specialized for counting:
    unsigned line_count = std::count(
        std::istream_iterator<char>(myfile),
        std::istream_iterator<char>(), 
        '\n');

    std::cout << "Lines: " << line_count << "\n";
    return 0;
}
  2. 5

    Je pense que votre question est, "pourquoi suis-je en obtenir un plus de ligne qu'il y a dans le fichier?"

    Imaginer un fichier:

    line 1
line 2
line 3

    Le fichier peut être représenté en ASCII comme ceci:

    line 1\nline 2\nline 3\n

    (Où \n est le byte 0x10.)

    Maintenant, nous allons voir ce qui se passe avant et après chaque getline appel:

    Before 1: line 1\nline 2\nline 3\n
  Stream: ^
After 1:  line 1\nline 2\nline 3\n
  Stream:         ^

Before 2: line 1\nline 2\nline 3\n
  Stream:         ^
After 2:  line 1\nline 2\nline 3\n
  Stream:                 ^

Before 2: line 1\nline 2\nline 3\n
  Stream:                 ^
After 2:  line 1\nline 2\nline 3\n
  Stream:                         ^

    Maintenant, vous pensez que le flux de la marque eof pour indiquer la fin du fichier, non? Nope! C'est parce que getline jeux de eof si la fin de fichier marqueur est atteint "à l'époque de l'opération". Parce que getline s'arrête lorsqu'il atteint \nla fin-de-fichier marqueur n'est pas lu, et eof n'est pas marqué. Ainsi, myfile.eof() retourne false, et la boucle passe par un autre itération:

    Before 3: line 1\nline 2\nline 3\n
  Stream:                         ^
After 3:  line 1\nline 2\nline 3\n
  Stream:                         ^ EOF

    Comment voulez-vous résoudre ce problème? Au lieu de vérifier eof()voir si .peek() retourne EOF:

    while(myfile.peek() != EOF){
    getline ...

    Vous pouvez également vérifier la valeur de retour de getline (implicitement casting bool):

    while(getline(myfile,line)){
    cout<< ...