当分配给另一个变量时，C 中的结构中的 malloced 数据会发生什么情况？

Question

Let's say I have a structure named "example" which has a member named data which stores data allocated on the heap:

typedef struct _EXAMPLE
{
    signed char *data;
    size_t size;
} example_t;

example_t *example_alloc(size_t size)
{
    example_t *ret = malloc(sizeof *ret);
    ret->size = size;
    ret->data = calloc(size, sizeof *ret->data);

    return ret;
}

example_t *a = example_alloc(10), b = *a;

Is the value in b.data stored on the stack or the heap? Does it point to the data in a ?

Answer 1

Pointers are just values.

In the same way that b.size is just a copy of a->size , b.data is a copy of the same pointer value that a->data holds.

It points to the same location, wherever that may be.

Care must be taken, as free ing a->data invalidates b.data , and vice versa, which may result in Undefined Behavior if accessed.

Answer 2

The structure b is a local variable, and all its members are stored locally in the stack (please, no pedantic comments saying that C doesn't specify that there's a stack -- it requires something that acts like a stack).

Since b.data is a member of b , it's stored on the stack. However, the data that it points to is the same as what a->data points to, and that's the heap memory that was allocated with calloc() in the function.

Answer 3

Following b = *a , a->data == b.data . That is to say they both refer to the same allocated memory. This is known as a " shallow copy ". To achieve a "deep copy" in C would require additional code. For example:

example_t* example_copy( example_t* b, const example_t* a )
{
    *b = *a ; // shallow copy all members
    
    // Allocate new block and copy content
    size_t sizeof_block = b->size * sizeof(*b->data)
    b->data = malloc( sizeof_block ) ;
    memcpy( b->data, a->data, sizeof_block ) ;

    return b ;
}

Then

example_t *a = example_alloc(10) ;
example_t b ;
example_copy( &b, a ) ;

Note that such code is is horribly prone to memory leaks. Here for example if b goes out of scope before b.data is free 'd, you will have lost access to that memory. Any function that allocates memory and returns without having free 'd it is making it the caller's responsibility whilst not at all making that necessarily visible or obvious (your naming convention _alloc is some level of mitigation perhaps). You should at least also implement corresponding functions to facilitate the clean-up of objects. I appreciate that it is an off-topic point but C++ provides a solution to this issue where a destructor is invoked when an object goes out of scope. Additionally copy constructors and assignment operator overloading can be used to automatically invoke deep-copy semantics.