结构中的数组和结构的Malloc
如何将malloc放在另一个struct中的struct？
我还想在结构中malloc一个项目数组，然后在需要时重新分配这个数组，这是如何正确完成的？
你能举个例子来说明一个结构，然后是上面的结构。
我有点不确定事情的顺序。
是否可以释放结构中的数组，然后是结构本身，在创建结构时是否必须对结构进行malloced，然后对其字段进行malloced /声明等等？
包含在另一个struct struct包含在副本中，因此您不必单独对其进行malloc操作。 如果struct包含指向另一个struct的指针，那么你可以考虑动态地为它分配内存。
struct Point2d { float x; float y; }; struct Rect { struct Point2D a; struct Point2D b; }; struct LinkedListNode { struct LinkedListNode* next; int value; };
在struct Rect ， struct Point2D元素被插入到struct Rect ，您不必为它们动态分配内存。 相反，在struct LinkedListNode ，下一个元素由指针引用，并且必须动态分配内存。
这两个版本都很有用，具体取决于具体情况。 没有正确的方法来管理内存，这取决于您的使用情况。
在arrays的情况下也会发生同样的情况。 如果您的数组是静态大小的，那么它可以直接包含在struct 。 但是，如果大小可能不同，则必须在struct存储指针。
struct Header { char magic[4]; unsigned int width; unsigned int height; }; struct Buffer { char* data; unsigned int size; unsigned int capacity; }; struct Buffer* buffer_init() { struct Buffer* buffer = (struct Buffer*)malloc(sizeof(struct Buffer)); buffer->data = 0; buffer->size = 0; buffer->capacity = 0; } void buffer_grow(struct Buffer* buffer, size_t capacity) { if (capacity > buffer->capacity) { buffer->data = realloc(buffer->data, capacity); buffer->capacity = capacity; } } void buffer_append(struct Buffer* buffer, const char* data, unsigned int dataLen) { if (dataLen + buffer->size > buffer->capacity) buffer_grow(MAX(dataLen + buffer->size, buffer->capacity * 2)); memcpy(buffer->data + buffer->size, data, dataLen); buffer->size += dataLen; }
realloc函数只执行浅复制，即复制指针值，但不复制指向对象。 再一次，你如何处理它将取决于你的应用程序。
typedef struct _A { int *arr; int arrCount; } A; void Construct_A(A *a, int arraySize) { a->arrCount = arraySize; a->arr = (int*)malloc(sizeof(int)*arraySize); } void Destruct_A(A *a) { free(a->arr); a->arr = 0; } typedef struct _B { A *a; } B; void Construct_B(B *b, int arraySize_A) { b->a = (A*)malloc(sizeof(A)); Construct_A(b->a); } void Destruct_B(B *b) { Destruct_A(b->a); free(b->a); b->a = 0; } void main() { B b; Construct_B(&b, 10); // Use b and b->a Destruct_B(&b); }
以下是结构中嵌套结构和数组的示例。 您将注意到在free外部结构之前必须如何处理嵌套元素，否则最终会导致内存泄漏。
typedef struct Base Base; struct Base { int x; }; typedef struct Sample Sample; struct Sample { Base base; int size; int *arr; }; // Create the sample struct Sample *createSample() { Sample sample = malloc(sizeof(Sample)); if(sample == NULL) { return NULL; } sample->base = malloc(sizeof(Base)); if(sample->base == NULL) { free(sample); return NULL; } sample->base->x = 0; sample->size = 0; sample->arr = NULL; return sample; } // Adding element to the array void addItemToSample(Sample *sample, int item) { if(sample == NULL) { return; } int *arr = realloc(sample->arr, sizeof(int) * (sample->size + 1)); if(arr == NULL) { return; } arr[sample->size++] = item; sample->arr = arr; } // Freeing the struct void freeSample(Sample *sample) { // Free deep elements first free(sample->base); free(sample->arr); // Free outer free(sample); }
它不是很易读，但有时人们会创建一个带有count成员和最终单元素数组成员的结构。 然后有一个特殊的工厂方法，它分配足够的空间，以便您可以写入数组中的count元素。 显然，arrays成员可以是任何类型。
typedef struct { int count; int elements[1]; } int_array; int_array* allocate_int_array(int count) { int_array* mem = (int_array*)malloc(sizeof(int_array) + (count - 1) * sizeof(int)); if (mem) mem->count = count; return mem; }
typedef struct _A { int i; } A; typedef struct _B { int j; A a} B;
要获得单个B：
B *b = malloc(sizeof(B));
要获得B的数组：
B *b = malloc(sizeof(B) * arrayLength);