C++ constructeur de copie implicite pour une classe qui contient d'autres objets

Foo f1;
Foo f2(f1);

Oui, cela fera ce que vous attendez:
Le constructeur de copie F2 Foo:: Foo (Foo const&) est appelé.
Cette copie construit sa classe de base, puis chaque membre (récursivement)

Si vous définissez une classe comme ceci:

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

Les méthodes suivantes seront définies par votre compilateur.

• Constructeur (par défaut) (2 versions)
• Constructeur (Copie)
• Destructeur (par défaut)
• affectation opérateur

Constructeur: Par Défaut:

Il y a en fait deux constructeurs par défaut.
L'un est utilisé pour zero-initialization, tandis que l'autre est utilisé pour value-initialization. L'utilisation dépend si vous utilisez () lors de l'initialisation ou non.

// 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'
{
}

Notes: si la classe de base ou les membres n'ont pas de constructeur par défaut visible valide, le constructeur par défaut ne peut pas être généré. Ce n'est pas une erreur sauf si votre code essaie d'utiliser le constructeur par défaut (alors seulement une compilation erreur d').

Constructeur (Copie)

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)
{}

Notes: si la classe de base ou les membres n'ont pas de constructeur de copie visible valide, le constructeur de copie ne peut pas être généré. Ce n'est pas une erreur sauf si votre code essaie d'utiliser le constructeur de copie (alors seulement une erreur de compilation).

Opérateur D'Affectation

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

Notes: si la classe de base ou les membres n'ont pas d'opérateur d'affectation viable valide, l'opérateur d'affectation ne peut pas être généré. Ce n'est pas une erreur sauf si votre code essaie d'utiliser l'opérateur d'affectation (alors seulement une erreur de compilation).

Destructeur

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

• Si un constructeur (y compris copy) est déclaré, le constructeur par défaut n'est pas implémenté par le compilateur.
• Si le constructeur de copie est déclaré, le compilateur n'en générera pas.
• Si l'opérateur d'affectation est déclaré, le compilateur n'en générera pas.
• Si un destructeur est déclaré le compilateur ne générera pas un.

Regardant votre code les constructeurs de copie suivants sont générés:

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)
{}