Variable length arrays in C++?

Question

I haven't used C very much in the last few years. When I read this question today I came across some C syntax which I wasn't familiar with.

Apparently in C99 the following syntax is valid:

void foo(int n) {
    int values[n]; //Declare a variable length array
}

This seems like a pretty useful feature, does anyone now if there was ever a discussion on adding it to the C++ standard, and if so why it was omitted? Some potential reasons:

• Hairy for compiler vendors to implement
• Incompatible with some other part of the standard
• Functionality can be emulated with other C++ constructs
• ???

The C++ standard states that array size must be a constant expression (8.3.4.1)

Yes, of course I realize that in the toy example one could use std::vector<int> values(m); but this allocates memory from the heap and not the stack. And if I want a multidimensional array like:

void foo(int x, int y, int z) {
    int values[x][y][z]; //Declare a variable length array
}

the vector version becomes pretty clumsy

void foo(int x, int y, int z) {
    vector< vector< vector<int> > > values(/*really painful expression here*/);
}

The slices, rows and columns will also potentially be spread all over memory.

EDIT: Looking at the discussion at comp.std.c++ it's clear that this question is pretty controversial with some very heavyweight names on both sides of the argument. It's certainly not obvious that a std::vector is always a better solution.

Answer 1

You need a constant expression to declare an array in C/C++.

For dynamic size arrays, you need to allocate memory on heap, then manage the liftime of this memory.

void foo(int n) {
    int values = new int[n]; //Declare a variable length array
    [...]
    delete [] values;
}

Answer 2

Use std::vector for this. For example:

std::vector<int> values;
values.resize(n);

The memory will be allocated on the heap, but this holds only a small performance drawback. Furthermore, it is wise not to allocate large datablocks on the stack, as it is rather limited in size.

Answer 3

Arrays like this are part of C99, but not part of standard C++. as others have said, a vector is always a much better solution, which is probably why variable sized arrays are not in the C++ standatrd (or in the proposed C++0x standard).

BTW, for questions on "why" the C++ standard is the way it is, the moderated Usenet newsgroup comp.std.c++ is the place to go to.

Answer 4

This was considered for inclusion in C++/1x, but was dropped (this is a correction to what I said earlier).

It would be less useful in C++ anyway since we already have std::vector to fill this role.

Answer 5

If you know the value at compile time you can do the following:

template <int X>
void foo(void)
{
   int values[X];

}

Edit: You can create an a vector that uses a stack allocator (alloca), since the allocator is a template parameter.

Answer 6

There recently was a discussion about this kicked off in usenet: Why no VLAs in C++0x.

I agree with those people that seem to agree that having to create a potential large array on the stack, which usually has only little space available, isn't good. The argument is, if you know the size beforehand, you can aswell use a static array. And if you don't know the size beforehand, you will write unsafe code.

VLAs could provide a small benefit of being able to create small arrays without wasting space or calling constructors for not used elements, but they will introduce rather large changes to the type system (you need to be able to specify types depending on runtime values - this does not yet exist in current C++, except for new operator type-specifiers, but they are treated specially, so that the runtime-ness doesn't escape the scope of the new operator).

You can use std::vector, but it is not quite the same, as it uses dynamic memory, and making it use ones own stack-allocator isn't exactly easy (alignment is an issue, too). It also doesn't solve the same problem, because a vector is a resizable container, whereas VLAs are fixed-size. The C++ Dynamic Array proposal is intended to introduce a library based solution, as alternative to a language based VLA. However, it's not going to be part of C++0x, as far as i know.

Answer 7

You could always use alloca() to allocate memory on the stack at runtime, if you wished:

void foo (int n)
{
    int *values = (int *)alloca(sizeof(int) * n);
}

Being allocated on the stack implies that it will automatically be freed when the stack unwinds.

Quick note: As mentioned in the Mac OS X man page for alloca(3), "The alloca() function is machine and compiler dependent; its use is dis-couraged." Just so you know.