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

[edit]Syntax

[edit]Explanation

Default-initialization is performed in three situations:

The effects of default-initialization are:

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

[edit]Default-initialization of a const object

If a program calls for the default-initialization of an object of aconst-qualified typeT, T shall be aconst-default-constructible class type or array thereof.

A class typeT is const-default-constructible if default-initialization ofT would invoke a user-provided constructor ofT(not inherited from a base class)(since C++11) or if

eachpotentially constructed base class ofT is const-default-constructible.

[edit]Indeterminate and erroneous values

If an evaluation produces an indeterminate value, the behavior isundefined.

[edit]Special cases

The following types areuninitialized-friendly:

• unsignedchar
• char, if its underlying type isunsignedchar

Given an indeterminate or erroneous(since C++26) valuevalue, theuninitialized result value ofvalue is:

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

If an evaluationeval produces an indeterminate or erroneous(since C++26) valuevalue 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 aconditional expression.
• The right operand of acomma expression.
• The operand of anintegral conversion,explicit cast orstatic_cast to an uninitialized-friendly type.
• Adiscarded-value expression.

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

• eval is an evaluation of the right operand of asimple 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 ofvalue.

• 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 ofvalue.

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 behaviorint f(bool b){unsignedchar* c= newunsignedchar;unsignedchar d=*c;// OK, “d” has an indeterminate valueint e= d;// undefined behaviorreturn 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 behaviorint g(bool b){unsignedchar c;// “c” has an indeterminate/erroneous value unsignedchar 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 behaviorreturn b? d:0;// undefined/erroneous behavior if “b” is true} // Same as case 2void h(){int d1, d2;// “d1” and “d2” have indeterminate/erroneous valuesint e1= d1;// undefined/erroneous behaviorint e2= d1;// undefined/erroneous behavior assert(e1== e2);// holdsassert(e1== d1);// holds, undefined/erroneous behaviorassert(e2== d1);// holds, undefined/erroneous behavior // no undefined/erroneous behavior,// but “d2” has an indeterminate/erroneous valuestd::memcpy(&d2,&d1, sizeof(int)); assert(e1== d2);// holds, undefined/erroneous behaviorassert(e2== d2);// holds, undefined/erroneous behavior}

[edit]Notes

References and const scalar objects cannot be default-initialized.

[edit]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 indeterminatestd::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 constructorconst T2 t2;// const class, calls the user-provided default constructor// t2.mem is default-initialized}

[edit]Defect reports

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

[edit]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

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文