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 shall be a const-default-constructible class type or array thereof.

A class 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) or if

each potentially constructed base class of T is const-default-constructible.

Indeterminate and erroneous values

If an evaluation produces an indeterminate value, the behavior is undefined .

Special cases

The following types are uninitialized-friendly :

• unsigned char
• char , if its underlying type is unsigned char

Given an indeterminate or erroneous (since C++26) value value , the uninitialized result value of value is:

• An indeterminate value, if value is also an indeterminate value.

If an evaluation eval produces an indeterminate or erroneous (since C++26) value value of an uninitialized-friendly type, the behavior is well-defined in the following cases:

• eval is the evaluation of one of the following expressions and operands:

• The second or third operand of a conditional expression .
• The right operand of a comma expression .
• The operand of an integral conversion , explicit cast or static_cast to an uninitialized-friendly type.
• A discarded-value expression .

In this case, the result of the operation is the uninitialized result value of value .

• eval is an evaluation of the right operand of a simple assignment operator whose left operand is an lvalue of an uninitialized-friendly type.

In this case, the value of the object referred to by the left operand is replaced by the uninitialized result value of value .

• eval is the evaluation of the initialization expression when initializing an object of an uninitialized-friendly type.

In this case, that object is initialized to the uninitialized result value of value .

Converting an indeterminate value of an uninitialized-friendly type produces an indeterminate value.

// 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);      // holds, but both integral promotions have
                         // undefined/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
    assert(e1 == d1); // holds, undefined/erroneous behavior
    assert(e2 == d1); // holds, undefined/erroneous behavior
    // no undefined/erroneous behavior,
    // but “d2” has an indeterminate/erroneous value
    std::memcpy(&d2, &d1, sizeof(int));
    assert(e1 == d2); // holds, undefined/erroneous behavior
    assert(e2 == d2); // holds, 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