Perché il costruttore di copia implicito chiama il costruttore di copia della classe base e il costruttore di copie definito non lo fa?

Question

consideri una gerarchia di classi in cui A è la classe base e B deriva da A.

Se il costruttore di copia non è definito nel B, il compilatore sintetizzerà uno. Quando viene richiamato, questo costruttore di copia chiamerà il costruttore di copia della classe di base (anche quello sintetizzato, se nessuno è stato fornito dall'utente).

#include <iostream> 

class A { 
    int a; 
public: 
    A() { 
     std::cout << "A::Default constructor" << std::endl; 
    } 

    A(const A& rhs) { 
     std::cout << "A::Copy constructor" << std::endl; 
    } 
}; 

class B : public A { 
    int b; 
public: 
    B() { 
     std::cout << "B::Default constructor" << std::endl; 
    } 
}; 

int main(int argc, const char *argv[]) 
{ 
    std::cout << "Creating B" << std::endl; 
    B b1; 
    std::cout << "Creating B by copy" << std::endl; 
    B b2(b1); 
    return 0; 
} 

uscita:

Creating B 
A::Default constructor 
B::Default constructor 
Creating B by copy 
A::Copy constructor 

---

Se l'utente definisce la propria costruttore di copia in B, quando invocato, questo costruttore di copia chiamerà il costruttore di base classe predefinita, a meno che una chiamata a il costruttore di copia della classe base è esplicitamente presente (ad es. nell'elenco di inizializzazione).

#include <iostream> 

class A { 
    int a; 
public: 
    A() { 
     std::cout << "A::Default constructor" << std::endl; 
    } 

    A(const A& rhs) { 
     std::cout << "A::Copy constructor" << std::endl; 
    } 
}; 

class B : public A { 
    int b; 
public: 
    B() { 
     std::cout << "B::Default constructor" << std::endl; 
    } 
    B(const B& rhs) { 
     std::cout << "B::Copy constructor" << std::endl; 
    } 
}; 

int main(int argc, const char *argv[]) 
{ 
    std::cout << "Creating B" << std::endl; 
    B b1; 
    std::cout << "Creating B by copy" << std::endl; 
    B b2(b1); 
    return 0; 
} 

uscita:

Creating B 
A::Default constructor 
B::Default constructor 
Creating B by copy 
A::Default constructor 
B::Copy constructor 

---

La mia domanda è: perché non il costruttore di copia definito dall'utente chiamare la copia costruttore della classe base, come un comportamento di default?

Answer 1

Questo è solo il modo in cui il costruttore di copia implicita è definita (non avrebbe senso chiamare il default). Non appena si definisce un costruttore (copia o altro), il suo normale comportamento automatico è chiamare il costruttore genitore predefinito, quindi sarebbe incoerente modificarlo per uno specifico costruttore definito dall'utente.

Answer 2

La semplice (forse banale) risposta è perché non hai detto a. Dato che stai scrivendo il costruttore di copie derivato, puoi controllare completamente come si comporta. Non è possibile specificare una chiamata alla base e il compilatore genera il codice per inizializzare la classe base chiamando il costruttore predefinito delle classi di base.

Answer 3

Tutti i costruttori bambino di base chiamare il costruttore di default genitore. Ecco come viene definito lo standard. Come lei ha sottolineato, se si voleva la classe base B a chiamare costruttore di copia di un dovete esplicitamente richiesto

#include <iostream> 

class A { 
int a; 
public: 
A() { 
    std::cout << "A::Default constructor" << std::endl; 
} 

A(const A& rhs) { 
    std::cout << "A::Copy constructor" << std::endl; 
} 
}; 

class B : public A { 
int b; 
public: 
B() { 
    std::cout << "B::Default constructor" << std::endl; 
} 
B(const B& rhs):A(rhs) { 
    std::cout << "B::Copy constructor" << std::endl; 
} 
}; 

int main(int argc, const char *argv[]) 
{ 
std::cout << "Creating B" << std::endl; 
B b1; 
std::cout << "Creating B by copy" << std::endl; 
B b2(b1); 
return 0; 
} 

Questo perché il compilatore non può sapere per ogni costruttore diversa che constuctor del genitore dovrebbe essere chiamato e quindi abbiamo i costruttori predefiniti Per tutti gli altri devi esplicitamente dichiararli.