Value-initialization

Esta es la inicialización realizada cuando un objeto se construye con un inicializador vacío.

Sintaxis

Explicación

La inicialización por valor se realiza en estas situaciones:

En todos los casos, si se utiliza el par de llaves vacío {} y T es un tipo agregado, aggregate initialization se realiza en lugar de value-initialization.

Los efectos de la inicialización por valor son:

• Si T es un tipo clase (posiblemente calificado con cv):

• Si la inicialización por defecto para T selecciona un constructor , y el constructor no es declarado por el usuario (hasta C++11) proporcionado por el usuario (desde C++11) , el objeto es primero zero-initialized .
• En cualquier caso, el objeto es default-initialized .

• De lo contrario, si T es un tipo de arreglo, cada elemento del arreglo es inicializado por valor.
• De lo contrario, el objeto es inicializado a cero.

Notas

La sintaxis T object ( ) ; no inicializa un objeto; declara una función que no toma argumentos y retorna T . La forma de inicializar por valor una variable nombrada antes de C++11 era T object = T ( ) ; , que inicializa por valor un temporal y luego inicializa por copia el objeto: la mayoría de compiladores optimizan la copia en este caso.

Las referencias no pueden ser inicializadas por valor.

Como se describe en function-style cast , la sintaxis T ( ) (1) está prohibida si T nombra un array type, mientras que T { } (5) está permitida.

Todos los contenedores estándar ( std::vector , std::list , etc.) inicializan por valor sus elementos cuando se construyen con un único argumento size_type o cuando se expanden mediante una llamada a resize ( ) , a menos que su asignador personalice el comportamiento de construct .

Ejemplo

#include <cassert>
#include <iostream>
#include <string>
#include <vector>
struct T1
{
    int mem1;
    std::string mem2;
    virtual void foo() {} // asegura que T1 no sea un agregado
}; // constructor por defecto implícito
struct T2
{
    int mem1;
    std::string mem2;
    T2(const T2&) {} // constructor de copia proporcionado por el usuario
};                   // sin constructor por defecto
struct T3
{
    int mem1;
    std::string mem2;
    T3() {} // constructor por defecto proporcionado por el usuario
};
std::string s{}; // clase => inicialización por defecto, el valor es ""
int main()
{
    int n{};                // escalar => inicialización a cero, el valor es 0
    assert(n == 0);
    double f = double();    // escalar => inicialización a cero, el valor es 0.0
    assert(f == 0.0);
    int* a = new int[10](); // array => inicialización por valor de cada elemento
    assert(a[9] == 0);      //          el valor de cada elemento es 0
    T1 t1{};                // clase con constructor por defecto implícito =>
    assert(t1.mem1 == 0);   //     t1.mem1 es inicializado a cero, el valor es 0
    assert(t1.mem2 == "");  //     t1.mem2 es inicializado por defecto, el valor es ""
//  T2 t2{};                // error: clase sin constructor por defecto
    T3 t3{};                // clase con constructor por defecto proporcionado por el usuario =>
    std::cout << t3.mem1;   //     t3.mem1 es inicializado por defecto a valor indeterminado
    assert(t3.mem2 == "");  //     t3.mem2 es inicializado por defecto, el valor es ""
    std::vector<int> v(3);  // inicialización por valor de cada elemento
    assert(v[2] == 0);      // el valor de cada elemento es 0
    std::cout << '\n';
    delete[] a;
}

42

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

Véase también

• constructor predeterminado
• explicit
• inicialización de agregado
• inicialización de lista