C++ implicit copy constructor dla klasy, która zawiera inne obiekty

Foo f1;
Foo f2(f1);

Yes this will do what you expect it to:
Wywoływany jest Konstruktor kopiujący F2 Foo:: Foo (Foo const&).
Ta kopia konstruuje swoją klasę bazową, a następnie każdy element (rekurencyjnie)

Jeśli zdefiniujesz klasę w ten sposób:

class X: public Y
{
    private:
        int     m_a;
        char*   m_b;
        Z       m_c;
};

Następujące metody zostaną zdefiniowane przez kompilator.

• Konstruktor (domyślnie) (2 wersje)
• Konstruktor (Kopia)
• Destructor (domyślnie)
• przypisanie operator

Konstruktor: Default:

W rzeczywistości istnieją dwa domyślne konstruktory.
Jeden jest używany do zero-initialization, podczas gdy drugi jest używany do value-initialization. Użyte zależy od tego, czy użyjesz () podczas inicjalizacji, czy nie.

// Zero-Initialization compiler generated constructor
X::X()
    :Y()                // Calls the base constructor
                        //     If this is compiler generated use 
                        //     the `Zero-Initialization version'
    ,m_a(0)             // Default construction of basic PODS zeros them
    ,m_b(0)             // 
    m_c()               // Calls the default constructor of Z
                        //     If this is compiler generated use 
                        //     the `Zero-Initialization version'
{
}

// Value-Initialization compiler generated constructor
X::X()
    :Y()                // Calls the base constructor
                        //     If this is compiler generated use 
                        //     the `Value-Initialization version'
    //,m_a()            // Default construction of basic PODS does nothing
    //,m_b()            // The values are un-initialized.
    m_c()               // Calls the default constructor of Z
                        //     If this is compiler generated use 
                        //     the `Value-Initialization version'
{
}

Uwagi: jeśli klasa bazowa lub któryś z członków nie ma poprawnego, widocznego domyślnego konstruktora, to konstruktor domyślny nie może zostać wygenerowany. To nie jest błąd, chyba że Twój kod próbuje użyć domyślnego konstruktora (wtedy tylko kompilacji błąd czasu).

Konstruktor (Kopia)

X::X(X const& copy)
    :Y(copy)            // Calls the base copy constructor
    ,m_a(copy.m_a)      // Calls each members copy constructor
    ,m_b(copy.m_b)
    ,m_c(copy.m_c)
{}

Uwagi: jeśli klasa bazowa lub któryś z członków nie ma poprawnego widocznego konstruktora kopiującego, to Konstruktor kopiujący nie może zostać wygenerowany. Nie jest to błąd, chyba że Twój kod próbuje użyć konstruktora kopiującego (wtedy tylko błąd czasu kompilacji).

Operator Przypisania

X& operator=(X const& copy)
{
    Y::operator=(copy); // Calls the base assignment operator
    m_a = copy.m_a;     // Calls each members assignment operator
    m_b = copy.m_b;
    m_c = copy.m_c;

    return *this;
}

Uwagi: jeśli klasa bazowa lub którykolwiek z członków nie ma ważnego, wykonalnego operatora przypisania, operator przypisania nie może zostać wygenerowany. Nie jest to błąd, chyba że Twój kod próbuje użyć operatora przypisania (wtedy tylko błąd czasu kompilacji).

Destructor

X::~X()
{
                        // First runs the destructor code
}
    // This is psudo code.
    // But the equiv of this code happens in every destructor
    m_c.~Z();           // Calls the destructor for each member
    // m_b              // PODs and pointers destructors do nothing
    // m_a          
    ~Y();               // Call the base class destructor

• jeśli dowolny konstruktor (łącznie z kopią) jest zadeklarowany, wtedy konstruktor domyślny nie jest zaimplementowany przez kompilator.
• jeśli Konstruktor kopiujący jest zadeklarowany, kompilator go nie wygeneruje.
• jeśli operator przypisania jest zadeklarowany, kompilator go nie wygeneruje.
• jeśli Destruktor jest deklaruje, że kompilator nie wygeneruje takiego

Patrząc na Twój kod, generowane są następujące konstruktory kopiujące:

Foo::Foo(Foo const& copy)
    :bar(copy.bar)
{}

Bar::Bar(Bar const& copy)
    :i(copy.i)
    ,baz(copy.baz)
{}

Baz::Baz(Baz const& copy)
    :j(copy.j)
{}