Constructores y listas de inicializadores de miembros

El constructor es una función miembro especial, no estática, de una clase que se usa para inicializar objetos de su tipo de clase.

En la definición del constructor de una clase, la lista de inicializadores de miembros especifica los inicializadores para los subobjetos directos y de bases virtuales, así como de los datos miembro no estáticos. No debe confundirse con std::initializer_list.

[editar] Sintaxis

Los constructores se declaran usando los declaradores de función miembro de la siguiente manera:

Donde el nombre-de-la-clase debe nombrar la clase actual (o la instanciación actual de una plantilla de clase), o, al declararse en un ámbito de espacio de nombres o en una declaración friend, debe ser un nombre de clase calificado.

Los únicos especificadores que se permiten en la sec-decl-especificadores de la declaración de un constructor son friend, inline, constexpr (desde C++11), consteval (desde C++20), y explicit (en particular, no se permite un tipo de retorno). Observa que los calificadores-cv y de referencia tampoco se permiten; la semántica const y volatile de un objeto en proceso de construcción no surte efecto hasta que se completa el constructor de la clase más derivada.

El cuerpo de una definición de función para cualquier constructor, antes de la llave de apertura de la instrucción compuesta, puede incluir la lista de inicializadores de miembros, cuya sintaxis es el carácter de dos puntos :, seguido de una lista separada por comas de uno o más inicializadores de miembros, cada uno de los cuales tiene la siguiente sintaxis:

struct S 
{
    int n;
 
    S(int);             // declaración del constructor 
    S() : n(7) {}       // definición del constructor
                        // ": n(7)" es la listas de inicializadores
                        // ": n(7) {}" es el cuerpo de la función
};
 
S::S(int x) : n{x} {}   // definición del constructor
                        // ": n{x}" es la listas de inicializadores
int main()
{
    S s;                // llama a S::S()
    S s2(10);           // llama a S::S(int)
}

[editar] Explicación

Los constructores no tienen nombres y no pueden llamarse directamente. Se invocan cuando tiene lugar la inicialización, y se seleccionan de acuerdo con las reglas de inicialización. Los constructores sin especificador explicit son constructores de conversión. Los constructores con un especificador constexpr hacen que su tipo sea un LiteralType. Los constructores que pueden llamarse sin ningún argumento son constructores por defecto. Los constructores que toman otro objeto del mismo tipo que el argumento son constructores de copia y constructores de movimiento.

Antes de que la instrucción compuesta que forma el cuerpo de la función del constructor comience a ejecutarse, finaliza la inicialización de todas las bases directas, bases virtuales y datos miembro no estáticos. La lista de inicializadores de miembros es el lugar donde se puede especificar la inicialización no predeterminada de estos objetos. Para las bases y los miembros de datos que no se pueden inicializar por defecto, como los miembros de referencia y los tipos calificados const, se deben especificar los inicializadores de miembros. No se realiza ninguna inicialización para uniones anónimas o miembros variantes que no tienen un inicializador de miembro.

Los inicializadores donde una clase-o-identificador nombra una clase base virtual se ignoran durante la ejecución de los constructores de cualquier clase que no sea la clase más derivada del objeto que se está construyendo.

Los nombres que aparecen en la lista-de-expresiones o la lista-de-inicializadores-entre-llaves se evalúan en el ámbito del constructor:

class X 
{
    int a, b, i, j;
public:
    const int& r;
 
    X(int i)
      : r(a)    // inicializa a X::r para que se refiera a X::a
      , b{i}    // inicializa a X::b con el valor del parámetro i
      , i(i)    // inicializa a X::i con el valor del parámetro i
      , j(this->i)  // inicializa a X::j con el valor de X::i
    { }
};

Las excepciones que se generan desde los inicializadores de miembros pueden capturarse mediante el bloque try de función.

Las funciones miembro (incluidas las funciones miembro virtuales) se pueden invocar desde los inicializadores de miembro, pero el comportamiento no está definido si no se inicializan todas las bases directas en ese punto.

Para llamadas virtuales (si se inicializan las bases directas en este punto), se aplican las mismas reglas que las reglas para las llamadas virtuales de constructores y destructores: las funciones miembro virtuales se comportan como si el tipo dinámico de *this es el tipo estático de la clase que se está construyendo (el despacho dinámico no se propaga por la jerarquía de herencia) y las llamadas virtuales (pero no las llamadas estáticas) a las funciones miembro virtuales puras tienen comportamientos indefinidos.

struct S 
{
    int n = 42;   // inicializador de miembro por defecto
    S() : n(7) {} // establecerá n a 7, no a 42
};

Los miembros de referencia no pueden vincularse a temporales en la lista de inicializadores de miembros:

struct A 
{
    A() : v(42) { }  // ERROR
    const int& v;
};

Nota: lo mismo se aplica al inicializador de miembro por defecto.

class Foo 
{
public: 
    Foo(char x, int y) {}
    Foo(int y) : Foo('a', y) {} // Foo(int) delega a Foo(char,int)
};

[editar] Orden de inicialización

El orden de los inicializadores de miembros en la lista es irrelevante: el orden actual de inicialización es de la siguiente manera:

(Nota: si el orden de inicialización se controlara por el orden de aparición en la lista de inicializadores de miembros de distintos constructores, entonces el destructor no sería capaz de garantizar que el orden de destrucción fuera el inverso del orden de construcción)

[editar] Ejemplo

#include <fstream>
#include <string>
#include <mutex>
 
struct Base 
{
    int n;
};   
 
struct Clase : public Base
{
    unsigned char x;
    unsigned char y;
    std::mutex m;
    std::lock_guard<std::mutex> lg;
    std::fstream f;
    std::string s;
 
    Clase ( int x )
        : Base { 123 },   // inicializa clase base
        x ( x ),        // miembro x se inicializa con el parámetro x
        y { 0 },        // y se inicializa a 0
        f{"test.cc", std::ios::app}, // esto toma lugar después que se inicializan
                                     // m y lg
        s(__func__),    //__func__ está disponible porque la inicialización de lista
                        // es parte del constructor
        lg ( m ),       // lg usa a m, que ya está inicializada
        m{}             // m se inicializa antes que lg aun cuando aquí aparece el último
    {}                  // instrucción compuesta vacía 
 
    Clase ( double a )
        : y ( a+1 ),
        x ( y ),        // x se inicializará antes que y, aquí su valor es indeterminado
        lg ( m )
    {} // el constructor de la clase base no aparece en la lista.
       // Es inicializado por defecto (no es los mismo que si se hubiera usado Base(),
       // que se usa inicialización de un valor)
 
    Clase()
    try                 // el bloque try de función empieza antes que el cuerpo
                        // de la función, que incluye la lista de inicialización
      : Clase( 0.0 )    // constructor delegado
    {
        // ...
    }
    catch (...)
    {
        // ocurrió un error durante la inicialización
    }
};
 
int main() {
    Clase c;
    Clase c1(1);
    Clase c2(0.1);
}

[editar] Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

[editar] Referencias

[editar] Véase también

• Constructor por defecto
• Constructor de conversión
• Constructor de copia
• Asignación de copia
• Constructor de movimiento
• Asignación de movimiento
• Elisión de copia
• Destructor
• Inicialización
  • Inicialización de agregado
  • Inicialización por constante
  • Inicialización de copia
  • Inicialización por defecto
  • Inicialización directa
  • Inicialización de lista
  • Inicialización de referencia
  • Inicialización de un valor
  • Inicialización cero
• Especificador explicit
• Expresión new