< c‎ | language

A declaraton of an object may provide its initial value through the process known as initialization.

For each declarator, the initializer, if not omitted, may be one of the following:

= expression (1)
= { initializer-list } (2)

where initializer-list is a non-empty comma-separated list of initializers (with an optional trailing comma), where each initializer has one of three possible forms:

expression (1)
{ initializer-list } (2)
designator-list = initializer (3)

where designator-list is a list of either array designators of the form [ constant-expression ] or struct/union member designators of the form . identifier; see array initialization and struct initialization.


[edit] Explanation

The initializer specifies the initial value stored in an object.

[edit] Explicit initialization

If an initializer is provided, see

[edit] Implicit initialization

If an initializer is not provided:

  • pointers are initialized to null pointer values of their types
  • objects of integral types are initialized to unsigned zero
  • objects of floating types are initialized to positive zero
  • members of arrays, structs, and unions are initialized as described above, recursively, plus all padding bits are initialized to zero
(on platforms where null pointers and floating zeroes have all-bit-zero representations, this form of initialization for statics is normally implemented by allocating them in the .bss section of the program image)

[edit] Notes

When initializing an object of static or thread-local storage duration, every expression in the initializer must be a constant expression or string literal.

Initializers cannot be used in declarations of objects of incomplete type, VLAs, and block-scope objects with linkage.

The initial values of function parameters are established as if by assignment from the arguments of a function call, rather than by initialization (until the post-C11 defect report DR 427, which changes the wording to use initialization).

[edit] Example

#include <stdlib.h>
int a[2]; // initializes a to {0, 0}
int main(void)
    int i;          // initializes i to an indeterminate value
    static int j;   // initializes j to 0
    int k = 1;      // initializes k to 1
    // initializes int x[3] to 1,3,5
    // initializes int* p to &x[0]
    int x[] = { 1, 3, 5 }, *p = x;
    // initializes w (an array of two structs) to
    // { { {1,0,0}, 0}, { {2,0,0}, 0} }
    struct {int a[3], b;} w[] = {[0].a = {1}, [1].a[0] = 2};
    // function call expression can be used for a local variable
    char* ptr = malloc(10);
//  Error: objects with static storage duration require constant initializers
//  static char* ptr = malloc(10);
//  Error: VLA cannot be initialized
//  int vla[n] = {0};

[edit] References

  • C11 standard (ISO/IEC 9899:2011):
  • 6.7.9 Initialization (p: 139-144)
  • C99 standard (ISO/IEC 9899:1999):
  • 6.7.8 Initialization (p: 125-130)
  • C89/C90 standard (ISO/IEC 9899:1990):
  • 3.5.7 Initialization

[edit] See also

C++ documentation for Initialization