why can C++ "fill" initialize a variable-sized array?

Question

#include <iostream>
using namespace std;
void aa(int n) {
    int test[n] = {0};
}
int main() {
    aa(10);
    return 0;
}

and got

error: variable-sized object may not be initialized

but

#include <iostream>
using namespace std;
void aa(int n) {
    int test[n];
    fill(test,test+10,0);
}
int main() {
    aa(10);
    return 0;
}

is ok

I want to know the reason why this one got compiled while the former failed.

You might want to use [std::vector](https://en.cppreference.com/w/cpp/container/vector) and [resize](https://en.cppreference.com/w/cpp/container/vector/resize) instead. — nada, Nov 25 '19 at 07:08

score 8 · Accepted Answer · answered Nov 25 '19 at 07:12

VLA are not part of C++. They are supported by some compilers as an extension. They come from C99, and in C99 you cannot initialize VLA with = {0};. Some compilers (like GCC) go further and add support for such an initialization. In GCC this syntax can be used starting from version 4.9. Clang apparently doesn't support it, and it doesn't have to.

score 1 · Answer 2 · answered Nov 25 '19 at 07:02

1

You can declare an array only with constant size, which can be deduced at compile time. variable n can be known only at runtime.

To elaborate, when you allocate memory on the stack, the size must be known at compile time. Since the arrays are local to the method, they will be placed on the stack.

answered Nov 25 '19 at 07:02

Maddy

774
5
14

actually I'm curious why can't I allocate a variable-sized array on stack at runtime – jin zhenhui Nov 25 '19 at 07:15
The first line of my comment answers your question – Maddy Nov 25 '19 at 07:16
@jinzhenhui, this is an unfortunate limitation of C++ at the time. There are [proposals](http://www.open-std.org/JTC1/sc22/WG21/docs/papers/2013/n3662.html) to fix it. – Evg Nov 25 '19 at 07:18
1

thank you very much @Evg that's exactly the answer I want – jin zhenhui Nov 25 '19 at 07:20

nada · Answer 3 · 2019-11-25T07:30:37.080

1

Neither of your examples is legal since n is not compile time constant and standard C++ doesn't allow non-const length for array initialisation (C does however).

The reason why your second example compiles is, that you address the seemingly only problem your compiler has with your first example, i.e. it is not initialized.

I recommend compiling with all compiler warnings enabled, which probably should be default anyway. You can enable them in GCC for example with -Wall -Wextra and optionally -Werror. If you want your compiler to strictly stick to the standard, add -pedantic, too.

You might want to use std::vector and resize instead. If that is the case, your code would become

#include <vector>

void aa(int n) {
    // 1st parameter: number of elements, 2nd: value of elements.
    std::vector<int> test(n, 0); 
    // test.resize(n, 0); // is also possible
    // std::fill(test.begin(), test.end(), 0); // is also possible
}

int main() {
    aa(10);
    return 0;
}

edited Nov 25 '19 at 07:30

answered Nov 25 '19 at 07:13

nada

2,109
2
16
23

1

Enabling warnings will not do anything for the second example. You need the `-pedantic` or `-pedantic-errors` flag for Clang and GCC to give a diagnostic for the use of VLAs. – walnut Nov 25 '19 at 07:25
thanks, actually I'm just wondering is there any reason that makes allocating a variable-sized array on stack at runtime impossible. – jin zhenhui Nov 25 '19 at 07:33
@jinzhenhui https://stackoverflow.com/a/1887178/4850111 answers why VLAs aren't standard C++ – nada Nov 25 '19 at 07:35

why can C++ "fill" initialize a variable-sized array?

3 Answers3