Cadena de constructor en C++

Question

Mi comprensión del encadenamiento de constructores es que, cuando hay más de un constructor en una clase (constructores sobrecargados), si uno de ellos intenta llamar a otro constructor, entonces este proceso se llama CONSTRUCTOR CHAINING, que no es compatible con C++. Recientemente me encontré con este párrafo, mientras que la lectura de material en línea .... Dice así ...

Usted puede encontrarse en la situación en la que desea escribir una función miembro para volver a inicializar una clase de nuevo a los valores predeterminados. Como probablemente ya tiene un constructor que hace esto, puede sentirse tentado de intentar llamar al constructor desde su función de miembro. Como se mencionó, encadenar llamadas de constructor son ilegales en C++. Podría copiar el código del constructor en su función, lo que funcionaría, pero conduciría a un código duplicado. La mejor solución en este caso es mover el código del constructor a su nueva función y hacer que el constructor llame a su función para hacer el trabajo de inicialización de los datos.

¿Una función de miembro que llama al constructor también viene bajo encadenamiento de constructor? Por favor, arroje algo de luz sobre este tema en C++.

Answer 1

El párrafo dice básicamente esto:

class X 
{ 
    void Init(params) {/*common initing code here*/ } 
    X(params1) { Init(someParams); /*custom code*/ } 
    X(params2) { Init(someOtherParams); /*custom code*/ } 
}; 

no puede llamar a un constructor de una función miembro tampoco. Puede parecer que tú has hecho, pero eso es una ilusión:

class X 
{ 
public: 
    X(int i):i(i){} 
    void f() 
    { 
     X(3); //this just creates a temprorary - doesn't call the ctor on this instance 
    } 
    int i; 
}; 

int main() 
{ 
    using std::cout; 
    X x(4); 
    cout << x.i << "\n"; //prints 4 
    x.f(); 
    cout << x.i << "\n"; //prints 4 again 
} 

Answer 2

Eso no es lo que dice el texto. Está sugiriendo que su constructor llame a una función miembro que es normal y legal. Esto es para evitar llamar explícitamente al ctor nuevamente y evitar la duplicación de código entre su ctor y la función de reinicio.

Foo::Foo() { 
    Init(); 
} 

void Foo::Reset() { 
    Init(); 
} 

void Foo::Init() { 
    // ... do stuff ... 
} 

Answer 3

no estoy seguro de si (llamando a un constructor de una función miembro) funcionará o no, pero es una mala práctica. mover el código de inicialización a una nueva función es la forma lógica.

Básicamente diciendo: No llama al constructor a menos que la construcción ...

Answer 4

cuando llamamos el constructor de una función miembro, entonces se creará un objeto temporal de su tipo. en caso de que llamemos a la función de clase derivada, todos los constructores padre también se ejecutarán y destruirán usando destructor una vez que la función se salga del alcance.

no es una buena práctica para llamar a los constructores en las funciones miembro, ya que crea objetos de todas las clases derivadas.

Answer 5

C++ 11 permite el encadenamiento del constructor (parcialmente). Esta función se llama "delegating constructors". Así que en C++ 11 se puede hacer lo siguiente

class Foo 
{ 
public: 
    Foo(int a) : Foo() { _a = a; } 
    Foo(char* b) : Foo() { _b = b; } 
    Foo() { _c = 1.5; } 
private: 
    int _a = 0; 
    char* _b = nullptr; 
    double _c; 
}; 

Sin embargo, hay una limitación grave que un constructor que llama a otro constructor no se le permite inicializar los otros miembros. Por lo que no puede hacer lo siguiente con un constructor delegar:

class Foo 
{ 
public: 
    Foo(int a) : Foo(), _a(a) { } 
    Foo(char* b) : Foo(), _b(b) { } 
    Foo() { _c = 1.5; } 
private: 
    int _a = 0; 
    char* _b = nullptr; 
    double _c; 
}; 

MSVC++ 2013 da compilar error "C3511: una llamada a un constructor delegar será el único miembro-inicializador" para el ejemplo de código de este último.