shared_ptr의 non-const 참조를 기본 클래스로 캐스트하는 더 안전하고 안전한 방법이 있습니까?

Question

가상 메소드가있는 클래스 기반과 가상 메소드를 구현하는 구현 클래스가있는 경우 std :: shared_ptr을 캐스팅 할 방법이 있습니까 < 구현> &을 std :: shared <베이스> &으로 변환 하시겠습니까? 컴파일러는 const 참조를 허용하지만 비 const 참조의 경우 아래 코드의 "사례 A"에서처럼 실패합니다. 이 작업을 수행하는 쉬운 방법이 있습니까?

그렇지 않은 경우 케이스 B에서 해결 방법 "questionable_cast"를 사용해도 안전합니까? 이 문제에

#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

두 명백한 솔루션은 원래 질문으로 : 1. 만들기는 do_something shared_ptr을 (또는 값에 의해 shared_ptr을)에 const를 참조 가져 가라. 2. 이름이있는 shared_ptr을 작성하고 그에 대한 참조를 전달 : 예

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

당신의 questionable_cast 기능은 엄격한 앨리어싱 규칙의 위반이며, 정의되지 않은 동작을 호출합니다. 그것은 초기 테스트에서 작동 할 가능성이 매우 높습니다. 그리고 컴파일러의 새로운 릴리즈는 최적화를 한 단계 끌어 올릴 것이며, 데모 중에는 실패 할 것입니다.

do_something 포인터 변경하는 경우 처리하려면 :

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

do_something 만약 보장이 같은 포인터를 반환하지 않는 경우에도, 같은 파생 타입의 포인터를 반환 템플릿에 포장하기를 함수 :

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