8

In C++ I tried declaring a global array of some size. I got the error:

array bound is not an integer constant before ‘]’ token

But when I declared an array of the same type in the main() function it is working fine.

Why is there different behaviour here?

int y=5;
int arr[y];         //When I comment this line it works fine

int main()
{
    int x=5;
    int arr2[x];        // This line doesn't show any error.
}

Edit: Many are suggesting this question is a duplicate of Getting error "array bound is not an integer constant before ']' token". But that question doesn't answer why there is different behaviour.

Deduplicator
  • 44,692
  • 7
  • 66
  • 118
Syed Maqthyar
  • 93
  • 7
  • 3
    Even in `main`, it is not legal, it uses VLA extension. – Jarod42 Mar 10 '20 at 15:27
  • 4
    Bounds of **all** arrays, in C++, need to have a value, that is known during compilation. If such code, when placed in `main` is "accepted" by your compiler: you are using the compiler extension, that allows VLAs to compile, even if they are not supported by C++ standard. – Algirdas Preidžius Mar 10 '20 at 15:28
  • 2
    dont confuse "no compiler errors" with "is working fine". In this case "working fine" means that your code relies on a non-standard compiler provided extension, ie it is ok-ish but it isnt portable c++ – 463035818_is_not_an_ai Mar 10 '20 at 15:30
  • Why not declare `y` and `x` as `const`? Do you need to modify the value of `y` or `x`? Hopefully not, because that raises many questions about how big `arr` and `arr2` should be -- especially with repsect to initialization order. (Hint: they should be constants) – Wyck Mar 10 '20 at 15:30
  • Compile your program with `--std=c++17` (or `--std=c++11` if it's an older compiler), and compilation will fail. – einpoklum Mar 10 '20 at 15:32
  • `// This line doesn't show any error` -- Yes it does. (https://rextester.com/NXZDT64108) – PaulMcKenzie Mar 10 '20 at 15:38

4 Answers4

10

Both examples are ill-formed in C++. If a compiler does not diagnose the latter, then it does not conform to the standard.

Why there is a different behaviour here?

You use a language extension that allows runtime length automatic arrays. But does not allow runtime length static arrays. Global arrays have static storage.

In case you are using GCC, you can ask it to conform to the standard by using the -pedantic command line option. It is a good idea to do so in order to be informed about portability problems.

eerorika
  • 232,697
  • 12
  • 197
  • 326
4

The size of an array must be a constant. You can fix this by declaring y as const.

const int y=5;
int arr[y];

As for why this worked in main, g++ does allow a variable length array in block scope as an extension. It is not standard C++ however.

dbush
  • 205,898
  • 23
  • 218
  • 273
0

Both shouldn't be used, one works because (as @eerorika said) automatic length arrays are allowed on runtime, but global arrays need to have static storage.

If you want to declare an array with a variable size (e.g. given by std::cin) you would do something along the lines of:

int x;
std::cin >> x;
const int n = x;
float arr[n];

But you wouldn't be able to set it to contain just zeros with float arr[n] = {0} (if you need to add to a value in the array, not being sure you set it), you would need to use a loop like that

for(int i = 0; i < n; i++)
{
    arr[i] = 0;
}
Misty
  • 416
  • 3
  • 8
  • 1
    Your example is still ill formed despite using const. The size must be a compile time constant expression. Something that you get from runtime input of course does not satisfy that. – eerorika Mar 10 '20 at 16:14
  • The statement that “Both shouldn’t be used” is inappropriate. One might wish to avoid using a variable-length array to write portable C++ code. One might wish to use a variable-length array to achieve a desired project goal at the expense of portability. The values of these goals are subjective and circumstantial, and you cannot say where the balance lies for another person. – Eric Postpischil Mar 10 '20 at 20:25
  • @EricPostpischil You're right but when you use a mutable variable, you can change it and for safety reasons it's better to keep it as a const – Misty Mar 10 '20 at 21:30
0

The type-system of C++ handles these C-like arrays in a way that it defines arr2 from your example of type int[5]. So, yes the number of elements of the array is part of the type!

This puts some constraints on what you are allowed to use in the definition of C-like arrays. I.e. this number needs to have static storage, needs to be immutable and needs to be available at compile time.

So, you might want to change your code to something like the following, which will have another goodie. It initializes the array in a proper way:

int arr2[] = {0, 0, 0, 0, 0};
salchint
  • 371
  • 3
  • 10