Why no variable size array in stack?

Question

I don't really understand why I can't have a variable size array on the stack, so something like

foo(int n) {
   int a[n];
}

As I understand the stack(-segment) of part of the data-segment and thus it is not of "constant size".

Answer 1

Variable Length Arrays(VLA) are not allowed in C++ as per the C++ standard.
Many compilers including gcc support them as a compiler extension, but it is important to note that any code that uses such an extension is non portable.

C++ provides std::vector for implementing a similar functionality as VLA.

---

There was a proposal to introduce Variable Length Arrays in C++11, but eventually was dropped, because it would need large changes to the type system in C++. The benefit of being able to create small arrays on stack without wasting space or calling constructors for not used elements was considered not significant enough for large changes in C++ type system.

Answer 2

Note that the proposal was rejected and the following is no longer true. It may be revived for a future version of C++ though.

VLA as described in N3639 has been accepted in Bristol meeting and will become part of C++14, as well as a library counter-part "dynarray". So using compiler with C++14 support we can start writing something like:

void func(int n)
{
    int arr[n];
}

Or use dynarray:

#include <dynarray>

void func(int n)
{
    std::dynarray<int> arr(n);
}

Answer 3

I'll try to explain this with an example:

Say you have this function:

int myFunc() {
   int n = 16;
   int arr[n];
   int k = 1;
}

When the program runs, it sets the variables in this way onto the stack:

- n @relative addr 0
- arr[16] @relative addr 4
- k @relative addr 64
TOTAL SIZE: 68 bytes

Let's say I want to resize arr to 4 elements. I'm going to do:

delete arr;
arr = new int[4];

Now: if i leave the stack this way, the stack will have holes of unused space. So the most intelligent thing to do is to move all the variables from one place to another in the stack and recompute their positions. But we are missing something: C++ does not set the positions on the fly, it is done only once, when you compile the program. Why? It is straightforward: because there is no real need of having variable size objects onto the stack, and because having them would slow down all the programs when allocating/reallocating stack space.

This is not the only problem, there is another, even bigger one: When you allocate an array, you decide how much space it will take and the compiler can warn you if you exceed the available space, instead if you let the program allocate variable size arrays on your stack, you are opening breaches in security, since you make all the programs that use this kind of method vulnerable to stack-overflows.

Answer 4

Simple answer: because it is not defined in the C++ standard.

Not so simple answer: Because no one propsed something behaving coherently for C++ in that case. From the standards POV there is no stack, it could be implemented totally differently. C99 has VLAs, but they seem to be so complex to implement that gcc only finished the implementation in 4.6. I don't think many people will want to propose something for C++ and see compiler manufacturers struggle with it for many years.

Answer 5

Stacks are fairly small, and their sizes can vary dramatically per architecture. The problem is that it is fairly easy to 'over-allocate' and cause a seg fault or write over memory owned by somebody else. Meanwhile, solutions to the problem (e.g. vector) have existed for a long time.

FWIW, I read Stroustrup say that he didn't want them, but I don't know which interview it was in.

Answer 6

Because in C++ a static array needs a static constant size, so it is not allowed by the language. Note that C99 does support vararrays at the stack, and some implementations support it under C++ as well as an extension.

Answer 7

Because the language specification says so. Nothing else matters (and explaining with segments is terribly wrong for different reasons).