Increasing The Size of Memory Allocated to a Struct via Malloc

2018-06-28 17:13:56

I just learned that it's possible to increase the size of the memory you'll allocate to a struct when using the malloc function. For example, you can have a struct like this:

struct test{
    char a;
    int v[1];
    char b;
};

Which clearly has space for only 2 chars and 1 int (pointer to an int in reality, but anyway). But you could call malloc in such a way to make the struct holds 2 chars and as many ints as you wanted (let's say 10):

int main(){
    struct test *ptr;
    ptr = malloc (sizeof(struct test)+sizeof(int)*9);
    ptr->v[9]=50;
    printf("%dn",ptr->v[9]);   
return 0;
}

The output here would be "50" printed on the screen, meaning that the array inside the struct was holding up to 10 ints.

My questions for the experienced C programmers out there:

What is happening behind the scenes here? Does the computer allocate 2+4 (2 chars + pointer to int) bytes for the standard "struct test", and then 4*9 more bytes of memory and let the pointer "ptr" put whatever kind of data it wants on those extra bytes?

Does this trick only works when there is an array inside the struct?

If the array is not the last member of the struct, how does the computer manage the memory block allocated?

...Which clearly has space for only 2 chars and 1 int (pointer to an int in reality, but anyway)...

Already incorrect. Arrays are not pointers. Your struct holds space for 2 char s and 1 int . There's no pointer of any kind there. What you have declared is essentially equivalent to

struct test {
    char a;
    int v;
    char b;
};

There's not much difference between an array of 1 element and an ordinary variable (there's conceptual difference only, ie syntactic sugar).

...But you could call malloc in such a way to make it hold 1 char and as many ints as you wanted (let's say 10)...

Er... If you want it to hold 1 char , why did you declare your struct with 2 char s???

Anyway, in order to implement an array of flexible size as a member of a struct you have to place your array at the very end of the struct.

struct test {
    char a;
    char b;
    int v[1];
};

Then you can allocate memory for your struct with some "extra" memory for the array at the end

struct test *ptr = malloc(offsetof(struct test, v) + sizeof(int) * 10);

(Note how offsetof is used to calculate the proper size).

That way it will work, giving you an array of size 10 and 2 char s in the struct (as declared). It is called "struct hack" and it depends critically on the array being the very last member of the struct.

C99 version of C language introduced dedicated support for "struct hack". In C99 it can be done as

struct test {
    char a;
    char b;
    int v[];
};

...
struct test *ptr = malloc(sizeof(struct test) + sizeof(int) * 10);

malloc allocates as much memory as you ask it to allocate. It is just a single flat block of raw memory. Nothing else happens "behind the scenes". There's no "pointer to int" of any kind in your struct, so any questions that involve "pointer to int" make no sense at all.

Does this trick only works when there is an array inside the struct?

Well, that's the whole point: to access the extra memory as if it belongs to an array declared as the last member of the struct.

If the array is not the last member of the struct, how does the computer manage the memory block allocated?

It doesn't manage anything. If the array is not the last member of the struct, then trying to work with the extra elements of the array will trash the members of the struct that declared after the array. This is pretty useless, which is why the "flexible" array has to be the last member.

No, that does not work. You can't change the immutable size of a struct (which is a compile-time allocation, after all) by using malloc ( ) at run time. But you can allocate a memory block, or change its size, such that it holds more than one struct:

int main(){
    struct test *ptr;
    ptr = malloc (sizeof(struct test) * 9);
}

That's just about all you can do with malloc ( ) in this context.

In addition to what others have told you (summary: arrays are not pointers, pointers are not arrays, read section 6 of the comp.lang.c FAQ), attempting to access array elements past the last element invokes undefined behavior.

Let's look at an example that doesn't involve dynamic allocation:

struct foo {
    int arr1[1];
    int arr2[1000];
};

struct foo obj;

The language guarantees that obj.arr1 will be allocated starting at offset 0, and that the offset of obj.arr2 will be sizeof (int) or more (the compiler may insert padding between struct members and after the last member, but not before the first one). So we know that there's enough room in obj for multiple int objects immediately following obj.arr1 . That means that if you write obj.arr1[5] = 42 , and then later access obj.arr[5] , you'll probably get back the value 42 that you stored there (and you'll probably have clobbered obj.arr2[4] ).

The C language doesn't require array bounds checking, but it makes the behavior of accessing an array outside its declared bounds undefined. Anything could happen -- including having the code quietly behave just the way you want it to. In fact, C permits array bounds checking; it just doesn't provide a way to handle errors, and most compilers don't implement it.

For an example like this, you're most likely to run into visible problems in the presence of optimization. A compiler (particularly an optimizing compiler) is permitted to assume that your program's behavior is well-defined, and to rearrange the generated code to take advantage of that assumption. If you write

int index = 5;
obj.arr1[index] = 42;

the compiler is permitted to assume that the index operation doesn't go outside the declared bounds of the array. As Henry Spencer wrote, "If you lie to the compiler, it will get its revenge".

Strictly speaking, the struct hack probably involves undefined behavior (which is why C99 added a well-defined version of it), but it's been so widely used that most or all compilers will support it. This is covered in question 2.6 of the comp.lang.c FAQ.

链接地址: http://www.djcxy.com/p/80208.html

上一篇: 结构的大小不等于其内容的大小

下一篇: 通过Malloc增加分配给结构的内存大小