lire les n dernières lignes du fichier en c / c ++

Il y a un certain nombre de problèmes avec votre code. La plupart des
importante est que vous n'avez jamais vérifier que toutes les fonctions
réussi. Et enregistrer les résultats d'une ftell dans un int n'est-ce pas
une très bonne idée non plus. Puis il y a le test pos < begin;
cela peut se produire uniquement si il y a une erreur. Et le fait que
vous êtes de mettre les résultats de fgetc dans un char (qui se traduit
une perte d'information). Et le fait que le premier de vous lire
n'est à la fin du fichier, ce sera un échec (et une fois un ruisseau entre
un état d'erreur, il y reste). Et le fait que vous ne pouvez pas
fiable de faire de l'arithmétique sur les valeurs retournées par ftell (à l'exception de
sous Unix) si le fichier est ouvert en mode texte.

Oh, et il n'y a pas de "caractère EOF"; 'ÿ' est parfaitement valide
caractère (0xFF en Latin-1). Une fois que vous affectez la valeur de retour
de fgetc à un char, vous avez perdu toute possibilité de tester pour
à la fin du fichier.

Je pourrais ajouter que la lecture en arrière d'un caractère est
extrêmement inefficace. La solution habituelle serait d'allouer
une mémoire tampon suffisamment grande, puis de compter le '\n'.

EDIT:

Juste un petit peu de code pour donner l'idée:

std::string
getLastLines( std::string const& filename, int lineCount )
{
    size_t const granularity = 100 * lineCount;
    std::ifstream source( filename.c_str(), std::ios_base::binary );
    source.seekg( 0, std::ios_base::end );
    size_t size = static_cast<size_t>( source.tellg() );
    std::vector<char> buffer;
    int newlineCount = 0;
    while ( source 
            && buffer.size() != size
            && newlineCount < lineCount ) {
        buffer.resize( std::min( buffer.size() + granularity, size ) );
        source.seekg( -static_cast<std::streamoff>( buffer.size() ),
                      std::ios_base::end );
        source.read( buffer.data(), buffer.size() );
        newlineCount = std::count( buffer.begin(), buffer.end(), '\n');
    }
    std::vector<char>::iterator start = buffer.begin();
    while ( newlineCount > lineCount ) {
        start = std::find( start, buffer.end(), '\n' ) + 1;
        -- newlineCount;
    }
    std::vector<char>::iterator end = remove( start, buffer.end(), '\r' );
    return std::string( start, end );
}

C'est un peu faible dans la gestion des erreurs; en particulier, vous
voulez probablement la distinction entre l'incapacité d'ouvrir des
un fichier et toutes les autres erreurs. (Pas d'autres erreurs devrait se produire,
mais on ne sait jamais.)

Aussi, c'est purement Windows, et elle suppose que le réel
le fichier contient du texte pur, et ne contiennent pas de '\r' que
ne font pas partie d'un CRLF. (Pour Unix, il suffit de déposer le côté de la
dernière ligne).

Cela est fait en utilisant le tableau circulaire de manière très efficace .
Pas de tampon supplémentaire est nécessaire .

void printlast_n_lines(char* filename, int n){

const int k =n;
ifstream file(fileName);
string l[k];
int size = 0 ;

  while(file.good()){
 getline(file, l[size%k]); //this is just circular array
 size++;
}

//start of circular array & size of it 
int start = size > k ? (size%k) : 0 ; //this get the start of last k lines 
int count = min(k,size); //no of lines to print

for(int i = 0; i< count ; i++){
cout << l[(start+i)%k] << endl ; //start from inbetween and print from start due to remainder till all counts are covered
}

}

Veuillez fournir des commentaires

Je crois, vous êtes à l'aide de fseek mal. Vérifier man fseek sur Google.

Essayez ceci:

fseek(f1, -2, SEEK_CUR);
//1 to neutrialize change from fgect
//and 1 to move backward

Vous devez également définir la position au début du dernier élément:

fseek(f1, -1, SEEK_END).

Vous n'avez pas besoin end variable.

Vous devriez vérifier les valeurs de retour de toutes les fonctions (fgetcfseek et ftell). C'est une bonne pratique. Je ne sais pas si ce code fonctionne avec des fichiers vides ou qqch de similaire.

Je voudrais utiliser deux flux d'imprimer les n dernières lignes du fichier:
Cela va dans O(lignes) d'exécution et O(lignes) de l'espace.

#include<bits/stdc++.h>
using namespace std;

int main(){
  //read last n lines of a file
  ifstream f("file.in");
  ifstream g("file.in");

  //move f stream n lines down.
  int n;
  cin >> n;
  string line;
  for(int i=0; i<k; ++i) getline(f,line);

  //move f and g stream at the same pace.
  for(; getline(f,line); ){
    getline(g, line);
  }

  //g now has to go the last n lines.
  for(; getline(g,line); )
    cout << line << endl;
}

Une solution avec un O(lignes) d'exécution et O(N) l'espace est à l'aide d'une file d'attente:

ifstream fin("file.in");
int k;
cin >> k;
queue<string> Q;
string line;
for(; getline(fin, line); ){
  if(Q.size() == k){
    Q.pop();
  }
  Q.push(line);
}
while(!Q.empty()){
  cout << Q.front() << endl;
  Q.pop();
}