Default-initialization

This is the initialization performed when an object is constructed with no initializer.

Syntax

Explanation

Default-initialization is performed in three situations:

The effects of default-initialization are:

• if T is a (possibly cv-qualified) non-POD(until C++11) class type, the constructors are considered and subjected to overload resolution against the empty argument list. The constructor selected (which is one of the default constructors) is called to provide the initial value for the new object;
• if T is an array type, every element of the array is default-initialized;

• otherwise, no initialization is performed (see notes).

Default-initialization of a const object

If a program calls for the default-initialization of an object of a const-qualified type T, T must be a const-default-constructible type.

A type T is const-default-constructible if

• Default-initialization of T would invoke a user-provided constructor of T (not inherited from a base class)(since C++11).
• T is a class type such that:

• T is an array of const-default-initializable type.

Indeterminate and erroneous values

Indeterminate and erroneous(since C++26) values of types std::byte, (since C++17)unsigned char, and char (if char is unsigned) can be propagated as follows:

• If an indeterminate or erroneous(since C++26) value of one of these types is produced by the evaluation of:

• the second or third operand of a conditional expression,
• the right operand of a comma expression,
• the operand of an implicit conversion or explicit conversion to one of these types,
• a discarded-value expression,

the result of the operation is an indeterminate value or the erroneous value, respectively(since C++26).

• If an indeterminate or erroneous(since C++26) value is assigned to an object of one of these types, the object acquires an indeterminate value or the erroneous value, respectively(since C++26).
• If an indeterminate or erroneous(since C++26) value is used to initialize an object of one of these types, the object acquires an indeterminate value or the erroneous value, respectively(since C++26).

Every other use of an indeterminate value is undefined behavior.

// Case 1: Uninitialized objects with dynamic storage duration
// All C++ versions: indeterminate value + undefined behavior
int f(bool b)
{
    unsigned char* c = new unsigned char;
    unsigned char d = *c; // OK, “d” has an indeterminate value
    int e = d;            // undefined behavior
    return b ? d : 0;     // undefined behavior if “b” is true
}

// Case 2: Uninitialized objects with automatic storage duration
// until C++26: indeterminate value + undefined behavior
// since C++26: erroneous value + erroneous behavior
int g(bool b)
{
    unsigned char c;     // “c” has an indeterminate/erroneous value
    
    unsigned char d = c; // no undefined/erroneous behavior,
                         // but “d” has an indeterminate/erroneous value
    
    assert(c == d);      // until C++26: undefined behavior
                         // since C++26: holds, but both integral promotions have
                         // erroneous behavior
    
    int e = d;           // undefined/erroneous behavior
    return b ? d : 0;    // undefined/erroneous behavior if “b” is true
}

// Same as case 2
void h()
{
    int d1, d2;  // “d1” and “d2” have indeterminate/erroneous values
    int e1 = d1; // undefined/erroneous behavior
    int e2 = d1; // undefined/erroneous behavior
    
    assert(e1 == e2); // holds since C++26
    assert(e1 == d1); // holds since C++26, undefined/erroneous behavior
    assert(e2 == d1); // holds since C++26, undefined/erroneous behavior
    
    // no undefined/erroneous behavior,
    // but “d2” has an indeterminate/erroneous value
    std::memcpy(&d2, &d1, sizeof(int));
    
    assert(e1 == d2); // holds since C++26, undefined/erroneous behavior
    assert(e2 == d2); // holds since C++26, undefined/erroneous behavior
}

Notes

References and const scalar objects cannot be default-initialized.

Example

#include <string>

struct T1 { int mem; };

struct T2
{
    int mem;
    T2() {} // “mem” is not in the initializer list
};

int n; // static non-class, a two-phase initialization is done:
       // 1) zero-initialization initializes n to zero
       // 2) default-initialization does nothing, leaving n being zero

int main()
{
    [[maybe_unused]]
    int n;            // non-class, the value is indeterminate
    std::string s;    // class, calls default constructor, the value is ""
    std::string a[2]; // array, default-initializes the elements, the value is {"", ""}
//  int& r;           // Error: a reference
//  const int n;      // Error: a const non-class
//  const T1 t1;      // Error: const class with implicit default constructor
    [[maybe_unused]]
    T1 t1;            // class, calls implicit default constructor
    const T2 t2;      // const class, calls the user-provided default constructor
                      // t2.mem is default-initialized
}

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

See also

• converting constructor
• default constructor
• explicit
• initialization
  • aggregate initialization
  • constant initialization
  • copy-initialization
  • direct-initialization
  • list-initialization
  • reference initialization
  • value-initialization
  • zero-initialization
• new