Zeilenweises auslesen einer txt Datei in C

    • Zeilenweises auslesen einer txt Datei in C

      Gibt es eine Funktion bzw. eine Möglichkeit, wie ich Integer Werte in eine txt Datei Zeilenweise reinschreibe, und das ganze dann Zeilenweise wieder (in z.B. ein Array) auslese?

      Bitte um schnelle Antwort! Ist dringend.

      mfg
      James
      [Blockierte Grafik: http://dl.dropbox.com/u/24753690/stuff/forenlinks/rocketsign.png]
      Team Rocket - so schnell wie das Licht,
      gebt lieber auf und bekämpft uns nicht!
      join #teamrocket @iz-smart.net

    • Schon mal was von fprintf und fscanf gehört?
      Ich hab mal ein kleines Beispiel zusammengeschustert:

      C-Quellcode

      1. #include <stdio.h>
      2. #include <malloc.h>
      4. typedef struct {
      5. int *array;
      6. int num;
      7. } tuple;
      9. void write_array(FILE *fp, tuple t)
      10. {
      11. int i = 0;
      12. for(; i < t.num; ++i) {
      13. fprintf(fp, "%d\n", t.array[i]);
      14. }
      15. fflush(fp);
      16. }
      18. tuple read_array(FILE *fp)
      19. {
      20. int num, i;
      21. tuple rw;
      22. fseek(fp, 0, SEEK_END);
      23. num = ftell(fp);
      24. fseek(fp, 0, SEEK_SET);
      26. rw.array = malloc(sizeof(int) * num);
      27. rw.num = num;
      29. for(i = 0; fscanf(fp, "%d\n", &rw.array[i]) != EOF; ++i);
      30. return rw;
      31. }
      33. int main(int argc, char *argv[])
      34. {
      35. FILE *fp = fopen("test.txt", "w");
      36. tuple tmp2;
      37. int tmp[5] = {1, 2, 3, 4, 5};
      38. int i;
      40. tmp2.array = tmp;
      41. tmp2.num = 5;
      43. write_array(fp, tmp2);
      44. fclose(fp);
      46. fp = fopen("test.txt", "r");
      47. tmp2 = read_array(fp);
      48. fclose(fp);
      50. for(i = 0; i < 5; ++i) {
      51. printf("%d\n", tmp2.array[i]);
      52. }
      54. free(tmp2.array);
      55. return 0;
      56. }
      Alles anzeigen

    • Danke erstmal für den Code

      Könntest du mir bitte Kommentare reineditieren?
      Weil mir einige Funktionen und Datentypen nicht ganz klar sind...

      z.B.: tuple oder malloc
      James
      [Blockierte Grafik: http://dl.dropbox.com/u/24753690/stuff/forenlinks/rocketsign.png]
      Team Rocket - so schnell wie das Licht,
      gebt lieber auf und bekämpft uns nicht!
      join #teamrocket @iz-smart.net

    • malloc steht für memory allocation, wodurch man sich speicher reserviert und einen pointer darauf legt, welcher zurückgegeben wird...


      aber um einfach nur zeilenweise einzulesen, genügt die funktion fgets

      die funktioniert so

      fgets(string, anzahl zeichen, dateipointer);

      string ist der string, auf welchem die gelesene zeile gespeichert wird

      anzahl zeichen ist die anzahl der maximal zu lesenden zeichen, also falls dein string begrenzt ist, das du nicht auf nen NULL pointer stößt^^

      und dateipointer ist selbsterklärend^^


      übrigends besitzt diese funktion einen rückgabewert, ob gelesen wurde oder nicht (1 oder 0) wodurch du am besten, wenn du aus einer datei liest, eine schleife drum baust, zB:

      while(fgets(ein, 1023, datei))

      die schleife arbeitet sich also durch die datei welche in der referenz von datei verbirgt durch, liest zeile für zeile raus und speichert sie in ein, (maximal 1023 zeichen, da ein ein string mit 1024 chars ist)

    • Öhm ich hab's mal kommentiert und gleich einen Fehler ausgebessert - hab halt schon lang nicht mehr C programmiert :/.

      C-Quellcode

      1. #include <stdio.h>
      2. #include <malloc.h>
      4. /**
      5. * This struct contains an array and the number of its elements.
      6. */
      7. typedef struct {
      8. int *array; /* the int-array */
      9. int num; /* the number of elements */
      10. } tuple;
      12. /**
      13. * write_array writes the array in the tuple struct into the file fp.
      14. *
      15. * @param fp is a file pointer.
      16. * @param t is a tuple which contains the array and the number of elements
      17. * which should be written into the file.
      18. */
      19. void write_array(FILE *fp, tuple t)
      20. {
      21. int i = 0;
      22. for(; i < t.num; ++i) {
      23. /* write the elements into the file */
      24. fprintf(fp, "%d\n", t.array[i]);
      25. }
      26. /* flush the file (all written elements are now written from the
      27. * internal buffer into the file) */
      28. fflush(fp);
      29. }
      31. /**
      32. * read_array reads the elements from a file into an int-array.
      33. *
      34. * @param fp is a pointer to a file
      35. *
      36. * @return a tuple struct is returned which contains a dynamically allocated
      37. * array and the number of elements in this array. Note: the array must be freed
      38. * by the user!
      39. */
      40. tuple read_array(FILE *fp)
      41. {
      42. int num, i;
      43. tuple rw;
      44. /* get the number of elements */
      45. for(num = 0; fscanf(fp, "%d\n", &i) != EOF; ++num);
      46. /* jump to the beginning of the file */
      47. fseek(fp, 0, SEEK_SET);
      49. /* allocate the array with the size num */
      50. rw.array = malloc(sizeof(int) * num);
      51. /* store the number of elements in the return value */
      52. rw.num = num;
      54. /* read the ints from the file */
      55. for(i = 0; fscanf(fp, "%d\n", &rw.array[i]) != EOF; ++i);
      56. return rw;
      57. }
      59. int main(int argc, char *argv[])
      60. {
      61. /* open the file */
      62. FILE *fp = fopen("test.txt", "w");
      63. tuple tmp2;
      64. int tmp[5] = {1, 2, 3, 4, 5};
      65. int i;
      67. /* first of all we are writing some dummy values (1-5) into the file */
      68. tmp2.array = tmp;
      69. tmp2.num = 5;
      71. /* write it */
      72. write_array(fp, tmp2);
      73. fclose(fp);
      75. /* now we are open the previously written file */
      76. fp = fopen("test.txt", "r");
      77. /* read the int-array from the file */
      78. tmp2 = read_array(fp);
      79. fclose(fp);
      81. /* print the int array */
      82. for(i = 0; i < tmp2.num; ++i) {
      83. printf("%d\n", tmp2.array[i]);
      84. }
      86. /* free the dynamically allocated array in the tuple struct */
      87. free(tmp2.array);
      88. return 0;
      89. }
      Alles anzeigen


      Zur Erklärung: malloc wurde ja schon erklärt. free ist sozusagen das Gegenstück zu malloc. Es gibt, wie der Name schon sagt, den von malloc dynamisch reservierten Speicher wieder frei. Immer wenn du irgendetwas mit malloc reservierst musst du es also irgendwann mal mit free wieder freigeben, ansonsten bekommst du Memory Leaks.

      tuple ist eine eigene definierte Datenstruktur, die eben das Array und dessen Größe beinhaltet. KA ob dir Strukturen schon geläufig sind, aber generell schaut so etwas so aus:

      Quellcode

      1. #include <stdio.h>
      3. typedef struct {
      4. int feld1;
      5. int feld2;
      6. } my_struct;
      8. void print_my_struct(my_struct *s)
      9. {
      10. printf("%d %d\n", s->feld1, s->feld2);
      11. }
      13. int main(int argc, char *argv[])
      14. {
      15. my_struct s;
      16. s.feld1 = 5;
      17. s.feld2 = 8;
      18. print_my_struct(&s);
      19. return 0;
      20. }
      Alles anzeigen

      In diesem Beispiel definiere ich meinen eigenen Datentyp my_struct, der aus 2 Feldern feld1 und feld2 besteht. Diese befülle ich dann im main und rufe dann print_my_struct mit einem pointer auf diese struct auf.
      print_my_struct gibt dann die beiden Felder mit s->feld1 (ist das selbe wie (*s).feld1) und s->feld2 aus.

      @fgets: fgets ist zwar OK wenn man generell strings zeilenweise einlesen will, aber in diesem Fall geht es doch im int-arrays oder? Dabei müsste ich doch jedes Mal zusätzlich noch atoi aufrufen und würde mir so eigentlich nicht wirklich etwas ersparen.

    • OK Danke!

      Habs jetzt bei meinem Programm eingebaut und es funktioniert.

      Von mir aus kann der Thread geschlossen werden.

      MFG
      James
      [Blockierte Grafik: http://dl.dropbox.com/u/24753690/stuff/forenlinks/rocketsign.png]
      Team Rocket - so schnell wie das Licht,
      gebt lieber auf und bekämpft uns nicht!
      join #teamrocket @iz-smart.net