læse linier i text-fil baglæns?

Flere muligheder:

1)  læs hele filen fra disk til memory buffer og søg baglæns fra
    slutningen efter '\n'

2)  læs hele filen op fra disk til en data struktur med linierne
    i og så kan du accesse dem direkte

3)  positioner dig og læs fra filen bagfra og frem

Jeg kan godt lave et eksempel, hvis du fortæller hvad du vil have.

tror det må være 3'eren..


altså hvis min fil indeholder

hej
med
dig

skal den udskrive

dig
med
hej

Det vil alle 3 løsninger gøre. De vil bare gøre det på 3 forskellige
måder.

hmm, hvilken en er hurtigst og lettest at bruge?

#1 er lang nemmest men kræver at hele filen kan være i memory.

filen er max 20 linier lang.. så skader det helt vildt?

kunne man ikke evt. cleare det memory den optager?

20 linier = slet ikke noget problem

Hvis de nu var 20 millioner linier, så ...

fint nok.. nr 1 så :D

kan det blive et problem hvis det nu skal gøres flere gange? eller kan man loade det ind i en global variabel til brug flere gange?

Man kan sagtens genbruge memeory.

Her er noget kode:

#include <stdio.h>


int main()
{
  char buffer[1000],line[100],*p1,*p2;
  FILE *fp;
  strcpy(buffer,"");
  fp = fopen("z.dat", "r");
  while(!feof(fp)) {
      fgets(line,sizeof(line),fp);
      strcat(buffer,line);
  }
  fclose(fp);
  p1 = buffer + strlen(buffer);
  while(p1 > buffer) {
      p2 = p1;
      p1--;
      while(p1 >= buffer && *p1 != '\n' ) p1--;
      strncpy(line,p1+1,p2-p1-1);
      line[p2-p1-1] = '\0';
      printf("%s\n",line);
  }
  return 0;
}

Det er bare sådan noget af det kode der er C når det er værst.

Lidt -1 og +1 her og der og hvis de tilfældigvis står rigtigt så
virker det.

Men ihvertfald må det illustrere ideen.

Så kan du jo pynte lidt.

hmm, den spytter sidste linie ud 2 gange..

Hvis den sidste linie er tom skriver den næst sidste linie ud
2 gange.

Jeg kigger på det.

Og det er ikke parsningen der går galt men indlæsningen.

Prøv med den her variant:

#include <stdio.h>

int main()
{
  char buffer[1000],line[100],*p1,*p2;
  FILE *fp;
  strcpy(buffer,"");
  fp = fopen("z.dat", "r");
  while(!feof(fp)) {
      if(fgets(line,sizeof(line),fp)) strcat(buffer,line);
  }
  fclose(fp);
  p1 = buffer + strlen(buffer);
  while(p1 > buffer) {
      p2 = p1;
      p1--;
      while(p1 >= buffer && *p1 != '\n' ) p1--;
      strncpy(line,p1+1,p2-p1-1);
      line[p2-p1-1] = '\0';
      printf("%s\n",line);
  }
  return 0;
}

takker.. lige det jeg manglede :)

Et klassisk problem: Først ind, sidst ud.
En klassisk løsning: En stak

#include <stdio.h>
#include <stack>
using namespace std;

int main()
{
  FILE * pFile = fopen("test.txt","rt");
  if (pFile != NULL)
  {
    stack<string> Data;
    char szLine[1000];
    while (fgets(szLine,sizeof(szLine),pFile) != NULL)
      Data.push(szLine);
    fclose(pFile);

    while (! Data.empty())
    {
      const string & strValue = Data.top();
      fputs(strValue.c_str(),stdout);
      Data.pop();
    }
  }

  return 0;
}

db

> db

flot løsning.