I got this piece of code:


Code:


There's supposed to be something dubious about it and I'm supposed to find out what, but the compiler doesn't give me any error and the program works just fine.
Yet I looked up the solution and it says that the dimension of an array must be a constant or a constant expression.

My doubt is, why's that when using a variable works just fine?

Hmm, my guess is the compiler is optimizing away the variable in that case. Try it where the user enters in the size and declare it the same way.

Can you be more specific?

Depending on your compiler and the standard it purports to accept, this may be allowed. C99 permits variable-length arrays, and I'd imagine newer revisions of C++ also permit it.

What compiler are you using, and what options are you passing to it? GCC's default gnu89 dialect might allow this; ANSI C definitely doesn't.

My compiler is C-Free Standard

Looks more like that's your IDE, which appears to ship with MinGW GCC. Still can't tell what options you're using though.

...

Look I don't know that much about programming... I have no idea what an IDE or an MinGW GCC might be.

So, my guess is, it works though some compilers don't support it, it that it?

More or less, yeah. The more canonical way to do it, which I'm sure you'll learn later in your book, is with malloc.

Alright, thanks for the help guys

That's not true at all. Most compilers do support it. The array is simply allocated on the stack. Like:


X86

Code:

Wouldn't most compilers supporting it mean that some don't support it? Meaning it is true at all?

Very few compilers don't support. Unless you're using some compiler you found off of a shady website instead of something like GCC, MSVC, TCC, LCC, etc, you have nothing to worry about.

Variable length arrays were added in C99. That's 1999, 15 years ago.

And therefore some number of compilers don't support it. So what I said isn't wrong.

When I said "very few" I meant private compilers. Things like what university students work on as a project might not support it.

Any publicly used compiler does.

Counterpoint: MSVC doesn't support C99.

That's bull. MSVC was actually the first to implement several of C99's features, and was the first to write a safe standard C library that prevents things like buffer overflows.

When it comes to standard C library implementation, MSVC is way ahead of anything else.

Transcribed from IRC/SAX.

Code:

I was wrong. Found this

https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html#Variable-Length

While VLA's are allowed in the C99 standard, they are not enforced by it. According to this page, Microsoft added support for the C99 runtime library in 2013. However, according to the roadmap, Microsoft is not actually going to implement the full C99 standard. Like...ever.

I'm guessing this stems somewhat from the fact that there are incompatibilities between C and C++ standards. MSVC was designed specifically for C++. The fact that it has C89/C90 compliance is more or less a perk.