Does C++ Support Variable Length Arrays

Why aren't variable-length arrays part of the C++ standard?

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 use a static array. And if you don't know the size beforehand, you will write unsafe code.

C99 VLAs could provide a small benefit of being able to create small arrays without wasting space or calling constructors for unused 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 one's 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.

Are variable length arrays there in c++?

The current C++ standard does not require that compilers support VLAs. However, compiler vendors are permitted to support VLAs as an extension. GCC >= 4.7, for example, does.

It was originally proposed that VLAs would appear in C++14, however the proposal did not succeed. They also, ultimately, did not appear in C++17.

Check support for variable length array in C

From the C11 specification §6.10.8.3

The following macro names are conditionally defined by the
implementation:

[...]

__STDC_NO_VLA__ The integer constant 1, intended to indicate that the implementation does not support variable length arrays or variably
modified types.

So if __STDC_VERSION__ > 201000L you need to check __STDC_NO_VLA__.

Otherwise, if __STDC_VERSION__ >= 199901L VLAs should work, but you'll get a compile time error if the compiler is non-compliant.

what happens if you create a variable length array and compile using g++

GCC documents its support of VLAs here (emphasis mine)

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

CLANG documentation too follows suit but mentions clearly that the standard doesn't accept (emphasis mine)

GCC and C99 allow an array's size to be determined at run time. This
extension is not permitted in standard C++. However, Clang supports
such variable length arrays for compatibility with GNU C and C99
programs.

If you would prefer not to use this extension, you can always disable it with
-Werror=vla to disallow compilation.

Variable Length array forbidden in ISO C++ error in sublime text 3

Replace the VLA with a std::vector:

#include <iostream>
#include <vector>

int main()
{
    int n;
    std::cin>>n;
    std::vector<int> a(n);  // was VLA: int a[n];
    for(int i=0;i<n;i++)
        std::cin>>a[i];
    for(int i=0;i<n;i++)
        std::cout<<a[i]<<" ";
}

Variable length arrays not possible w CLion and C99 Standard?

CLion is using MS Visual Studio 2019 as the underlying compiler. MSVC is not a fully compliant C compiler, and in particular it does not support variable length arrays.

You would have to use gcc or clang to get support for VLAs.

Does C++11 support variable sized arrays?

That is non standard C++. Some compilers accept it, but if you want to be portable you should stick with standard C++.