从一个结构数组解析一个结构以起作用

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 getCars , you define cars as CAR *cars[] , that is, array of pointers to CAR .

In main , &cars is a pointer to array of CAR s.

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 3

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 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.