Why & How C++ allows compile time arrays to be created using dynamic values

Question

While writing some code, I realised one of my code works which as per my understanding shouldn't be working. The code is

int main() {
    int val;
    cin>>val;
    int array[val];
}

No only this, even the code below is also working

 int main() {
        int valone = rand();
        int valtwo = rand();
        int array[valone][valtwo];
    }

I always had the understand that static arrays needs constant values, or the values which could be deduced by compilers during compile time.

Is there any change in recent C++11/14 specification or this was true for C++ since beginning.

NOTE: Visual Studio Compiler does gives an error in this case, but g++ as well as clang successfully compiles above code

Answer 1

It's a variable-length array.

These are supported by C99, and both GCC and Clang support them in C++ as a non-standard extension. (They are not part of the C++ language.) MSVC does not support C99, and therefore does not support them at all.

In standard C++, you would use std::vector instead.

Answer 2

This is a compiler extension called Variable-Length Arrays. This is not standard C++ as you said and thus should not be relied on when trying to write cross-compiler compliant code. Instead, you can use std::vector for "dynamic arrays", this is standard.

Answer 3

There are some compilers that allow variable-length arrays as an extension of the language. Don't rely on it if you want portable code, use std::vector instead.

Answer 4

Variable length arrays are not standard in c++. Some compilers support it, but as non-standard extensions.

For example, see thee gcc documentation for this extension here.

Answer 5

VLA's are a very useful construct. They allow one to create an array of a size known at compile time, yet use automatic memory and not rely on dynamic memory management as vectors do.

There may be several reasons to avoid dynamic allocations, among most important would be performance penalty incurred by it (especially in multithreading scenarios) and simple lack of dynamic memory control on some MCUs.