Zurückgegebenes abgeleitetes Objekt als Basis von virtueller Methode

Question

Es gibt eine virtuelle Methode in der Basisklasse, die dasselbe Basisobjekt (nicht Zeiger) zurückgibt. In einigen der virtuellen Überschreibungen möchte ich abgeleitete Objekte als Basis zurückgeben. Problem ist jedoch, dass die Methode das Basisobjekt immer dazu bringt, abgeleitete Werte zurückzugeben. Hier ist einfaches Beispiel:

#include <iostream> 
#include <string> 

class Base { 
public: 
    Base() {} 
    virtual std::string myName() { return "Base"; } 
    virtual Base createAlike() { return Base(); } 
}; 

class Derived : public Base { 
public: 
    Derived() : Base() {} 
    std::string myName() override { return "Derived"; } 
    Base createAlike() override { return Derived(); } 
}; 

int main() { 
    Derived d; 
    Base d1 = d.createAlike(); 
    std::cout << d.myName() << std::endl; 
    std::cout << d1.myName(); 
    return 0; 
} 

die Ausgänge:

Derived 
Base 

Wie es zu korrigieren?

Answer 1

Da Sie nach Wert zurückgeben, ist der Rückgabewert eine Kopie des Ausdrucks, den Sie zurückgegeben haben. Und da dieser Rückgabetyp immer Base ist, wird das Objekt Derived abgeschnitten. Damit Polymorphismus funktioniert, benötigen Sie in der Regel einen Zeiger oder eine Referenz.

Versuchen Sie dies mit std::unique_ptr:

#include <iostream> 
#include <string> 
#include <memory> 

class Base { 
public: 
    Base() {} 
    virtual std::string myName() { return "Base"; } 
    virtual std::unique_ptr<Base> createAlike() 
    { return std::make_unique<Base>(); } 
}; 

class Derived : public Base { 
public: 
    Derived() : Base() {} 
    std::string myName() override { return "Derived"; } 
    std::unique_ptr<Base> createAlike() override 
    { return std::make_unique<Derived>(); } 
}; 

int main() { 
    Derived d; 
    auto d1 = d.createAlike(); 
    std::cout << d.myName() << std::endl; 
    std::cout << d1->myName(); 
    return 0; 
}