Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://en.cppreference.com/w/cpp/language/../io/../language/zero_initialization.html below:

Zero-initialization - cppreference.com

Sets the initial value of an object to zero.

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.

T t = {} ;

T {} ; (since C++11)

Zero-initialization is performed in the following situations:

As part of

sequence for non-class types and for members of value-initialized class types that have no constructors, including value initialization of elements of

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.

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.

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

Possible output:

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

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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4