parse one struct to function from an array of structs - c

Question

I am new to C, but not to programming. I have been roped into modifying a C program to make it gather multiple pieces of data and put them in an array. I am not allowed to post actual source code, so I have made the following example which illustrates what I am trying to do:
#include <windows.h>
typedef struct
{
int size;
long rpm;
} ENGINE;
typedef struct
{
int doors;
int wheels;
ENGINE engine;
} CAR;
int newCar(CAR *car)
{
ENGINE eng;
eng.rpm=30000;
eng.size=1600;
car->doors=4;
car->wheels=4;
car->engine=eng;
return 0;
}
int getCars(CAR *cars[], int n)
{
int i = 0;
for (i=0; i<n; i++)
{
newCar(cars[i]);
}
return 0;
}
int carCount(int *count)
{
*count = 4;
return 0;
}
int main()
{
int n = 0;
CAR *cars = (CAR*) malloc(sizeof(CAR));
carCount(&n);
cars = (CAR*)realloc(cars, n * sizeof(CAR));
cars[1].doors = 2;
getCars(&cars,n);
}
The code above compiles but fails when I try to set members of the car struct inside the newCar routine. I'm not sure whether my realloc on the cars array is doing what I want it to, I based it on some other posts on stackoverflow. Does it look ok?
How can I access the members of car from the newcar routine?
Is this a reasonable way of doing this?
Many thanks :)

Answer 1

You don't need double indirections!
A simple pointer to CAR can point to different CARs.
Create space for the number of CARs you need: ok
A pointer to the first CAR in that space can easily be made to point to the other CARs.
CAR *cars = malloc(sizeof(CAR));
if malloc didn't fail cars points to a space large enough to hold 1 CAR
cars = realloc(cars, n * sizeof(CAR));
if realloc didn't fail cars now points to a space large enough to hold n cars
pass that pointer to your functions, along with how many cars it points to
getCars(cars, n);
and use the pointer in the functions
int getCars(CAR *cars, int n)
{
int i = 0;
for (i=0; i<n; i++)
{
/* here, cars[0] is the first car; cars[1] is the second ... */
/* we can pass the address with &cars[i] */
/* or make arithmetic with the pointer itself: */
newCar(cars+i);
}
return 0;
}

Answer 2

In order to use malloc for example you need the stdlib.h header. Since you are casting the pointer from malloc to (CAR*) the compiler assumes that malloc is returning an int and no warning is generated.

Answer 3

In getCars, you define cars as CAR *cars[], that is, array of pointers to CAR.
In main, &cars is a pointer to array of CARs.
The code happens to compile perhaps because both resolve to CAR**.
I would rewrite the code in the following way:
int newCar(CAR** car)
{
*car = (CAR*)malloc(sizeof(CAR));
ENGINE eng;
eng.rpm=30000;
eng.size=1600;
(*car)->doors=4;
(*car)->wheels=4;
(*car)->engine=eng;
return 0;
}
int getCars(CAR *cars[], int n)
{
int i = 0;
for (i=0; i<n; i++)
{
newCar(&cars[i]);
}
return 0;
}
int main()
{
int n = 0;
CAR** cars = (CAR**) malloc(sizeof(CAR*));
carCount(&n);
cars = (CAR**)realloc(cars, n * sizeof(CAR*));
getCars(cars,n);
cars[1]->doors = 2;
}
etc.

Answer 4

The reason why your code fails, is that in main, cars is a simple scalar variable, and you call a subroutine with its address as argument. In getCars, cars is an array of pointer, so cars[i], read ahead of the address you passed as argument. And this is where its wrong, because the address is an address of a single scalar variable, not the address of a table.
To get right, you should call the subroutine with the value of main's cars, which is exactly the address of the table your created with malloc/realloc. Note that in that case, the subroutine prototype will simply be
int getCars(CAR *cars, int n)

Answer 5

You would typically use malloc(n * sizeof(CAR)). The realloc function is only useful for over-the-moon-kind of programming.