Aufruf default-copy-Konstruktor von innen überlastet copy-Konstruktor

Hier ist die Frage, die code, da ich dies Schreibe:

class Foo {
public:
     Foo() {}
     Foo(Foo const & other);
     ...
private:
     int a, b, c, d, e;
     std::shared_ptr<Bla> p;
};

Foo::Foo(Foo const & other) {
    p.reset(new Bla(other.p));

    //Can I avoid having to write the default copy constructor code below
    a = other.a;
    b = other.b;
    c = other.c;
    d = other.d;
    e = other.e;
}

Den oben genannten code ist wahrscheinlich falsch, weil

1. den default-Konstruktor Blätter a, b, c, d und e nicht initialisiert, und

2. den code nicht übernehmen Zuordnung kopieren, und

3. den Ausdruck new Bla(other.p) erfordert, dass Bla hat einen Konstruktor nehmen eine std::shared_ptr<Bla>, das ist extrem unwahrscheinlich.

Mit std::shared_ptr dies würde zu C++11 code, um formal korrekte Sprache-klug. Ich glaube jedoch, dass es nur code, der verwendet, was verfügbar ist, mit Ihrem compiler. Und so glaube ich, dass die relevanten C++ - standard C++98, die mit der technischen Korrekturen von den C++03-änderung.

Können Sie ganz einfach nutzen Sie die eingebauten (generiert) kopieren Initialisierung, auch in C++98, z.B.

namespace detail {
    struct AutoClonedBla {
        std::shared_ptr<Bla> p;

        AutoClonedBla( Bla* pNew ): p( pNew ) {}

        AutoClonedBla( AutoClonedBla const& other )
            : p( new Bla( *other.p ) )
        {}

        void swap( AutoClonedBla& other )
        {
            using std::swap;
            swap( p, other.p );
        }

        AutoClonedBla& operator=( AutoClonedBla other )
        {
            other.swap( *this );
            return *this;
        }
    };
}

class Foo {
public:
     Foo(): a(), b(), c(), d(), e(), autoP( new Bla ) {}
     //Copy constructor generated by compiler, OK.

private:
     int                      a, b, c, d, e;
     detail::AutoClonedBla    autoP;
};

Beachten Sie, dass dieser code nicht korrekt initialisieren, die in der Standard-Konstruktor, nicht übernehmen kopieren-Zuordnung (mit den swap-idiom) und erfordert keine spezielle smart-pointer-bewusst Bla Konstruktor, sondern benutzt nur die normalen Bla copy-Konstruktor zum kopieren.

Wäre es einfacher zu schreiben, eine variation auf shared_ptr hat tief kopieren hinein gebaut. So, Sie nicht zu schreiben, ein copy-Konstruktor für Ihre main-Klasse; nur für diesen besonderen deep_copy_shared_ptr geben. Ihre deep_copy_shared_ptr hätte ein Kopie-Konstruktor, und es würde speichern shared_ptr selbst. Es könnte sogar eine implizite Konvertierung zu shared_ptr, um es ein bisschen einfacher zu verwenden.

Nicht möglich ist. Es ist entweder erstellen Sie eine benutzerdefinierte Kopie-Konstruktor (ganz auf eigene Faust) oder der compiler schreibt es für Sie.

Beachten Sie, dass wenn Sie schreiben, ein copy-Konstruktor, dann müssen Sie wahrscheinlich eine Kopie, Zuweisung und Destruktor als gut, weil das schreiben auf jeder dieser drei Ressource-management-Funktionen bedeutet, Sie sind Geschäftsführer einer Ressource. Mit der copy-and-swap-idiom, jedoch, Sie müssen nur schreiben die Kopie Logik einmal in den copy-Konstruktor, und Sie dann definieren Sie den Zuweisungsoperator in Bezug auf die Kopie-Konstruktor.

Abgesehen davon, ich bin mir nicht ganz sicher, warum man mit einem shared_ptr<>. Der Punkt, der eine shared_ptr<> ist, um zu ermöglichen, dass mehrere Zeiger auf sicher zeigen auf das gleiche Objekt. Aber du bist nicht die Freigabe der pointee, Sie tief zu kopieren. Vielleicht sollten Sie ein raw-pointer statt, und frei in den Destruktor. Oder, noch besser, ersetzen Sie die shared_ptr<> mit einem clone_ptr, und eliminieren dann die Kopie-Konstruktor, copy-Zuweisung und Destruktor insgesamt.