结构内的数组和结构的malloc

Question

一个malloc如何在另一个结构内的结构？

我也想在需要时的malloc一个struct内项目的数组，然后ReAlloc如果这个数组，这是怎么做正确？

您能给并声明一个结构的一个例子，则以上。

林有点不确定的事情的顺序。

会一个结构中的数组被释放，然后结构本身，必须在创建时的结构进行malloced然后将其字段中malloced /申报等？

Answer 1

包括内部另一个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中，下一个元素由指针引用，并且内存必须动态分配。

两个版本都是有用的，视情况而定。没有正确的方法来管理内存，这取决于您的使用情况。

对于数组，情况相同，要么是数组是静态大小的，然后它可以直接包含到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功能只做浅拷贝，也就是指针值被复制，但不是尖锐的物体。再一次，你如何处理它取决于你的应用程序。

Answer 2

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); 
} 

Answer 3

下面是在结构中嵌套结构和数组的一个例子。你会注意到嵌套元素在外部结构之前必须被处理，否则你最终会发生内存泄漏。

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); 
} 

Answer 4

typedef struct _A { int i; } A; 
typedef struct _B { int j; A a} B; 

为了得到一个B：

B *b = malloc(sizeof(B)); 

为了得到B的数组：

B *b = malloc(size(b) * arrayLength); 

Answer 5

这不是很可读，但有时人们创造一个结构的计数成员和最终的单元素数组成员。然后有一个特殊的工厂方法分配足够的空间，以便您可以写入数组中的元素。显然，数组成员可以是任何类型的。

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; 
}