Gibt es eine bessere/sichere Möglichkeit, eine nicht-konstante Referenz von shared_ptr auf eine Basisklasse zu übertragen?

Question

Wenn Sie eine Klasse Base mit virtuellen Methoden und eine Klasse Implementierung haben, die die virtuellen Methoden implementiert, gibt es eine Möglichkeit, std :: shared_ptr < Implementierung zu std :: shared < Base> &? Der Compiler erlaubt dies für Const-Verweise, aber für nicht-const-Verweise schlägt es wie in "Case A" in dem folgenden Code fehl. Gibt es einen einfachen Weg, dies zu tun?

Wenn nicht, wie sicher ist meine Problemumgehung "fraglich_cast" in Fall B?

#include <iostream> 
#include <memory> 

class Base 
{ 
public: 
    virtual void set_value(int x) = 0; 
}; 

class Implementation : public Base 
{ 
public: 
    Implementation() : m_value(0) { } 
    void set_value(int x) override 
    { 
    m_value = x; 
    } 
    int get_value() const 
    { 
    return m_value; 
    } 
private: 
    int m_value; 
}; 


void do_something(std::shared_ptr<Base>& base) 
{ 
    base->set_value(5); 

    /// Code like this makes the non-const argument necessary 
    base = std::make_shared<Implementation>(); 
} 

template <class T, class U> 
std::shared_ptr<T>& questionable_cast(std::shared_ptr<U>& u) 
{ 
    /// This code is here to assure the cast is allowed 
    std::shared_ptr<T> tmp = u; 
    (void)tmp; 

    return *reinterpret_cast<std::shared_ptr<T>*>(&u); 
} 

int main() 
{ 
    std::shared_ptr<Implementation> a = std::make_shared<Implementation>(); 

    // The following line causes a compiler error: 
    // invalid initialization of reference of type ‘std::shared_ptr<Base>&’ ... 
    // do_something(a); 
    // do_something(std::dynamic_pointer_cast<Base>(a)); 

    // This is the workaround 
    do_something(questionable_cast<Base>(a)); 

    std::cerr << "a = " << a->get_value() << std::endl; 

    return 0; 
} 

Answer 1

Zwei offensichtliche Lösungen für das Problem, wie ursprünglich gefragt: 1. Machen Sie do_something nimmt eine konstante Referenz auf einen shared_ptr (oder einen Shared_ptr nach Wert). 2. Erstellen Sie einen Namen shared_ptr und übergeben einen Verweis auf das: Eg

int main() 
{ 
    std::shared_ptr<Implementation> a = std::make_shared<Implementation>(); 
    std::shared_ptr<Base> b = a; // This conversion works. 
    do_something(b); // Pass a reference to b instead. 
    return 0; 
} 

Ihre questionable_cast Funktion ist eine Verletzung der strengen Aliasing Regeln und ruft nicht definiertes Verhalten. Es ist sehr wahrscheinlich, dass es in ersten Tests funktioniert, und dann wird eine neue Version des Compilers die Optimierung ein wenig ankurbeln, und es wird während einer Demo versagen.

den Fall zu behandeln, wo do_something den Zeiger ändert:

int main() 
{ 
    std::shared_ptr<Implementation> a = std::make_shared<Implementation>(); 
    std::shared_ptr<Base> b = a; // This conversion works. 
    do_something(b); // Pass a reference to b instead. 
    const auto aa = std::dynamic_pointer_cast<Implementation>(b); 
    if (aa) 
     a = aa; 
    else 
     ; // Handle the error here 
    return 0; 
} 

Wenn do_something garantiert einen Zeiger aus dem gleichen abgeleiteten Typ zurückzukehren, auch wenn sie nicht den gleichen Zeiger zurückgibt, wickeln Sie es in einer Vorlage Funktion:

template <typename T> 
void do_something_ex(std::shared_ptr<T>& a) 
{ 
    std::shared_ptr<Base> b = a; 
    do_something(b) 
    a = std::dynamic_pointer_cast<T>(b); 
    if (!a) 
     throw_or_assert; 
}