Il costruttore può chiamare un altro costruttore in C++?

Question

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

Il primo costruttore può chiamare il secondo?

Answer 1

Non before C++11.

Estrarre invece la funzionalità comune in una funzione separata. Di solito chiamo questa funzione construct().

La cosiddetta seconda chiamata si compilerebbe, ma ha un significato diverso in C++: costruirà un nuovo oggetto, un temporaneo, che verrà quindi cancellato all'istante alla fine dell'istruzione. Quindi, no.

Un distruttore, tuttavia, può essere chiamato senza problemi.

Answer 2

Non prima C++0x, n.

MA, solo per interesse accademico mi è venuta in un modo davvero orribile * a farlo utilizzando un operatore di posizionamento "nuovo" (cura qualcuno per sottolineare come questo è portatile?)

#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; 
} 

* Inferno no, non lo scrivo nel codice di produzione.

Answer 3

La risposta è in effetti "sì", ma come altri hanno suggerito, non fa quello che vuoi. Ovviamente è possibile utilizzare il costruttore di una classe base, in modo implicito o esplicito:

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

Non direttamente. Ci sono alcuni modi per ovviare a questo.

Dall'elenco di inizializzazione del costruttore della classe, è possibile chiamare un costruttore su qualsiasi classe di base e su tutte le variabili membro.

Quindi, di solito, puoi rifattorizzare la tua classe e dividerla in più piccole per risolvere il problema. Il codice comunemente eseguito può essere inserito in un oggetto membro o forse in una classe base. Quindi ognuno dei costruttori principali della classe deve decidere quale costrutto utilizzare per inizializzare quel membro.

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

Questa è una vecchia domanda; tuttavia,

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

potrebbe essere

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