¿Puede un constructor llamar a otro constructor en C++?

Question

class A{ 
    A(int a = 5){ 
    DoSomething(); 
    A(); 
    } 
    A(){...} 
} 

¿Puede el primer constructor llamar al segundo?

Answer 1

No before C++11.

En su lugar, extraiga la funcionalidad común en una función separada. Normalmente llamo a esta función constructo().

La segunda llamada llamada "así llamada" se compilaría, pero tiene un significado diferente en C++: construiría un nuevo objeto, un temporal, que luego se eliminará instantáneamente al final de la declaración. Entonces, no.

Sin embargo, un destructor puede invocarse sin problemas.

Answer 2

No antes de C++0x, no.

PERO, fuera de su interés académico Yo he llegado con una forma realmente horrible * hacerlo utilizando un operador de colocación "nueva" (cuidado de alguien para señalar cómo portátil que es esto?)

#include <new> 
#include <iostream> 

class A 
{ 
public: 
    A(int i, int j) 
     : i_(i), j_(j) { } 

    A(int i) 
    { new (this) A(i, 13); } 

    int i_,j_; 
}; 

int 
main() { 
    A a1(10,11), a2(10); 
    std::cout 
     << a1.i_ << ", " 
     << a1.j_ << std::endl 
     << a2.i_ << ", " 
     << a2.j_ << std::endl; 
    return 0; 
} 

* Demonios no, no escribo esto en el código de producción.

Answer 3

La respuesta es, de hecho, "sí", pero como otros han sugerido, no hace lo que desea. Por supuesto, puede utilizar el constructor de una clase base, ya sea implícita o explícitamente:

struct B { 
    B() {} 
    B(int x) {} 
}; 

struct A : public B { 
    A() {} // calls B() implicitly 
    A(int a, int b) : B(b) {} // calls B(int) explicitly 
}; 

Answer 4

No

directamente. Hay algunas formas de evitar esto.

Desde la lista de inicializadores del constructor de su clase, puede llamar a un constructor en cualquier clase base y en todas las variables miembro.

Por lo tanto, normalmente puede refactorizar su clase y dividirla en varias más pequeñas para resolver el problema. El código comúnmente ejecutado se puede colocar en un objeto miembro o quizás una clase base. Entonces cada uno de los constructores de la clase principal solo tiene que decidir qué construcotr usar para inicializar ese miembro.

class B { 
    B() { } 
    B(int b) { DoSomething(); } 
} 
class A{ 
    A(int a = 5) : b(a) { } // call B's constructor which does something 
    A() : b() {} // call B's constructor which does nothing 

    B b; 
}; 

Answer 5

Esta es una vieja pregunta; Sin embargo,

class A{ 
    A(int a = 5){ 
    DoSomething(); 
    A(); 
    } 
    A(){...} 
} 

podría ser

class A{ 
    A(int a = 5){ 
    *this = A(); 
    DoSomething(); 
    } 
    A(){...} 
}