It is my understanding that in C and C++ , we create data-structures whose size is known at compile time on the stack and we use the heap (malloc-free / new-delete) for things whose size is not known at compile time and is decided at run-time.Why then , does my g++ compiler allow me to do something like the following code snippet.
int n ;
cin >> n ; // get the size of array.
int arr[n] ; // create a variable sized array.
.... do other stuff ...
They aren't allowed in standard C++, but they are allowed in standard C, and g++ allows them in C++ as well, as a language extension.
How then are variable sized arrays on the stack implemented?
See this question. The gist is that the size (
n) gets evaluated and stored in a compiler-generated local variable, and then that much stack space is allocated. There's no law of physics that says the size of a stack variable has to be known at compile-time - it's merely simpler that way.
Why are they even necessary?
They aren't. As you aid, you can do the same thing with dynamic allocation.
Why can't we just use the heap for variable sized buffers?
Stack allocation is more efficient.