Sets the initial value of an object to zero.

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.

Explanation

Zero-initialization is performed in the following situations:

1) 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.

2) 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.

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.

Example

#include <iostream>
#include <string>

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";
}

Defect reports

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

See also

• constructor
• copy assignment
• default constructor
• initialization
  • aggregate initialization
  • constant initialization
  • copy initialization
  • default initialization
  • direct initialization
  • list initialization
  • value initialization
• move assignment
• new