Wie implementiert man einen Move-Konstruktor für eine diamantförmige Vererbung?

Question

Ich habe eine rautenförmige Hierarchie von Klassen, in denen es weder einen Standardkonstruktor noch Kopierkonstruktoren gibt. Die beiden Konstrukteure ich habe, sind eine „Bewegung“ ein und eine andere, die einen L-Wert-Referenz auf ein Objekt nimmt:

struct base { 
    base(base&&) = default; 
    base(member_type&& m): member_(std::move(m)) {} 
    member_type member_; 
}; 

struct virt_1: virtual base { 
    virt_1(virt_1&& rhs): base(std::move(rhs)) {} 
    virt_1(member_type&& m): base(std::move(m)) {} 
}; 

struct virt_2: virtual base { 
    virt_2(virt_2&& rhs): base(std::move(rhs)) {} 
    virt_2(member_type&& m): base(std::move(m)) {} 
}; 

struct concrete: virt_1, virt_2 { 
    concrete(concrete&& rhs) // ??? 
}; 

Neben keinen rautenförmigen Hierarchie verwendet wird, ist es möglich, die Bewegung Konstruktor für die konkrete Klasse zu implementieren ?

Danke!

Answer 1

Was ist falsch daran, den Compiler nach der Implementierung zu fragen?

concrete(concrete&&) = default; 

Ich würde definieren die virt_1 und virt_2 Konstrukteurs bewegen als zu Verzug geraten.

Man könnte es schreiben, wenn Sie wirklich wollte:

concrete(concrete&& rhs) 
: base(std::move(rhs)), virt_1(std::move(rhs)), virt_2(std::move(rhs)) 
{ } 

Oder wenn Sie wirklich, wie eingeben:

concrete(concrete&& rhs) 
    : base(static_cast<base&&>(rhs)), 
     virt_1(static_cast<virt_1&&>(rhs)), 
     virt_2(static_cast<virt_2&&>(rhs)) 
    { } 

Die Initialisierungen für die virt_1 und virt_2 Basen nutzlos sind, weil sie nur Rufen Sie den base Konstruktor auf, und da es eine virtuelle Basis ist, werden sie das nicht tun, wenn concrete es aufgerufen hat, aber aufgrund Ihrer Auswahl von Konstruktoren können Sie sie nicht standardmäßig konstruieren und müssen sie mit einem initialisieren rvalue, obwohl sie nichts damit machen.

Answer 2

Sicher. Jeder Konstruktor mit einer virtual Basis irgendwo in der Hierarchie ist verantwortlich für die Initialisierung dieser Basis. Im Wesentlichen erbt jede Klasse unterhalb der virtual Basis in der Hierarchie die Berechtigung zum Initialisieren der Basis.

In diesem Fall sollte der Standard-Move-Konstruktor das Richtige tun. Ich würde auch empfehlen, concrete : private virtual base zu spezifizieren, um zu klären, was passiert.

Here ist eine funktionierende Demo.