Confusion over Omitting Outer Braces in Initializer Lists for Aggregates and POD Structures

In the realm of C programming, a common question arises regarding the use of braces in initializer lists. Specifically, programmers may encounter scenarios where outer braces appear to be required for certain aggregate types but not for others. This article aims to delve deeper into the topic and provide clarification on when outer braces can be omitted.

The Issue

When compiling the following code in Visual C 2010, an error message is generated:

struct A
{
    int foo;
    double bar;
};

std::array a1 = 
  // error C2078: too many initializers
  {
    {0, 0.1},
    {2, 3.4}
  };

// OK
std::array a2 = {0.1, 2.3};

The error indicates that there are too many initializers for a1, suggesting that the extra braces are required. However, omitting the outer braces for a2 does not result in an error. This discrepancy raises the question of why outer braces are needed for a1 but not for a2.

The Explanation

The key to understanding the reason behind this difference lies in the nature of std::array. std::array is classified as an aggregate and a Plain Old Datatype (POD), whereas other standard library containers are not. Unlike containers with user-defined constructors, std::array does not have one. Its first data member is an array of size N, specified as a template argument. This data member is directly initialized using an initializer list. The additional braces are necessary because they enclose the internal array that is being initialized.

To illustrate this concept further, consider a custom aggregate type Aarray, defined as follows:

// Custom aggregate with no user-defined constructor
struct Aarray
{
   A data[2];  // An internal array
};

Initializing this structure requires the use of braces to denote the start and end of the internal array being initialized:

Aarray a1 =
{
  {  // Begins initialization of the internal array

        { // Initializes the first element of the internal array

           0, 0.1

        }, // Ends initialization of the first element

       {2, 3.4}  // Initializes the second element of the internal array

  } // Ends initialization of the internal array
};

// ERROR: Too many initializers if not using braces
Aarray b1 =
{
   0, 0.1,
   2, 3.4
};

The Case of Double

In the case of std::array, the situation is different because double is not an aggregate type. Instead, std::array is considered an aggregate of primitives. The following code is valid without outer braces because the primitive values are directly initialized within the aggregate:

std::array a2 = {0.1, 2.3};

Clarification on Brace Usage

The C standard provides guidelines regarding the use of braces in initializer lists. Section §8.5.1/11 of the C 11 specification states that if the initializer-list begins with a left brace, then each subsequent comma-separated list of initializer-clauses initializes the members of a subaggregate. On the other hand, if the initializer-list for a subaggregate does not begin with a left brace, then only enough initializer-clauses will be taken to initialize the subaggregate members, with any remaining initializer-clauses initializing the next aggregate member.

Conclusion

The use of outer braces in initializer lists is crucial for aggregates and POD structures, such as std::array, because these types do not have user-defined constructors and the internal array is directly initialized. For primitive types, on the other hand, outer braces can be omitted as the primitive values are directly initialized within the aggregate. By understanding the difference between these cases, programmers can ensure correct initialization and avoid compiler errors.