default initialization
This is the initialization performed when a variable is constructed with no initializer.
Contents |
[edit] Syntax
T object ;
|
(1) | ||||||||
new T ;
|
(2) | ||||||||
[edit] 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 default constructor 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 new T() as well as a member initializer naming a base or a member with the initializer in the form of an empty pair of parentheses was classified as default initialization, but specified zero initialization for non-class types. |
(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) |
[edit] 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.
[edit] 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 undeterminate 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 nd; // error: const class type with implicit 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) }