Why can't I initialize a variable-sized array?

GCC gives no error when you initialize a variable-sized array as long as the variable is const, but when it isn't, it won't compile.

What's the r开发者_StackOverflow中文版eason behind this? What's so wrong with doing:

int size = 7;
int test[size] = {3, 4, 5};

That won't compile at all, but if I don't initialize test[] then it does compile! That doesn't make any sense to me, because as far as I know a stack frame needs to be made to fit this array according to its size(7 ints) no matter what(which means the integer literals I use don't really have any meaning, if I'm not mistaken), so what difference does it make if I initialize it or not?

Just another one of my crazy C++ design questions...

Thanks!

• The size of the array must be a constant integral expression.
• An integral literal is a constant integral expression. (int arr[5];)

• A constant integral variable initialized with a constant expression is a constant expression. (const int j = 4; const int i = j; int a[i];)

• A constant variable initialized with a non-constant expression is not a constant expression

   int x = 4;  // x isn't constant expression because it is not const
   const int y = x; //therefore y is not either
   int arr[y]; //error)
  

It's actually more like a crazy C99 design question, since variable-length arrays are a feature from C99 that gcc allows in C++ as an extension.

In C99, 6.7.8/3 says "The type of the entity to be initialized ... is not a variable length array type", so gcc has just used the same rule for its extension as is required by C99.

The C99 rationale document doesn't say anything about why a VLA can't be initialized. I can speculate that it might be because of the risk of excess elements in the initializer, if the value provided for the size turns out to be smaller than the initializer. But I don't know.

Some compilers allow this if you use const int size = 7;. Theoretically the compiler could figure out that it's constant size but it doesn't do that.

From http://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html "Variable-length automatic arrays are allowed in ISO C99, and as an extension GCC accepts them in C90 mode and in C++. "

Your program is not valid in c++ at all and gcc compiles it as "an extension". You'd likely have to ask the authors of gcc why they decided to implement in this way.

The code is not valid in standard C++.

As per (8.3.4.1) of the C++ standard, array size must be a constant expression

Variable lenght arrays are not allowed in C++ because C++ provides std::vector for that.

Variable length array was a feature introduced in C99 after C++ branched out from C standard based on c98. C++ already had std::vector to provide functionality of variable lenght arrays so C++ standard never allowed variable length arrays as a part of the standard.

If your compiler supports it, it is through a compiler extension. Compile with -pedantic option and it will notify you of the same with the warning saying it's forbidden by ISO C++

I'm not sure about the intentions of gcc designers when they implemented this extension, but one possible reason why the gcc extension works like this is:

int is1[2] = {1}

compiles without warning, reasonable to assume user wants {1,0}

int is2[1] = {1,2};

compiles with a warning, what should the compiler do?

int i;
cin >> i;
int is3[i] = {1,2}

aha, to warn or not to warn?