Delegación de constructores en C++

A veces es útil que un constructor pueda llamar a otro constructor de la misma clase. Esta característica, llamada Delegación de constructor , se introdujo en C++ 11.
Un programa de ejemplo sin delegación: 
 

// A C++ program to demonstrate need of
// constructor delegation.
#include <iostream>
using namespace std;
 
class A {
    int x, y, z;
 
public:
    A()
    {
        x = 0;
        y = 0;
        z = 0;
    }
    A(int z)
    {
        // The below two lines are redundant
        x = 0;
        y = 0;
 
        /* Only initialize z by passing an argument,
           while all the other arguments are
           initialized the same way they were,
           as in the previous constructor*/
        this->z = z;
    }
 
    void show()
    {
        cout << x << '\n'
             << y << '\n'
             << z;
    }
};
 
int main()
{
    A obj(3);
    obj.show();
    return 0;
}

0
0
3

Resolviendo el problema de código redundante anterior usando init() 
Podemos ver en el ejemplo anterior que los constructores de la clase anterior, a pesar de tener diferentes firmas, tienen dos primeras líneas de código comunes entre ellos, lo que lleva a la duplicación de código. Una solución para evitar esta situación habría sido la creación de una función de inicio que se puede llamar desde ambos constructores. 
 

// Program to demonstrate use of init() to
// avoid redundant code.
#include <iostream>
using namespace std;
 
class A {
    int x, y, z;
 
    // init function to initialize x and y
    void init()
    {
        x = 0;
        y = 0;
    }
 
public:
    A()
    {
        init();
        z = 0;
    }
    A(int z)
    {
        init();
        this->z = z;
    }
 
    void show()
    {
        cout << x << '\n'
             << y << '\n'
             << z;
    }
};
 
int main()
{
    A obj(3);
    obj.show();
    return 0;
}

0
0
3

Resolviendo el problema de código redundante anterior usando la delegación del constructor() 
Si bien el uso de una función init() elimina el código duplicado, todavía tiene sus propios inconvenientes. Primero, no es tan legible, ya que agrega una nueva función y varias llamadas a funciones nuevas. En segundo lugar, debido a que init() no es un constructor, se puede llamar durante el flujo normal del programa, donde las variables miembro ya pueden estar configuradas y la memoria asignada dinámicamente ya puede estar asignada. Esto significa que init() debe ser más complejo para poder manejar correctamente los casos de nueva inicialización y reinicialización.
Sin embargo, la delegación de C++ Constructor proporciona una solución elegante para manejar este problema, permitiéndonos llamar a un constructor colocándolo en la lista de inicializadores de otros constructores. El siguiente programa demuestra cómo se hace:
 

// Program to demonstrate constructor delegation
// in C++
#include <iostream>
using namespace std;
class A {
    int x, y, z;
 
public:
    A()
    {
        x = 0;
        y = 0;
        z = 0;
    }
 
    // Constructor delegation
    A(int z) : A()
    {
        this->z = z; // Only update z
    }
 
    void show()
    {
        cout << x << '\n'
             << y << '\n'
             << z;
    }
};
int main()
{
    A obj(3);
    obj.show();
    return 0;
}

0
0
3

Es muy importante tener en cuenta que la delegación del constructor es diferente de llamar a un constructor desde el interior del cuerpo de otro constructor, lo cual no se recomienda porque al hacerlo se crea otro objeto y lo inicializa, sin hacer nada al objeto creado por el constructor que lo llamó. .