4. Pointer, Char, Malloc Problem (mal wieder :-( )

Pointer, Char, Malloc Problem (mal wieder :-( )


  • Es ist voellig normal, wenn du "Hyroglyphen" siehst. Du hast wohl noch nie in eine Binaerdatei reingeschaut.

    - fflush(stdin); ist Müll
    - wenn save==NULL, machst du weiter statt rauszugehen

    0
  • ?

    beginner88888 schrieb:

    Wenn die Datei, z.B.: test1.txt heißt und ich mach die auf... Bis auf den "String" sind alles Hyroglyphen.

    Du schreibst mit fwrite die Daten genau so in die Datei, wie sie im Speicher stehen. Wenn du (als Mensch) sie lesen willst, musst du die ZAhlen vorher in strings umwandeln.
    Dazu ist fprintf da.

    beginner88888 schrieb:

    Aber wie gesagt, ich kanns dann "richtig" auslesen.

    Da gibt es viele Fallen, in die man rennen kann.
    Solange du nur auf dem selben System arbeitest ist das in Ordnung.
    Aber in C ist ja schon die Größe von int nicht eindeutig.
    Auch die Endianness kann unterschiedlich sein.
    Dann klappt das mit dem fread nicht mehr.

    Ein einfaches gängiges Format wäre noch CSV

    0
  • B

    ok, das mit dem fflush weiß ich eigentlich und wenn save==NULL hab ich übersehen. Sorry.

    Ehrlich gesagt Plattformunabhängig will ich jetzt momentan noch gar nicht sein 🙂

    Jetzt stellt sich das gößere Problem, an das ich ursprünglich schon mal dachte.

    Wenn ich meine Datei ein weiteres mal "öffne", mit fopen(name, "a") müsste der Dateizeiger am Ende stehen. Soweit so gut, ich kann also wieder eine Struktur dazu schreiben, es dürfte nichts überschrieben werden.

    Tja, nur wie lese ich die dann wieder aus???
    fread(??????) . Ich hab ja jetzt meine Struktur 2mal drinn stehen...
    Überlegung war :

    fread(&puffer1, .....)
    fread(&puffer2, .....) aber da wandert mir der Dateizeiger irgendwie nicht mit, bzw. in puffer2 ist ausser müll dann nicht viel drinnen.

    fseek... ?? Wäre das ein Lösungansatz?
    Aber Problem ist ja auch, wenn ich 2 Strukturen auslesen will, brauch ich ja nen "puffer", der 2 Strukturen aufnimmt... Array of Struct? Wah, ich dreah noch durch mit C.

    Ich habe das gefühl, mit dem Strukturen schreiben und lesen total auf dem Holzweg zu sein??

    Leute mal OFF-Topic.. Wie lange macht ihr "das" (C) schon ?? Ich hab mich schon in ein paar Programmiersprachen einlernen müssen ( THX GOD, brauchte selten was mit String´s), aber C haut mir immer wenn ich meine "Jetzt hab ich´s" wieder eine rein... Wah 😡 😡 😡

    0
  • ?

    beginner88888 schrieb:

    Tja, nur wie lese ich die dann wieder aus???
    fread(??????) . Ich hab ja jetzt meine Struktur 2mal drinn stehen...
    Überlegung war :

    fread(&puffer1, .....)
    fread(&puffer2, .....)

    Ja, genau so.

    beginner88888 schrieb:

    aber da wandert mir der Dateizeiger irgendwie nicht mit, bzw. in puffer2 ist ausser müll dann nicht viel drinnen.

    Hast du sie nach dem schreiben bzw. anhängen wieder geschlossen und neu zum lesen geöffnet?

    0
  • B

    Hast du sie nach dem schreiben bzw. anhängen wieder geschlossen und neu zum lesen geöffnet?

    Ja, hab sie mit fclose zugemacht und mit fopen (..."a") wieder auf gemacht.
    Aber das :

    fread(&puffer1, sizeof(puffer1), 1, ptr);
fread(&puffer2, sizeof(puffer2), 1, ptr);

    ...klappt nicht. Muss ich evtl. fread(&puffer1, sizeof(puffer1), 2, ptr) machen? nö is quatsch, 2 blöcke kopieren.

    Ich hab das "Programm" jetzt leider nicht mehr vorliegen, hab mich da "nebenbei" in der Arbeit etwas "gespielt".

    Aber prinzipell sollte der Zeiger mitwandern? Muss ich nochmal drüber sehen.

    Hat evtl. jmd. ein kurzes Bspl. mit gemischten Strukturen?

    Nochmal Danke, das du mir über meine Codehaufen rüber siehst.

    0
  • ?

    beginner88888 schrieb:

    Ja, hab sie mit fclose zugemacht und mit fopen (..."a") wieder auf gemacht.

    fread ist lesen. Daetien zum lesen öffnen geht mit fopen(.., "r")
    Wobei das r in fread und das "r" bei fopen durchaus etwas miteinander zu tun haben.

    "a" öffnet zum schreiben und positioniert den Dateizeiger an das Dateiende. (kein lesen)
    "w" öffnet zum schreiben und positioniert den Dateizeiger an den Dateianfang. (kein lesen)
    Ein bestehende Datei wird vorher gelöscht (auf Länge 0 gesetzt).
    "r" öffnet zum lesenund und positioniert den Dateizeiger an den Dateianfang. (kein schreiben)

    Die Modi mit dem + zum lesen und schreiben sind auch nicht einfacher zu verstehen, da du zwischen lesen und schreiben den Dateizeiger selber bewegen musst.

    0
  • B

    Hallo Dirk, wei´s nicht genau wo gestern mein Fehler lag, aber heute ging´s.
    Hab nochmal das "Speichern usw. " überarbeitet.
    Mann verzeihe mir das fflush

    #include <stdio.h>
#include <stdlib.h>
#include "system.h"
#define input  1
#define output 2

void dbank(const char *fname, const int ct_dbank){

struct data ibuffer, obuffer[5];     
FILE *save, *open;
int choose=0;
int i, j, k;
char dummy;

while (choose != 3) {

system("cls");
puts("######################################");
puts("#   Daten Eingeben oder Auslesen?    #");
puts("#       1=  Eingeben                 #");
puts("#       2=  Auslesen                 #");
puts("#       3=  EXIT                     #");
puts("######################################");
puts("\n");
scanf("%d",&choose);

switch (choose){

       case input   :  if ( (save=fopen(fname, "w")) != NULL)
                            puts("File Opened");
                            else{
                             puts("Can´t open / Create File");
                              return;
                              }
                         for (i=0; i< ct_dbank; i++) {
                             fflush(stdin);
                             puts("Enter Name: ");
                             fgets(ibuffer.name, smax, stdin);
                             puts("Enter ID: ");
                             scanf("%d", &ibuffer.id);
                             fflush(stdin);
                             puts("Enter Status: ");
                             scanf("%c", &ibuffer.status);
                             fwrite(&ibuffer, sizeof(ibuffer), 1, save);
                             } 
                             fclose(save); 
                       break;

       case output  :  if ( (open=fopen(fname, "r")) != NULL)
                            puts("File Opened");
                            else{
                             puts("Can´t open / Create File");
                              return;
                              }
                       for (j=0; j< ct_dbank; j++) {
                           fflush(stdin);
                           fread(&obuffer[j], sizeof(obuffer[j]), 1, open);
                           }
                       fclose(open);
                       k=0;
                       while (k< ct_dbank) {
                             printf("Name   : %s  ", obuffer[k].name);
                             printf("ID     : %d  \n", obuffer[k].id);
                             printf("Status : %c  \n", obuffer[k].status);
                             puts("Press Any Key + 'Enter' to contiune");
                             k++;
                             dummy=getchar();
                             fflush(stdin);
                             }

                      break;

       default      : puts("Wrong Input"); return  ;

       }

}     

}

    Habe mich jetzt doch für ein Array of Struct entschieden.
    Muss noch ne Abfrage reinmachen, das nicht mehr ausgelesen werden dürfen, wie das Array Elemente hat.

    0
  • ?

    Du solltest die Eingabe vom Speichern und die Ausgabe vom Lesen trennen.
    Das sind vier verschiedene Funktionen.

    0
  • B

    Wollte das jetzt noch umsetzten, hab aber jetzt ein Problem mit dem "Öffnen".

    Was hab ich übersehen, er erstellt mir die Datei usw, nur reinspeichern tut er nicht mehr.
    Wird die Datei beim verlassen des sub´s open wieder geschlossen? Oder stimmt einfach meine Rückgabe nicht?

    öffnen

    #include <stdio.h>
#include <stdlib.h>
#include "system.h"
FILE* fileopen_w(FILE *ptr, const char* filename){

    if ( (ptr=fopen(filename, "w")) != NULL){

     puts("File Opened");
     return ptr;
     }
     else{
     puts("Error FILE NOT AVAILABLE");
     return NULL;
     }

}

    geänderter Ausschnitt aus dbank.c

    void dbank(const char *fname, const int ct_dbank){

struct data ibuffer, obuffer[5];     
FILE *save, *open;
int choose=0;
int i, j, k;
char dummy;

while (choose != 3) {

system("cls");
puts("######################################");
puts("#   Daten Eingeben oder Auslesen?    #");
puts("#       1=  Eingeben                 #");
puts("#       2=  Auslesen                 #");
puts("#       3=  EXIT                     #");
puts("######################################");
puts("\n");
scanf("%d",&choose);

switch (choose){

       case input   :    fileopen_w(save, fname);

                         for (i=0; i< ct_dbank; i++) {
                             fflush(stdin);
                             puts("Enter Name: ");
                             fgets(ibuffer.name, smax, stdin);
                             puts("Enter ID: ");
                             scanf("%d", &ibuffer.id);
                             fflush(stdin);
                             puts("Enter Status: ");
                             scanf("%c", &ibuffer.status);
                             fwrite(&ibuffer, sizeof(ibuffer), 1, save);
                             } 
                             fclose(save); 
                       break;
    0
  • ?

    Du willst nicht das ändern, auf das save zeigt.
    Du willst save ändern. Darum musst du die Adresse von save übergeben.
    Das ergibt dann einen Doppelzeiger in fileopen_w.

    Lass FILE* als Paramter einfach weg.

    FILE* fileopen_w(const char* filename){

    FILE *ptr;
    if ( (ptr=fopen(filename, "w")) != NULL){

      puts("File Opened");
      return ptr;
    }
    else{
      puts("Error FILE NOT AVAILABLE");
      return NULL;
    }

}

... 
case input   :   save = fileopen_w(fname);

    Aber was passiert, wenn wirklich mal eine NULL zurück kommt.
    Du machst weiter als sei dies nie der Fall. Dann brauchst du auch nicht den Wrapper für fopen.

    0
  • B

    Aber was passiert, wenn wirklich mal eine NULL zurück kommt.
    Du machst weiter als sei dies nie der Fall. Dann brauchst du auch nicht den Wrapper für fopen.

    Ja, das muss ich noch machen. Das ganze ist noch sehr "Experimentell".

    Du willst save ändern. Darum musst du die Adresse von save übergeben.
    Das ergibt dann einen Doppelzeiger in fileopen_w.

    😮 😮 Ich dachte mir gestern noch "Wenigstens werd ich sowas wie Doppelzeiger bestimmt nie brauchen. Ähmm... ja.
    Ok, das würde mich aber jetzt brennend interessieren, da ich bis jetzt immer dachte "Doppelzeiger brauch ich nicht, weiß keine Anwendung dafür (Array ausgenommen)".

    Wie würde das mit dem Doppelzeiger dann funktionieren?

    0
  • ?
     

    FILE* fileopen_w(FILE **ptr, const char* filename){

    if ( (*ptr=fopen(filename, "w")) != NULL){ // *ptr ist ein einfacher Zeiger

     puts("File Opened");
     return *ptr;
     }
     else{
     puts("Error FILE NOT AVAILABLE");
     return NULL;
     }

}	
...
case input   :    fileopen_w(&save, fname);  // du übergibst die Adresse von save
    0
  • B

    Danke!! Die funktion hatte ich schon hingebastelt,

    #include <stdio.h>
#include <stdlib.h>
#include "system.h"

FILE* fileopen_r(FILE **ptr, const char* filename){ 

    if ( (*ptr=fopen(filename, "r")) != NULL){ 

     puts("File Opened"); 
     return *ptr; 
     } 
     else{ 
     puts("Error FILE NOT AVAILABLE"); 
     return NULL; 
     } 

}

    Aber das ich dann beim Aufruf die Adresse übergeben muss.... Da wär ich nicht so schnell drauf gekommen. Danke nochmal.
    Muss mich mal mit der Doppelzeiger "Sache" etwas mehr beschäftigen 🙂

    0
Anmelden zum Antworten