当我们在 c 中有更简单的代码时，为什么要使用 malloc 或 calloc？

Question

#include <stdio.h>

int main() {
    int n = 0, i;
    printf("Enter the size of array\n");
    scanf("%d", &n);
    int a[n];
    for (i = 0; i < n; i++) {
        a[i] = i + 1;
        printf("%d,", a[i]);
    }
}

May I know the difference between malloc() and calloc() and this code, because I guess both are fulfilling the need?

Answer 1

Note that as per the latest standard, VLAs are not mandatory part of the spec. Allocator functions ( malloc() and family) are the standard way of allocating memory for which size is only known at run-time.

Quoting C18 , chapter 6.7.6.2/P4

[...] (Variable length arrays are a conditional feature that implementations need not support; see 6.10.8.3.)

That said, there are other usage limitations in case of VLAs due to their nature, their lifetime is limited in the scope in which they are defined. For example, you cannot return a VLA, defined in a function from a function call, but if you use allocator functions, you can return the pointer, as it's lifetime remains until programatically released (call free() ).

Answer 2

The line

int a[n];

declares a as a variable-length array . VLAs are useful, but limited:

• They cannot be declared with the static keyword or at file scope;
• They cannot be initialized in the declaration - eg, you can't write something like int a[n] = {0}; ;
• They cannot be members of a struct or union type;
• They cannot be arbitrarily large;
• They are not universally supported - they were introduced in the 1999 revision of the language definition and made optional in the 2011 revision;
• They cannot be resized after they are defined - the "variable" in variable-length only means that their size isn't fixed from one definition to the next.

Like any auto variable, they cease to exist when you exit their enclosing scope.

Dynamically-allocated memory has a few advantages over VLAs:

• The memory stays allocated until you explicitly free it;
• You can allocate an arbitrarily large block of memory;
• You can resize the allocated block as necessary;
• Unlike VLAs, malloc , calloc , and realloc are supported by any hosted implementation;

If all you need is some temporary working storage within a function, you don't know its size ahead of time, you don't need too much of it, and they are supported, then VLAs are a good option and less messy than using malloc or calloc .