Wie liest man eine wachsende Textdatei in C++?

Question

Ich versuche, aus einer Datei zu lesen, die (etwas Ähnliches, was tail -F tut) wächst, aber es muss einige Probleme mit meinem Code sein:

string log, logFile("test.log"); 
size_t p = 0; 

while(true) 
{ 
    ifstream ifs(logFile.c_str()); 

    ifs.seekg(p); //*1 

    while(ifs.eof() == false) 
    { 
     getline(ifs, log); 

     cout << log << endl; 

     p = ifs.tellg(); //*2 
    } 

    nanosleep(&pause, NULL); 
} 

Ohne die Linien // * 1 und // * 2, die Protokolldatei wird korrekt bis zum Ende gelesen, aber wenn neue Zeilen hinzugefügt werden, passiert nichts.

Mit seekg und tellg Ich versuche, die aktuelle Endposition der Datei zu speichern, so dass, wenn ich es wieder öffnen ich dort Straße gehen und lesen, was hinzugefügt wurde.

Ich mag würde wissen, was in meinem Code falsch ist, und wenn es wirklich notwendig, die gleiche Datei für diesen Zweck zu schließen und wieder öffnen.

Vielen Dank.

Answer 1

Die Schleife ist falsch, wie wenn eof() angetroffen wird tellg() kehrt -1 und es gibt keine Überprüfung auf eof() sofort nach dem Aufruf getline(), die sein muss, da. Ändern Schleife:

while (getline(ifs, log)) 
{ 
    cout << log << endl; 
    p = ifs.tellg(); 
} 

Zusätzlich wird, wie p als size_t erklärt, wenn tellg()-1 der Wert p Rückkehr wurde auf 4294967295 gesetzt wird. Dies bedeutete, dass die seekg() über das Ende der Datei hinaus eingestellt wurde. Ändern Sie den Typ von p zu std::streamoff und bestätigen Sie den Aufruf seekg() erfolgreich war:

if (ifs.seekg(p)) 
{ 
    while (getline(ifs, log)) 
    { 
     cout << log << endl; 
     p = ifs.tellg(); 
    } 
} 

---

, wenn es wirklich notwendig ist, zu schließen und erneut öffnen die gleiche Datei für diesen Zweck.

Nein, ist es nicht notwendig, aber Sie müssen den eof Zustand aus dem Strom clear(). Im Folgenden ist eine Alternative zu einer korrigierten Version des entsandten Code:

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

int main() 
{ 
    std::ifstream ifs("test.log"); 

    if (ifs.is_open()) 
    { 
     std::string line; 
     while (true) 
     { 
      while (std::getline(ifs, line)) std::cout << line << "\n"; 
      if (!ifs.eof()) break; // Ensure end of read was EOF. 
      ifs.clear(); 

      // You may want a sleep in here to avoid 
      // being a CPU hog. 
     } 
    } 

    return 0; 
} 

Answer 2

Diese Methode treu für mich gearbeitet hat:

#include <string> 
#include <chrono> 
#include <thread> 
#include <fstream> 
#include <iostream> 

int main(int, char* argv[]) 
{ 
    // open file passed in on command line (at end of file) 
    std::ifstream ifs(argv[1], std::ios::ate); 

    if(!ifs.is_open()) 
    { 
     std::cerr << "ERROR: opening log file: " << argv[1] << '\n'; 
     return 1; 
    } 

    // remember file position 
    std::ios::streampos gpos = ifs.tellg(); 

    std::string line; 
    bool done = false; 

    while(!done) 
    { 
     // try to read line 
     if(!std::getline(ifs, line) || ifs.eof()) 
     { 
      // if we fail, clear stream, return to beginning of line 
      ifs.clear(); 
      ifs.seekg(gpos); 

      // and wait to try again 
      std::this_thread::sleep_for(std::chrono::milliseconds(100)); 
      continue; 
     } 

     // remember the position of the next line in case 
     // the next read fails 
     gpos = ifs.tellg(); 

     // process line here 
     std::cout << "line: " << line << std::endl; 
    } 
} 

Answer 3

Dieser Code funktioniert für mich:

struct timespec pause; 
pause.tv_sec = 1; 
pause.tv_nsec = 0; 

std::ifstream ifs("test.log"); 
std::streamoff p; 

if(ifs.is_open()) 
{ 
    std::string line; 

    while(true) 
    { 
     if(ifs.seekg(p)) 
     { 
      while(std::getline(ifs, line)) 
      { 
       std::cout << line << std::endl; 
       p = ifs.tellg(); 
      } 
     } 

     ifs.clear(); 

     nanosleep(&pause, NULL); 
    } 
}