为什么或何时需要在C中动态分配内存？

Question

动态内存分配是C编程中非常重要的主题.但是,我无法找到一个很好的解释,这使我们能够做到这一点,或者为什么需要这样做.

我们不能只声明变量和结构,而不必使用malloc()吗？

作为旁注,有什么区别:

ptr_one = (int *)malloc(sizeof(int));

和

int *ptr_one = malloc(sizeof(int));

Answer 1

在以下情况下需要使用动态内存:

• 您无法确定在编译时使用的最大内存量;
• 你想分配一个非常大的对象;
• 您希望构建没有固定大小的数据结构(容器);

您并不总是知道在编译时需要留出多少内存.想象一下处理一个数据文件(比如温度的时间序列),其中文件中的记录数量不固定.您可以只有10条记录或多达100000条记录.如果要将所有数据读入内存以进行处理,在读取文件之前,您将不知道要分配多少内存.如果文件的结构使得第一个值是记录数,则可以执行以下操作:

size_t recs = 0;
double *temps = NULL;

FILE *fp = fopen ( filename, "r" );
if ( fp )
{
  if ( fscanf( fp, "%zu", &recs ) == 1 )
  {
    temps = malloc( sizeof *temps * recs );
    if ( temps )
    {
      // read contents of file into temps
    }
  }
}

有时您需要分配一个非常大的对象,例如

int ginormous[1000][1000][1000];

假设一个4字节的整数,这个数组将需要4GB.不幸的是,堆栈帧(其中局部变量保留在大多数架构上)往往比这小得多,因此尝试分配那么多内存可能会导致运行时错误(通常会发生).动态存储器池(又名堆)通常远小于堆越大,要少得多任一项堆栈帧.所以对于令人讨厌的东西,你需要写一些类似的东西

int (*ginormous)[1000][1000] = malloc( sizeof *ginormous * 1000 );

这样的请求仍有可能失败; 如果你的堆足够多,你可能没有足够大的单个连续块来处理请求.如果有必要,你可以做一个零碎的分配; 行在内存中不一定是相邻的,但是你更有可能获得所需的所有内存:

int ***ginormous = malloc( sizeof *ginormous * 1000 );
if ( ginormous )
{
  for ( size_t i = 0; i < 1000; i++ )
  {
    ginormous[i] = malloc( sizeof *ginormous[i] * 1000 );
    if ( ginormous[i] )
    {
      ginormous[i][j] = malloc ( sizeof *ginormous[i][j] * 1000 );
      if ( ginormous[i][j] )
      {
        // initialize ginormous[i][j][k]
      }
    }
  }
}

最后,动态内存允许您构建可以在添加或删除数据时增长和缩小的容器,例如列表,树,队列等.您甚至可以构建自己的真实"字符串"数据类型,可以在追加时增长它的字符(类似于stringC++中的类型).

Answer 2

当您不知道内存的最坏情况要求时,需要动态分配.然后,不可能静态分配必要的内存,因为你不知道你需要多少.

即使您知道最坏情况的要求,仍然可能需要使用动态内存分配.它允许多个进程更有效地使用系统内存.所有进程都可以静态提交最坏情况的内存要求,但这会限制系统上可以存在多少个正在运行的进程.如果从来没有所有进程同时使用最坏的情况,那么系统内存不断运行未充分利用,这是浪费资源.

至于你的问题,你不应该把调用的结果malloc()强制转换为C.它可以隐藏缺失声明的错误(在C.99之前允许隐式声明),并导致未定义的行为.总是喜欢malloc()没有演员的结果.malloc()声明返回void *,并且在C中,void *总是允许和另一个指针类型之间的转换(模数类型限定符之类const).

Answer 3

作为旁注，以下之间有什么区别：ptr_one = (int *)malloc(sizeof(int))和int *ptr_one = malloc(sizeof(int))

看到这个。

首先，我知道这可能是一个荒谬的问题，因为动态内存分配是 C 编程中非常重要的主题。然而，我一直无法找到一个很好的解释来解释这能让我们做什么，或者为什么需要它。

与堆栈相比，内存池（或更常见的是堆）非常大。考虑这两个示例，了解为什么在堆栈上使用内存池很有用：

1.如果您定义了一个数组并希望它在多个堆栈帧中持续存在怎么办？当然，您可以将其声明为全局变量，并将其存储在内存的全局数据部分中，但是随着您的程序变得越来越大，这会变得混乱。或者，您可以将其存储在内存池中。

int *func( int k ) {
  assert( k >= 1 );

  int *ptr_block = malloc( sizeof( int ) * k );

  if ( ptr_block == NULL ) exit( EXIT_FAILURE );

  for ( int i = 0; i < k; i++ ) {
    ptr_block[ i ] = i + 1;
  }

  return ptr_block; // Valid.
}

...但是，如果您在堆栈上定义数组，则这将不起作用。原因是，一旦弹出堆栈帧，所有内存地址都可以被另一个堆栈帧使用（并因此被覆盖），而使用内存池中的内存将持续到free用户（您或客户端）使用为止。

2.如果您想实现一个动态数组来处理读取任意大的数字序列怎么办？您将无法在堆栈上定义数组，您需要使用内存池。回想一下，传递指向结构的指针而不是结构本身（因为它们可能相当大）是非常常见的（并且强烈推荐，除非您明确需要复制结构）。考虑动态数组的这个小实现：

struct dyn_array {
  int *arr;
  int len;
  int cap;
};

typedef struct dyn_array *DynArray;

void insert_item( int const item, DynArray dyn_arr ) {
  // Checks pre conditions.
  assert( dyn_arr != NULL );

  // Checks if the capacity is equal to the length. If so, double.
  if ( dyn_arr->cap == dyn_arr->len ) {
    dyn_arr->cap *= 2;

    DynArray new_dyn_arr = malloc( sizeof( int ) * dyn_arr->cap ); // [oo]

    // ... copy, switch pointers and free...
  }

  // ... insert, increase length, etc.
}

...在线[oo]注意，如果这是在堆栈上定义的，那么一旦弹出该堆栈帧，将不再分配数组的所有内存地址。这意味着，另一个堆栈帧（可能是下一个）将使用这些内存地址（或其某些子集）。

备注：从我的代码片段来看，ptr_block存储在堆栈上：因此&ptr_block是堆栈地址，但 的值ptr_block来自内存池的某个位置。