Initializing an array with an initializer list

Many learners arrive at arrays with a comfortable mental model. A variable holds a value, and that value can be supplied at runtime, computed from other values, or passed in as a parameter. It seems reasonable to assume the same flexibility applies to the number of slots in an array. If a program needs room for n items, why shouldn't the array simply be declared with n?

This belief is the misconception this article corrects. In C++, the element count of an array is part of its declaration, and it cannot be an arbitrary runtime value. The rule is strict, and the compiler enforces it before the program ever runs. Before reading the rule, try a prediction.

The element count of an array is not optional, so a declaration must state its size. The size is written inside the brackets, as in int a[5]. The initializer list that follows the equals sign supplies values, but it does not supply the size. The list fills the slots that the size has already defined. It cannot define the size on its own. Providing values is not the same as providing a size.

A literal number such as 5 is a constant expression, because its value is fixed in the source code itself. A variable parameter such as n does not meet this requirement, because its value is only known once the function is called. This is the whole rule. Only the form of the size expression decides whether the declaration is accepted.

Consider two declarations that differ only in how the size is written. The first uses a parameter n, and the compiler rejects it. The second uses a literal 5, which is a constant expression, and the compiler accepts it. The diagram below traces the decision the compiler makes for any size expression.

Once the size is fixed, the initializer list fills positions from the start of the array. Take int a[5] = {1, 2};. The size defines five slots, indexed 0 through 4. The list supplies two values, so they go to the first two positions. The remaining positions are not left without values: in C++ they are value-initialized, which for an int means they are set to zero.

Read the diagram from left to right. The values in the list are matched to positions in order, so the list never decides where the array begins or how long it is. The declared size decides both. If the list had supplied more values than the size allows, the declaration would not describe the array the programmer intended, so the size and the list must agree.

A declaration with an initializer list has four visible parts. The type names what each element is. The name identifies the array. The bracketed size gives the element count, and it must be a constant expression. The initializer list after the equals sign supplies the initial values. The diagram below labels each part of int a[3] = {1, 2, 3};.

The bracketed part is the one this article focuses on. When you read a declaration, look there first. If the bracket holds a literal number, or another expression whose value is fixed at compile time, the element count is settled. If the bracket holds a function parameter or another value that is only known while the program runs, the declaration is not valid for a fixed-size array.

The source gives the decision rule directly: when the element count needs to be a variable, use vector instead of array. The table below compares the two choices across the situations a learner is likely to meet. A fixed-size array fits problems where the count is known as a constant. A vector fits problems where the count can only be known while the program runs.