zero initialization

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

C++ language

 

Initialization

Initializer

Default initialization

Value initialization

Direct initialization

Copy initialization

List initialization

Aggregate initialization

Reference initialization

Static initialization

Zero initialization

Constant initialization

Dynamic non-local initialization

Ordered dynamic initialization

Unordered dynamic initialization

Class member initialization

Member initializer list

in-class brace-or-equal initializer

 

Sets the initial value of an object to zero

Syntax

static T object ;	(1)
int () ;	(2)
char array [ n ] = "";	(3)

Explanation

Zero initialization is performed in the following situations:

1) For every named variable with static or thread-local storage duration that is not subject to constant initialization (since C++14), 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.

3) When a character array is initialized with a string literal that is too short, the remainder of the array is zero-initialized.

The effects of zero initialization are:

• If T is a scalar type, the object's initial value is the integral constant zero explicitly converted to T.

• If T is an non-union class type, all base classes and non-static data members are zero-initialized, and all padding is initialized to zero bits. The constructors, if any, are ignored.

• If T is a union type, the first non-static named data member is zero-initialized and all padding is initialized to zero bits.

• 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 variables that aren't constant-initialized (since C++14) 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

Run this code

#include <string>
 
double f[3]; // zero-initialized to three 0.0's
int* p;   // zero-initialized to null pointer value
std::string s; // zero-initialized to indeterminate value
               // then default-initialized to ""
int main(int argc, char* argv[])
{
    static int n = argc; // zero-initialized to 0
                         // then copy-initialized to argc
    delete p; // safe to delete a null pointer
}

Defect reports

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

DR	Applied to	Behavior as published	Correct behavior
CWG 2026	C++14	zero-init was specified to always occur first, even before constant-init	no zero-init if constant init applies

See also

• default initialization
• direct initialization
• value initialization
• copy initialization
• list initialization