Variable Length vs Malloc-ed arrays

According to c99 standard, we can write the following code and it's totally legal

int x;
scanf("%d",&x);
int ar[x];

My question is, if I can allocate an array like this, why would I ever need malloc to allocate variable size arrays again?

Also, could you please explain how does the var开发者_开发问答iable length arrays allocation happens? Deep inside, does it call malloc to allocate the array or what?

---

Two reasons spring to my mind:

1. Arrays that live beyond this stack frame.
2. Arrays that are bigger than the stack.

---

Variable length array allocation (or any array declaration actually) is done on the stack (assuming GCC compiler). Malloc assigns memory from the heap.

Two advantages to heap vs. stack: 1. Stack is much smaller. There is a decent chance that your variable-size array could cause your stack to overflow. 2. Items allocated on the stack don't survive after the function they were declared in returns.

---

In the C11 standard, variable length arrays became "optional" which I take to mean "implementation defined" and as such they are no longer portable.

This is shown in

6.7.6.2 Array declarators section 4

Variable length arrays are a conditional feature that implementations need not support.

and

6.10.8.3 Conditional feature macros section 1

__STDC_NO_VLA__ The integer constant 1, intended to indicate that the implementation does not support variable length arrays or variably modified types.

Some advantages of using malloc over the VLA are:

• The implementation of malloc usually obtains memory from the heap which in most C implememtations is a bigger resource than the stack. However neither heap nor stack are mentioned in the C standard, but they are common ways to implement global and local memory.
• Memory obtained from malloc can be increased or reduced by realloc but it is not possible with a VLA.
• Memory obtained from malloc can be passed around the program until freed, with pointers, but the VLA can only be used in a hierarchy of functions. The VLA becomes dead after the function in which it is defined returns, because it goes out of scope.