Is it necessary to use new for dynamic memory allocation?

Question

In C, we can input the size of an array (at runtime) from the user by the concept of dynamic memory allocation. But we can also use

int n;
scanf("%d",&n);
int a[n];

So what is the need of using pointers for dynamic memory allocation using new?

Answer 1

You are not doing any "dynamic memory allocation", i.e. allocation of memory with dynamic lifetime. You are using "variable-length arrays" in C99. But it's still a local variable, with "automatic storage duration", which means the variable's lifetime is the scope in which it was declared.

Answer 2

Variable length array came into existence after C99 standard. Before that, there was no concept for VLA. Please note, moving forward, since C11, this has been changed to an optional feature.

OTOH, dynamic memory allocation using malloc()^## and family was there from long back.

That said, the VLA is still an array and usually, an array and a pointer are not the same. Array holds type and size information, while a pointer does not have any size information.

Also, FWIW, the array size can be defined at runtime, but that does not change the scope and lifetime as compared to normal arrays. Just using VLA approach does not change the lifetime of an otherwise automatic array to global or something else.

---

^{## There is no new keyword in C. GLIBC provides malloc() and family of APIs to handle dynamic memory allocation.}

Answer 3

What you have shown is called variable length array supported from C99.

Yes based on the input you are allocating memory. What if you want to extend the allocated memory.

Don't you need pointers now? In order to do realloc() . This is one scenario I can think of but we need pointers for dynamic memory allocation.

C doesn't have new so my answer is specific to C which has malloc() and family functions

If you have a function to allocate memory dynamically say

int *alloc_memory()
{
   int n;
   scanf("%d",&n);
   int a[n];
   // Fill values to array and do
   return a;
}

Now this will lead to undefined behavior as the allocated memory just has scope of the function. Pointers are useful for this purpose

int *alloc_memory()
{
   int n;
   scanf("%d",&n);
   int *p = malloc(sizeof(int) * n);
   // Fill values
   return p;
}

The point is VLA doesn't provide the flexibility which dynamic memory allocation by pointers provide you.

Answer 4

Using a VLA is conceptually similar to calling alloca to allocate automatic mmory.

A few differences between a Variable Length Array (VLA) and dynamically allocated memory using malloc:

1) The VLA is an automatic variable that will cease to exist when your function returns. Whereas dynamically allocated memory with malloc will exist until free is called or your program exits.

2) For data types other than arrays, such as structs, you probably want allocated with malloc.

3) The VLA is typically stored on the stack (although this is not strictly required by the C99 specification), whereas dynamically allocated memory with malloc is stored on the heap.