4.2 Initialization

Initializers provide an initial value for objects, and follow this syntax:

initializer:

   expression
   { initializer-list }
   { initializer-list, }

initializer-list:

   initializer
   initializer-list, initializer

Initialization of objects of each type is discussed in the following sections, but a few universal constraints apply to all initializations in C:

• The number of initializers cannot exceed the number of objects to be initialized. Initializers can number less than the number of objects to be initialized, in which case the remaining objects are initialized to zero.

• Constant expressions must be used in an initializer for an object that has static storage duration, or in an initializer list for an object that has an aggregate or union type.

• If an identifier's declaration has block scope, and the identifier has external or internal linkage, the declaration of the identifier cannot include an initializer.

• If an object that has static storage duration is not explicitly initialized, it is initialized implicitly as if every member with an arithmetic type were assigned 0, and every member with a pointer type were assigned a null pointer constant. If an object that has automatic storage duration is not initialized explicitly, its value is indeterminate.

• The initializer for a scalar object must be a single expression, optionally enclosed in braces. The initial value of the object is that of the expression. The same type constraints and conversions apply as for simple assignment.

• If an aggregate object contains members that are aggregates or unions, or if the first member of a union is an aggregate or union, the initialization rules apply recursively to the aggregate members or contained unions. If an initializer list is used for an aggregate member or contained union, the initializers in that list initialize the members of the aggregate member or contained union. Otherwise, only enough initializers from the list are used to account for the object; any remaining members in the list are left to initialize the next member of the aggregate object. For example:

  struct t1 {
   int i;
   double d;
  };
  
  union t2 {
   int i;
   double d;
  };
  
  struct t3 {
   struct t1 s;
   union t2 u;
  };
  
  struct t3 st[] = { /* complete initializer */
   1, 2, 0, 4, 0, 0, 7, 0, 0
  };
  

  Given the previous declarations, the variable st is an array of 3 structures. Its initial contents are:

              s      u
           ------    -
  st[0]:   1, 2.0,   0
  st[1]:   4, 0.0,   0
  st[2]:   7, 0.0,   0
  

  This variable can also be defined in the following ways-all four initializers are equivalent:

  struct t3 st[] = { /* partial initializer */
   1, 2, 0, 4, 0, 0, 7
  };
  
  struct t3 st[] = { /* nested and complete initializers */
   {1, 2, 0},
   {4, 0, 0},
   {7, 0, 0}
  };
  
  struct t3 st[] = { /* nested and partial initializers */
   {1, 2},
   {4},
   {7}
  };
  

• Variant structures and unions are initialized just like normal structures and unions. See Section 4.8.4 and Section 4.8.5 for more information.

C has historically allowed initializers to be optionally surrounded by extra braces (to improve formatting clarity, for instance). These initializers are parsed differently depending on the type of parser used. DEC C uses the parsing technique specified by the ANSI standard, known as the top-down parse. Programs depending on a bottom-up parse of partially braced initializers can yield unexpected results. The compiler generates a warning message when it encounters unnecessary braces in common C compatibility mode or when the error-checking compiler option is specified on the command line.