Question

我有一个结构，它显示我的数据元素

struct myElement
{
    int field1;
    int field2;
    int field3;    
};

另一个结构，其中包含此元素的数组和另一些数据

struct myArray 
{
    struct myElement *elements;
    int someData;
};

我需要像这样的数组

struct myArray *myMatrix;

但是我的内存分配有问题。 myArray中的元素数量也可能不同，在myMatrix中也是如此，所以我需要动态分配内存。在这种情况下分配和释放内存的正确方法是什么？

Answer 1

以下是一个小例子，说明如何在malloc中分配（free）和解除分配（struct myElement）动态struct myArray数组。另请注意，您需要跟踪数组的大小，因此我将size_t elements_len;添加到struct myArray（原谅camelCase和下划线的组合 - 我在C中使用下划线，但不想要修改您的标识符）：

#include <stdlib.h>

struct myElement
{
    int field1;
    int field2;
    int field3;    
};

struct myArray 
{
    struct myElement *elements;
    size_t elements_len;
    int someData;
};

void allocate_elements(struct myArray *m, size_t length)
{
   m->elements = malloc(length * sizeof( *m->elements) );
   m->elements_len = length;
}

void free_elements(struct myArray *m)
{
   free(m->elements);
   m->elements = NULL;  /* point to NULL to signify no array allocated */
   m->elements_len = 0; /* length of 0 also signifies no elements/no array */
}

int main(void)
{
   struct myArray ma;

   allocate_elements(&ma, 5);
   free_elements(&ma);

   return 0;
}

应用类似的逻辑以获得struct myArray的动态数组。你需要malloc足够的内存用于struct myArray的X量，然后for该数组中的每个struct myArray元素，你可以调用allocate_elements。然后在完成后迭代遍历数组中的每个元素并调用free_elements。

Answer 2

int  num_elements = 1234;  // whatever

struct myArray *myMatrix;

myMatrix = malloc (num_elements * sizeof (*myMatrix));
if (!myMatrix)
     // error

// subsequent use of myMatrix is just like it had been statically dimensioned:
myMatrix [0].someData =  343;

myMatrix [1].someData =  323;

Answer 3

使用malloc分配内存：

myMatrix = malloc(sizeof(myArray)*dim1);
for (int i = 0; i < dim1; i++)
    myMatrix[i].elements = malloc(sizeof(myElement)*dim2);

以类似的方式使用free，以便在完成后释放内存。

Answer 4

struct myArray *myMatrix = malloc(Nentries * sizeof(*myMatrix));
if (myMatrix != 0)
{
    for (int i = 0; i < Nentries; i++)
    {
        myMatrix[i].elements = malloc(Nelements[i] * sizeof(myElement));
        if (myMatrix[i].elements != 0)
        {
            for (int j = 0; j < Nelements[i]; j++)
            {
                myElement *e = &myMatrix[i].elements[j];
                e->field1 = 0;
                e->field2 = 1;
                e->field3 = 2;
            }
            myMatrix[i].someData = 37;
        }
    }
}

我假设Nentries表示矩阵中有多少元素，并且数组Nelements的每个元素表示矩阵的相应元素中有多少元素。代码测试成功的内存分配，但不会对分配失败做出反应。

Answer 5

这样的东西应该可行，虽然它不是一个很好的解决方案，有这么多单独的分配，更进一步向下是一个更好的解决方案。我试图让变量名称描述它们的含义。

int arrayOfSubArrayLengths={9,5,10,50,...};
int lengthOfMyMatrix=something;

myMatrix= (myArray*) malloc( sizeof(myArray) * lengthOfMyMatrix);

for(int i=0; i<lengthOfMyMatrix; ++i)
{
    myMatrix[i].elements=new myElement[arrayOfSubArrayLengths];
    myMatrix[i].someData=whatever;
}

删除：

for(int i=0; i<lengthOfMyMatrix; ++i)
{
    free( myMatrix[i].elements );
}
free( myMatrix );

然而正如我所说，这不是一个很好的解决方案，有这么多的分配。它可能会导致一些严重的内存碎片，具体取决于lengthOfMyMatrix的大小。此外，对分配器的这么多调用可能会再次依赖于lengthOfMyMatrix的大小来减慢速度。这是一个更好的解决方案：

int arrayOfSubArrayLengths={9,5,10,50,...};
int lengthOfMyMatrix=something;
int sumOfSubArrayLengths=someNumber;

myArray* fullArray=(myElement*) malloc( sizeof(myElement) * sumOfSubArrayLengths);

myMatrix= (myArray*) malloc( sizeof(myArray) * lengthOfMyMatrix);

int runningSum=0;

for(int i=0; i<lengthOfMyMatrix; ++i)
{
    myMatrix[i].elements = &fullArray[runningSum];
    runningSum += arrayOfSubArrayLengths[i];
    myMatrix[i].someData = whatever;
}

删除：

free( fullArray );
free( myMatrix );

以这种方式，无论各种长度，都只有两次调用分配器。因此存在更多的内存碎片和更少的分配开销时间。第二种方法的一个缺点是，如果你不小心边界检查，很容易破坏数组中的数据而不知道因为内存“属于”你因此操作系统不会因为访问冲突而踢你。

Answer 6

您需要使用malloc和free函数来动态分配和释放内存。请使用以下作为参考。

#include <stdio.h>
#include <stdlib.h>

int main()
{

    struct myElement {
        int field1;
        int field2;
        int field3;
    };

    struct myArray {
        struct myElement *elements;
        int someData;
    };

    struct myArray *myMatrix = NULL;

    int n_myarray = 0;
    int n_elements = 0;
    int i, j;

    printf("How many myArray's do you want? ");
    scanf("%d", &n_myarray);

    printf("How many elements do you want in each array? ");
    scanf("%d", &n_elements);

    /* memory allocation starts here */
    if ((myMatrix = (struct myArray *) malloc((int)sizeof(struct myArray) * n_myarray)) == NULL) {
        printf("ERROR: unable to allocate array\n");
        return 1;
    }

    for (i=0 ; i<n_myarray ; i++) {
        if ((myMatrix[i].elements = (struct myElement *) malloc((int)sizeof(struct myElement) * n_elements)) == NULL) {
            printf("ERROR: unable to allocate array elements\n");
            free(myMatrix);
            return 1;
        }

        /* initialization of other members of struct myArray goes here */
        myMatrix[i].someData = 123;

        /* initialization of members of struct myElement goes here */
        for (j=0 ; j<n_elements ; j++) {
            myMatrix[i].elements[j].field1 = 123;
            myMatrix[i].elements[j].field2 = 123;
            myMatrix[i].elements[j].field3 = 123;
        }
    }

    /* do your calculations here */
    /* I'm printing the values */

    for (i=0 ; i<n_myarray ; i++) {
        printf("myMatrix[%d].someData : %d \n", i, myMatrix[i].someData);
        for (j=0 ; j<n_elements ; j++) {
            printf("myMatrix[%d].elements[%d].field1 : %d \n", i, j, myMatrix[i].elements[j].field1);
            printf("myMatrix[%d].elements[%d].field2 : %d \n", i, j, myMatrix[i].elements[j].field2);
            printf("myMatrix[%d].elements[%d].field3 : %d \n", i, j, myMatrix[i].elements[j].field3);
        }
    }

    /* memory deallocation (free) starts here */

    for (i=0 ; i<n_myarray ; i++) {
        free(myMatrix[i].elements);
    }
    free(myMatrix);

    return 0;
}

> ./a.out
How many myArray's do you want? 2
How many elements do you want in each array? 5
myMatrix[0].someData : 123
myMatrix[0].elements[0].field1 : 123
myMatrix[0].elements[0].field2 : 123
myMatrix[0].elements[0].field3 : 123
myMatrix[0].elements[1].field1 : 123
myMatrix[0].elements[1].field2 : 123
myMatrix[0].elements[1].field3 : 123
myMatrix[0].elements[2].field1 : 123
myMatrix[0].elements[2].field2 : 123
myMatrix[0].elements[2].field3 : 123
myMatrix[0].elements[3].field1 : 123
myMatrix[0].elements[3].field2 : 123
myMatrix[0].elements[3].field3 : 123
myMatrix[0].elements[4].field1 : 123
myMatrix[0].elements[4].field2 : 123
myMatrix[0].elements[4].field3 : 123
myMatrix[1].someData : 123
myMatrix[1].elements[0].field1 : 123
myMatrix[1].elements[0].field2 : 123
myMatrix[1].elements[0].field3 : 123
myMatrix[1].elements[1].field1 : 123
myMatrix[1].elements[1].field2 : 123
myMatrix[1].elements[1].field3 : 123
myMatrix[1].elements[2].field1 : 123
myMatrix[1].elements[2].field2 : 123
myMatrix[1].elements[2].field3 : 123
myMatrix[1].elements[3].field1 : 123
myMatrix[1].elements[3].field2 : 123
myMatrix[1].elements[3].field3 : 123
myMatrix[1].elements[4].field1 : 123
myMatrix[1].elements[4].field2 : 123
myMatrix[1].elements[4].field3 : 123
>

请确保以下内容：

malloc

应该有一个free
在使用使用malloc分配的内存之前，必须检查malloc是否已成功分配了您请求的内存块。

在纯C中对struct进行内存分配

6 个答案: