如何在结构内部重新分配double数组

Question

I would like to dynamically change the size of an array inside a struct. I got the following structure:

struct PolynomStruct {
  double * term;
  unsigned int size;
};

typedef struct PolynomStruct *Polynom;

When I try to create a new Polynom I have to reserve memory for the struct to use the variables inside the struct, right?:

Polynom res = malloc(sizeof(struct PolynomStruct));
res->size = 10;

Afterwards I want to add a double to the term array at index 4. So it shall look like this [0,0,0,0,2.0000]. The first thing I do is to reallocate the memory of the array.

  res->term = realloc(5 * sizeof(double));

In my opinion the sizeof(res->term) should be 5 * 8 bytes = 40 bytes. But the following code returns 8.

printf("size term: %lu\n",sizeof(res->term));

"size term: 8"

Afterwards I tried to do this:

res->term[4] = 2;
printf("%f\n",res->term[4] );

It prints "2.000000" to stdout. I really dont get how this works. I would be very happy if someone could give me a hint. Sorry for my English.

Answer 1

sizeof(res->term) returns size of the pointer, not of the allocated memory. You need to track manually the allocated amount, ie by res->size * sizeof(*term) or something similar.

Answer 2

First you don't want this:

Polynom res = malloc(sizeof(struct PolynomStruct));
res->size = 10;

You've allocated space for the struct but not initialised the term pointer you want:

Polynom res = malloc(sizeof(struct PolynomStruct));
if(res==NULL){
  //Handle allocation failure...
}
res_>term=NULL;
res->size = 0;

//Later....
free(res->term);
free(res);

That allocates space for the struct and initialises the array as empty. Notice it's fine to pass NULL to free() it does nothing and returns normally.

Or if you did want to preallocate 10 terms:

Polynom res = malloc(sizeof(struct PolynomStruct));
if(res==NULL){
  //Handle allocation failure...
}
res->size = 10;
res_>term=malloc(res->size*sizeof(double));
if(res->term==NULL){
  res->size=0;
  //Handle error...
}

//Later (when finished with res)...
free(res->term);
free(res);

That preallocates the array to being 10. If you preallocate you may want to track a capac (how much is allocated) and size (how much is used). But that's beyond the scope here.

To reallocate write a function ike this:

int reallocate(Polynom res,int newsize){
    double *resized=realloc(res->term,newsize*sizeof(double));
    if (resize==NULL){
      //Allocation failed. The array is the same size as before.
      return 1; //Or handle error your own way.
    }
    res->term=resized;
    res->size=newsize;
    //realloc may extend the space allocated in place or realloc space elsewhere.
    //If it does reallocate elsewhere the current contents are just copied over 
    //(byte for byte) and the old space freed. 
    return 0;//Success. No error.
}


//Later (when finished with res)...
free(res->term);
free(res);

It's often wise to then res=NULL; to avoid confusing mishaps.

Notice if a pointer was returned by malloc or realloc (and not NULL ) it must go to free() (exactly once).

Also notice realloc can reduce the size so newsize < res->size is fine.

Answer 3

I feel there might be some confusion over pointer vs array. Please read this helpful article: Are pointers and arrays equivalent in C?

You don't "change the size of an array inside a struct" because the whole point of having a struct is keeping things stable. Therefore, Polynom res = malloc(sizeof(struct PolynomStruct)) will always allocate the same amount of memo on the heap for res.

If you want to build a heap array of doubles and points term to it, you can do:

int member=10; // grow array size by member=member*2 for example
double a[]=malloc(member*sizeof(double));
term=a; 

This way, you can dynamically grow your array.