Zero-initialization - cppreference.com (original) (raw)

Sets the initial value of an object to zero.

[edit] Syntax

Note that this is not the syntax for zero-initialization, which does not have a dedicated syntax in the language. These are examples of other types of initializations, which might perform zero-initialization.

| | | | | ------------------------------------------------------------------- | --- | | | static T object ; | (1) | | | | | | | T () ; T t = {} ; T {} ; (since C++11) | (2) | | | | | | | CharT array [ n ] = " short-sequence "; | (3) | | | | | |

[edit] Explanation

Zero-initialization is performed in the following situations:

For every named variable with static or thread-local(since C++11) storage duration that is not subject to constant initialization, before any other initialization.
As part of value-initialization sequence for non-class types and for members of value-initialized class types that have no constructors, including value initialization of elements of aggregates for which no initializers are provided.

The effects of zero-initialization are:

If T is a scalar type, the object is initialized to the value obtained by explicitly converting the integer literal 0 (zero) to T.
If T is a non-union class type:
all padding bits are initialized to zero bits,
each non-static data member is zero-initialized,
each non-virtual base class subobject is zero-initialized, and
if the object is not a base class subobject, each virtual base class subobject is zero-initialized.
If T is a union type:
all padding bits are initialized to zero bits, and
the object’s first non-static named data member is zero-initialized.
If T is array type, each element is zero-initialized.
If T is reference type, nothing is done.

[edit] Notes

As described in non-local initialization, static and thread-local(since C++11) variables that aren't constant-initialized are zero-initialized before any other initialization takes place. If the definition of a non-class non-local variable has no initializer, then default initialization does nothing, leaving the result of the earlier zero-initialization unmodified.

A zero-initialized pointer is the null pointer value of its type, even if the value of the null pointer is not integral zero.

[edit] Example

#include #include struct A { int a, b, c; }; double f[3]; // zero-initialized to three 0.0's int* p; // zero-initialized to null pointer value // (even if the value is not integral 0) std::string s; // zero-initialized to indeterminate value, then // default-initialized to "" by the std::string default constructor int main(int argc, char*[]) { delete p; // safe to delete a null pointer static int n = argc; // zero-initialized to 0 then copy-initialized to argc std::cout << "n = " << n << '\n'; A a = A(); // the effect is same as: A a{}; or A a = {}; std::cout << "a = {" << a.a << ' ' << a.b << ' ' << a.c << "}\n"; }

Possible output:

[edit] Defect reports

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