c++ moyen le plus rapide pour lire uniquement la dernière ligne du fichier texte?

Utilisation seekg pour sauter à la fin du fichier, puis de le lire jusqu'à ce que vous trouver le premier retour à la ligne.
Ci-dessous est un exemple de code sur le dessus de ma tête à l'aide de MSVC.

#include <iostream>
#include <fstream>
#include <sstream>

using namespace std;

int main()
{
    string filename = "test.txt";
    ifstream fin;
    fin.open(filename);
    if(fin.is_open()) {
        fin.seekg(-1,ios_base::end);                //go to one spot before the EOF

        bool keepLooping = true;
        while(keepLooping) {
            char ch;
            fin.get(ch);                            //Get current byte's data

            if((int)fin.tellg() <= 1) {             //If the data was at or before the 0th byte
                fin.seekg(0);                       //The first line is the last line
                keepLooping = false;                //So stop there
            }
            else if(ch == '\n') {                   //If the data was a newline
                keepLooping = false;                //Stop at the current position.
            }
            else {                                  //If the data was neither a newline nor at the 0 byte
                fin.seekg(-2,ios_base::cur);        //Move to the front of that data, then to the front of the data before it
            }
        }

        string lastLine;            
        getline(fin,lastLine);                      //Read the current line
        cout << "Result: " << lastLine << '\n';     //Display it

        fin.close();
    }

    return 0;
}

Et ci-dessous est un fichier de test. Il réussit à vide, d'une ligne, et de plusieurs lignes de données dans le fichier texte.

This is the first line.
Some stuff.
Some stuff.
Some stuff.
This is the last line.

OriginalL'auteur derpface

Vous pouvez utiliser seekg() pour sauter à la fin du fichier, et lue à l'envers, le Pseudo-code comme:

ifstream fs
fs.seekg(ios_base::end)
bytecount = fs.tellg()
index = 1
while true
    fs.seekg(bytecount - step * index, ios_base::beg)
    fs.read(buf, step)
    if endlinecharacter in buf
        get endlinecharacter's index, said ei
        fs.seekg(bytecount - step*index + ei)
        fs.read(lastline, step*index - ei)
        break
    ++index

OriginalL'auteur carter2000

Alors que la réponse par derpface est certainement correct, il revient souvent des résultats inattendus. La raison pour cela est que, au moins sur mon système d'exploitation (Mac OSX 10.9.5), de nombreux éditeurs de texte, mettre fin à leurs fichiers avec une "fin de ligne".

Par exemple, quand j'ouvre vim, tapez simplement le caractère " a " (pas de retour), et de l'enregistrer, le fichier contiendra maintenant (en hexadécimal):

61 0A

61 est la lettre 'a' et 0A est un caractère de fin de ligne.

Cela signifie que le code par derpface renvoie une chaîne vide sur tous les fichiers créés par un éditeur de texte.

Bien que je ne peux certainement imaginer des cas où un fichier est arrêté avec une "fin de ligne" doit retourner une chaîne de caractères vide, je pense que ignorant la dernière "fin de ligne" serait plus approprié lorsque vous traitez avec des fichiers de texte normaux; si le fichier est terminée par une "fin de ligne" - nous bien de l'ignorer, et si le fichier n'est pas résilié par une "fin de ligne" nous n'avons pas besoin de le vérifier.

Mon code pour ignorer le dernier caractère du fichier d'entrée est:

#include <iostream>
#include <string>
#include <fstream>
#include <iomanip>

int main() {
    std::string result = "";
    std::ifstream fin("test.txt");

    if(fin.is_open()) {
        fin.seekg(0,std::ios_base::end);      //Start at end of file
        char ch = ' ';                        //Init ch not equal to '\n'
        while(ch != '\n'){
            fin.seekg(-2,std::ios_base::cur); //Two steps back, this means we
                                              //will NOT check the last character
            if((int)fin.tellg() <= 0){        //If passed the start of the file,
                fin.seekg(0);                 //this is the start of the line
                break;
            }
            fin.get(ch);                      //Check the next character
        }

        std::getline(fin,result);
        fin.close();

        std::cout << "final line length: " << result.size() <<std::endl;
        std::cout << "final line character codes: ";
        for(size_t i =0; i<result.size(); i++){
            std::cout << std::hex << (int)result[i] << " ";
        }
        std::cout << std::endl;
        std::cout << "final line: " << result <<std::endl;
    }

    return 0;
}

Qui sera de sortie:

final line length: 1
final line character codes: 61 
final line: a

Sur le single "un".

EDIT: La ligne if((int)fin.tellg() <= 0){ cause de problèmes si le fichier est trop gros (> 2 GO), car tellg n'est pas simplement renvoyer le nombre de caractères à partir du début du fichier (tellg() de la fonction de donner mauvaise taille de fichier?). Il peut être préférable d'séparément test pour le début du fichier fin.tellg()==tellgValueForStartOfFile et pour les erreurs fin.tellg()==-1. Le tellgValueForStartOfFile est probablement 0, mais la meilleure façon de vous assurer que serait probablement:

fin.seekg (0, is.beg);
tellgValueForStartOfFile = fin.tellg();

OriginalL'auteur Joost Huizinga

J'ai pris alexandros solution et amélioré un peu

bool moveToStartOfLine(std::ifstream& fs)
{
    fs.seekg(-1, std::ios_base::cur);
    for(long i = fs.tellg(); i > 0; i--)
    {
        if(fs.peek() == '\n')
        {
            fs.get();
            return true;
        }
        fs.seekg(i, std::ios_base::beg);
    }
    return false;
}

std::string getLastLineInFile(std::ifstream& fs)
{
    //Go to the last character before EOF
    fs.seekg(-1, std::ios_base::end);
    if (!moveToStartOfLine(fs))
        return "";

    std::string lastline = "";
    getline(fs, lastline);
    return lastline;
}

int main()
{
    const std::string filename = "test.txt";
    std::ifstream fs;
    fs.open(filename.c_str(), std::fstream::in);
    if(!fs.is_open())
    {
        std::cout << "Could not open file" << std::endl;
        return -1;
    }

    std::cout << getLastLineInFile(fs) << std::endl;

    return 0;
}

OriginalL'auteur Daniel Duvilanski