This is the initialization performed when a variable is constructed with no initializer.
Syntax
T object ; | (1) | |
new T ;
| (2) |
Explanation
Default initialization is performed in three situations:
The effects of default initialization are:
- If
T
is a 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, nothing is done: the objects with automatic storage duration (and their subobjects) are initialized to indeterminate values.
Only (possibly cv-qualified) non-POD class types (or arrays thereof) with automatic storage duration were considered to be default-initialized when no initializer is used. Scalars and POD types with dynamic storage duration were considered to be not initialized (since C++11, this situation was reclassified as a form of default initialization). | (until C++11) |
Prior to C++03 (which introduced value initialization), the expression | (until C++03) |
If | (until C++11) |
Use of an indeterminate value obtained by default-initializing a non-class variable of any type is undefined behavior, except in the following cases:
int f(bool b) { int x; // value of x is indeterminate int y = x; // undefined behavior unsigned char c; // value of c is indeterminate unsigned char d = c; // OK, value of d is indeterminate int e = d; // undefined behavior return b ? d : 0; // undefined behavior if b is true } | (since C++14) |
Notes
Default initialization of non-class variables with automatic and dynamic storage duration produces objects with indeterminate values (static and thread-local objects get zero initialized).
If T
is a const-qualified type, it must be a class type with a user-provided default constructor.
Reference cannot be default-initialized.
Example
#include <string> struct T1 {}; class T2 { int mem; public: T2() {} // "mem" not in initializer list }; int n; // A two-phase initialization is done // In the first phase, zero initialization initializes n to zero // In the second phase, default initialization does nothing, leaving n being zero int main() { int n; // non-class: the value is indeterminate std::string s; // calls default ctor, the value is "" (empty string) std::string a[2]; // calls default ctor, creates two empty strings // int& r; // error: default-initializing a reference // const int n; // error: const non-class type // const T1 t1; // error: const class type with implicit default ctor T1 t1; // ok, calls implicit default ctor const T2 t2; // ok, calls the user-provided default ctor // t2.mem is default-initialized (to indeterminate value) }
Please login to continue.