Argthtjtr

I want to read a lot of information from a file, so I need a dynamic memory.
This is why I use malloc for my struct in the main.
I wanted to realloc with every new line I get from the file, but he says "realloc(): invalid old size", and does not even realloc once.

typedef struct{

 int anzahl;

 int ANR;

 char MHD[10];

 char Bezeichnung[20];

 char VPE[5];

 float Preis;

 float gesamtpreis;

}Ware; 



int DateiLesen(Ware *Rechnung)

{

FILE *datei_lesen = NULL;

char trennung = " :,;n=";

char zeilen_lesen[256] = {0};

char *formatierer = NULL;

int count = 0;



datei_lesen = fopen("artikel.txt","r");

while(fgets(zeilen_lesen,256,datei_lesen))

{

    count++;

}

fclose(datei_lesen);

if(count == 0)

{

    return -1;

}

datei_lesen = fopen("artikel.txt","r");

while(fgets(zeilen_lesen,256,datei_lesen))

{

    fputs(zeilen_lesen,datei_lesen);

    formatierer = strtok(zeilen_lesen,trennung);

    if(atoi(formatierer) >= 100000)

    {

        Rechnung->ANR = atoi(formatierer);

        formatierer = strtok(NULL,trennung);

        strcpy(Rechnung->MHD,formatierer);

        formatierer = strtok(NULL,trennung);

        strcpy(Rechnung->Bezeichnung,formatierer);

        formatierer = strtok(NULL,trennung);

        strcpy(Rechnung->VPE,formatierer);

        formatierer = strtok(NULL,trennung);

        Rechnung->Preis = atoi(formatierer);

        Rechnung =  realloc(Rechnung,1*sizeof(Ware));

        //Rechnung = (Ware*) realloc(Rechnung,1);

        Rechnung++;

    }

}

fclose(datei_lesen);

return 0;

}





int main(void) {

Ware *Rechnung = (Ware*) malloc(sizeof(Ware));

int test = 0;



initialisiere(&Rechnung);

test = DateiLesen(&Rechnung);

return EXIT_SUCCESS;

}

This is not how you grow an array.

First,

Rechnung++;

is fine and dandy, but Rechnung is no longer a pointer returned by a previous call to malloc or realloc. So you can neither realloc nor free it.

Second,

Rechnung =  realloc(Rechnung,1*sizeof(Ware));

is fine if you want to leave the size of the array always at 1 element no matter what. If you want the size to increase, you need to feed in the new size.

A typical array-growing loop often looks like this:

Data *array = NULL; // note it's fine to realloc a NULL

size_t size = 0;

while (fgets(...)) {

    size_t new_size = size + 1;

    Data *new_array = realloc(array, sizeof(Data) * new_size);

    if (new_array == NULL) {

       // report an error, exit, abort, try again, whatever

       // note having a separate `new_array` variable allows you 

       // to retain old data in `array` in the case of `realloc` erroring on you

    } else {

       array = new_array;

       array[size].foo = make_foo();

       array[size].bar = make_bar();

       size = new_size;

    }

}

Note you never increment array because you cannot pass an incremented array to realloc . You cannot also have something like this:

    Data *array = malloc(sizeof(Data));

    Data *current = data;

    while (...) {

        ...

        current->foo = make_foo();

        current->bar = make_bar();

        array = realloc(array, sizeof(Data) * new_size);

        current++;

    }

because realloc may and will return a pointer different from what it was passed, and current will become invalid. So use plain old boring array indexing.