如何在函数中动态分配内存？

Question

假设我想动态分配内存，但使用函数而不是 main() 函数。

所以我尝试这样做：

dynamAlloc(int *fPtr)
{
   fPtr=malloc(cols * sizeof(*fPtr) );
   if(fPtr==NULL)
    { 
      printf("Can't allocate memory");
      exit(1);
    }
}

然后我意识到：即使在堆上分配的内存在程序的整个生命周期内都可以使用，但该内存只能被形式参数 fPtr 引用，而不是实际参数（我们称之为 aPtr）。但是一旦退出函数，该内存就会丢失。

那么我该如何使用函数动态分配内存呢？

Answer 1

内存只能被形式参数fPtr引用，而不是实际参数（我们称之为aPtr）。

aPtr 不能在调用dynamAlloc() 之前表示堆内存对象，因为该对象尚未分配，其地址已分配给aPtr 槽fPtr。此后aPtr做引用堆对象。

我们只需要将aPtr的指针地址传递给dynamAlloc()即可。因此，您需要适当的参数（实际参数）和参数（形式参数）在函数之间传递指针 aPtr 的地址，如下所示。

那么我该如何使用函数动态分配内存呢？

您可以像 main() 那样做，不管指针是在 main() 还是其他函数中声明的，您只需将指针 aPtr 的地址传递给其他函数，你想在其中使用堆内存对象，比如fe：

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

#define cols 5

void dynamAlloc(int** fPtr);

int main()
{
    int* aPtr;

    dynamAlloc(&aPtr);

    free(aPtr);

    return 0;
}


void dynamAlloc(int** fPtr)                 
{
   *fPtr = malloc(sizeof(*fPtr) * cols);
   if(*fPtr == NULL)
    { 
      printf("Can't allocate memory");
      exit(1);
    }
}

---

别忘了free()堆内存！

Answer 2

或者直接改成这样：

void dynamAlloc(int **fPtr)
{
   *fPtr=malloc(cols * sizeof(**fPtr) ); // malloc is returning void* so in that place it would be compiler error, so pointer returned from malloc should be casted to the pointer type of the value.
   if(*fPtr==NULL) // that would be a warning in gcc since NULL is a macro eq to 0, or (void*)0, it compiler version
    { 
      printf("Can't allocate memory");
      exit(1);
    }
}

及功能用法：

int* ptr = (int*)NULL;
dynamAlloc(&ptr);
*ptr = 1; // assign 1 to the first element, ptr is a valid pointer here

但双指针语法在某些情况下可能会变慢，最后用返回函数回答，该本地指针的副本是更好的做法。

Answer 3

由于您需要更改指针本身 - 需要指向指针的指针

void *allocate(void **tmp, size_t size)
{
    if(tmp)
    {
        *tmp = malloc(size);
    }
    return *tmp;
}


int main()
{
    int *ptr;

    if(!allocate((void**)&ptr, sizeof(*ptr) * 100))
    {
        perror("Error\n");
        exit(1);
    }
    /* do something*/
    free(ptr);
}

Answer 4

使用宏函数更方便，像这样：

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

#define NEW_ARRAY(ptr, n) \
    { \
        (ptr) = malloc((size_t) (n) * sizeof (ptr)[0]); \
        if ((ptr) == NULL) { \
            fputs("Can't allocate memory\n", stderr); \
            exit(EXIT_FAILURE); \
        } \
    }

#define NEW(ptr) NEW_ARRAY((ptr), 1)

int main(void)
{
    int *myArray;
    const int myArrayLen = 100;
    int i;

    NEW_ARRAY(myArray, myArrayLen);
    for (i = 0; i < myArrayLen; i++) {
        /*...*/
    }
    return 0;
}

更新：

宏的目的是抽象出细节并使内存分配更不容易出错。对于（非宏）函数，我们必须将元素大小作为参数传递，因为当指针传递给 void 指针类型的形式参数时，该信息会丢失：

void NewArray(void *ptr, int n, int elemSize)
{
        *ptr = malloc((size_t) n * sizeof elemSize);
        if (*ptr == NULL) {
            fputs("Can't allocate memory\n", stderr);
            exit(EXIT_FAILURE);
        }
}

有了函数NewArray，对应第一个例子的分配调用就变成了

NewArray(&myArray, n, sizeof myArray[0]);

这对我们没什么好处。