C++ Variable expressions for defining array size?

Question

I'm a newb at C++ and I practice coding on my school computer, so I have to use an online compiler (www.CompileOnline.com). I have a variable that is defined by a function and is then used to initialize an array like so:

int var = function(a);

int num[var];

This code works just fine on the website, but on Visual Studio Express 2012 it gives me an error:

C2057: expected constant expression

Is this a problem with Visual Studio? I've read that it's a C++ rule, but then why does it work on the website? Any help is appreciated, thanks.

Answer 1

The feature that the code snippet requires is called variable length arrays (VLAs). Support for this feature in the C or C++ language depends on the compiler and the version of the standard.

• C99 supports VLAs as standard.
• Versions earlier than C99 (includes C90) do not support VLAs as standard, but some compilers may implement it as a language extension.
• C11 makes VLAs an optional feature.
• C++14 supports a restricted variant of VLAs called dynamic arrays.
• Versions earlier than C++14 (includes C++11, C++03, and C++98) do not support VLAs as standard, but some compilers may implement it as an extension.

In particular, GCC implements VLAs as a language extension for C90 and C++, and apparently www.compileonline.com uses GCC as the compiler (version 4.7.2 as of this writing). No version of the Visual C++ compiler implement VLAs.

Herb Sutter talks about C++14's dynamic array feature:

In the language, draft C++14 now allows stack-based arrays to have a size determined at run time:

void f(std::size_t n)
{
   int a[n];

   ...

}

Note that this is not the same as C99 variable length arrays (VLAs), and that the C11 standard has made VLAs conditionally-supported so that they are no longer part of portable C required in a conforming C compiler. In particular, C++ explicitly not does support the following features from C99 VLAs which C++ feels are not desirable:

• multidimensional arrays, where other than the top level has a runtime bound (in analogy, the array form of new expressions doesn’t support that either)
• modifications to the function declarator syntax
• sizeof(a) being a runtime-evaluated expression returning the size of a
• typedef int a[n]; evaluating n and passing that through the typedef

If you want C++ code that works in pretty much any version of C++, consider using std::vector instead:

#include <vector>

int main()
{
    int var = function(a); // Assume function() has been defined.
    std::vector<int> num(var); // Creates a vector with var number of elements.
    // ...
    int num1 = num[1]; // You can access elements in vectors just like arrays.
    num[1] += 10;
    // ...
}

Answer 2

Variable length arrays are not allowed in C++. The size of the array must be determinable at compile time.

CompileOnline.com says it uses GNU GCC version 4.7.2. GCC has an extension that supports variable length arrays in C++:

Variable-length automatic arrays are allowed in ISO C99, and as an extension GCC accepts them in C90 mode and in C++.

Answer 3

It seems the online compiler is gcc which implement variable length arrays as an extension in C++. The "problem" in this case is actually gcc, not VC++: gcc implement an extension which enables by default, tricking users into creating non-portable code.

If you need a variable sized array in C++, you'd include <vector> and use the class template declared in this header, e.g.:

int var = function(a);
std::vector<int> num(var);