Nsryjdtyk

Not sure if my title makes much sense, but what I am trying to do is fwrite from dynamic structure to file, but what makes this somewhat harder is that my structure is passed by reference and I do not know how 1st parameter of fwrite should look like. Here is a part of the code:

void editData(FILE* fPtr, Car* carPtr, int* size)

{

int number = 0;

printData(carPtr, size);



while(1)

{

    if ((scanf("%d", &number) == 1) && (getchar() == 'n'))

    {

        if ((number > 0) && (number <= *size))

        {

            char make[15] = "", model[15] = "";

            int year = 0;

            double price = 0;



            if (getUserInput(make, model, &year, &price) == 1)

            {

                strcpy((*carPtr+number-1)->make, make);

                strcpy((*carPtr+number-1)->model, model);

                (*carPtr+number-1)->year = year;

                (*carPtr+number-1)->price = price;



                fseek(fPtr, sizeof(Car) * number-1, SEEK_SET);

                fwrite(**&carPtr[number-1]**, sizeof(Car), 1, fPtr);

            }

And that is how I call this function from main:

FILE* db = NULL;

int choice = 0;

db = openDatabase(db);



Car* cr = NULL;

int size = 0;

loadData(db, &cr, &size);

while((choice = menuChoice()) != 5)

    {

        switch (choice)

        {

            case 1:

                insertData(db, &cr, &size);

                break;

            case 2:

                **editData(db, &cr, &size);**

                break;

            case 4:

                printData(&cr, &size);

                break;

        }

    }

    free(cr);

    fclose(db);

}

Memory allocation to the structure happens in a different function.

If structure was local, in fwrite as 1st parameter I would write

&carPtr[number-1]

But in my case this does not work.

Car declaration:

struct car

{

    char make[15];

    char model[15];

    int year;

    double price;

};

Car *pnt

this is a pointer to Car.

The expression *(...) dereferences the ... into an object.

The expression a[b] is equal to *(a + b).

Car* carPtr

in a function parameter list (ie. in function(... Car *carPtr ....) is equal to:

Car **carPtr

This is a pointer to a pointer to Car.

&carPtr[x]

is equal to:

carPtr + x

which is not what you want. You have a pointer to an array of cars, not an array of pointers to cars. You want first to derefernce carPtr, then increment. You want:

&(*carPtr)[x]

which is equal to:

((*carPtr) + x)

So try:

fwrite(&(*carPtr)[number-1], sizeof(Car), 1, fPtr);

Also I would rewrite the

(*carPtr+number-1)->

into

(*carPtr)[number - 1].

as to indicate that you are handling a pointer to an array.

But really, I would rewrite the api to handle better abstraction:

struct cars_s {

     Car *cars;

     size_t carslen;

};



int main() {

    struct cars_s cars;



    insertData(db, &cars);

     ...

    editData(db, &cars);

}

which will make you code more readable, when you do editData(FILE *db, struct cars_s *cars) and cars->cars[x].year = year instead of Cars *cars, int *size and (*carPtr)[x].year = year.

fwrite expects a pointer to a byte buffer to write.

If you have a local variable (including structure), you would need to get its address with the & operator, like this:

Car myCar;

fwrite(&myCar, sizeof(Car), 1, fout);

But, if you already have a pointer, then you don't need the & opertator:

Car *myCar;

fwrite(myCar, sizeof(Car), 1, fout);

Same thing goes if you have an array of pointers to structures:

Car* cars;

fwrite(cars[i], sizeof(Car), 1, fout);

Since cars[i] already has the address fwrite needs, there is no need for any operators.

One thing to note is that C compilers pad structures - they may insert unused bytes between fields to make sure each field starts on a boundary (depends on your system word alignment, usually 4).

So, those 15 char arrays may have an extra byte appended to round to 16.
If you write the whole structure to file, those bytes will also be written.

This is why it is usually recommended to write each field separately, but if this is just an exercise, it may not matter.

The problem was not fwrite, but fseek after all.
This:

fseek(fPtr, sizeof(Car) * number-1, SEEK_SET);

must be changed to this:

fseek(fPtr, sizeof(Car) * (number-1), SEEK_SET);

I've managed to omit parenthesis and because of this fwrite would write to wrong place. Fread would then read more than there is memory allocated and thats why I think random things happened.

As for correct way to write fwrite:

fwrite(&(*carPtr)[number-1], sizeof(Car), 1, fPtr);

This works perfectly