std:: static_pointer_cast, std:: dynamic_pointer_cast, std:: const_pointer_cast, std:: reinterpret_pointer_cast

std::shared_ptr 의 저장된 포인터를 캐스트 표현식을 사용하여 r 의 저장된 포인터로부터 얻어내는 새로운 인스턴스를 생성합니다.

만약 r 가 비어 있다면, 새로운 shared_ptr 도 비어 있습니다(그러나 저장된 포인터가 반드시 null인 것은 아닙니다). 그렇지 않으면, 새로운 shared_ptr 은 r 의 초기값과 소유권을 공유합니다. 단, dynamic_pointer_cast 에 의해 수행된 dynamic_cast 가 null 포인터를 반환하는 경우에는 비어 있게 됩니다.

Y 를 typename std:: shared_ptr < T > :: element_type 라고 하면, 결과로 생성되는 std::shared_ptr 의 저장된 포인터는 각각 다음을 평가하여 얻어집니다:

이러한 함수들의 동작은 U* 에서 T* 로의 해당 캐스트가 올바르게 형성되지 않는 한 정의되지 않습니다:

매개변수

참고 사항

다음 표현식들 std:: shared_ptr < T > ( static_cast < T * > ( r. get ( ) ) ) , std:: shared_ptr < T > ( dynamic_cast < T * > ( r. get ( ) ) ) 그리고 std:: shared_ptr < T > ( const_cast < T * > ( r. get ( ) ) ) 은 동일한 효과를 가진 것처럼 보일 수 있지만, 모두 동일한 객체를 두 번 삭제하려 시도하여 정의되지 않은 동작을 초래할 가능성이 높습니다!

가능한 구현

template<class T, class U>
std::shared_ptr<T> static_pointer_cast(const std::shared_ptr<U>& r) noexcept
{
    auto p = static_cast<typename std::shared_ptr<T>::element_type*>(r.get());
    return std::shared_ptr<T>{r, p};
}

template<class T, class U>
std::shared_ptr<T> dynamic_pointer_cast(const std::shared_ptr<U>& r) noexcept
{
    if (auto p = dynamic_cast<typename std::shared_ptr<T>::element_type*>(r.get()))
        return std::shared_ptr<T>{r, p};
    else
        return std::shared_ptr<T>{};
}

template<class T, class U>
std::shared_ptr<T> const_pointer_cast(const std::shared_ptr<U>& r) noexcept
{
    auto p = const_cast<typename std::shared_ptr<T>::element_type*>(r.get());
    return std::shared_ptr<T>{r, p};
}

template<class T, class U>
std::shared_ptr<T> reinterpret_pointer_cast(const std::shared_ptr<U>& r) noexcept
{
    auto p = reinterpret_cast<typename std::shared_ptr<T>::element_type*>(r.get());
    return std::shared_ptr<T>{r, p};
}

예제

#include <iostream>
#include <memory>
class Base
{
public:
    int a;
    virtual void f() const { std::cout << "I am base!\n"; }
    virtual ~Base() {}
};
class Derived : public Base
{
public:
    void f() const override { std::cout << "I am derived!\n"; }
    ~Derived() {}
};
int main()
{
    auto basePtr = std::make_shared<Base>();
    std::cout << "Base pointer says: ";
    basePtr->f();
    auto derivedPtr = std::make_shared<Derived>();
    std::cout << "Derived pointer says: ";
    derivedPtr->f();
    // static_pointer_cast to go up class hierarchy
    basePtr = std::static_pointer_cast<Base>(derivedPtr);
    std::cout << "Base pointer to derived says: ";
    basePtr->f();
    // dynamic_pointer_cast to go down/across class hierarchy
    auto downcastedPtr = std::dynamic_pointer_cast<Derived>(basePtr);
    if (downcastedPtr)
    {
        std::cout << "Downcasted pointer says: ";
        downcastedPtr->f();
    }
    // All pointers to derived share ownership
    std::cout << "Pointers to underlying derived: "
              << derivedPtr.use_count()
              << '\n';
}

Base pointer says: I am base!
Derived pointer says: I am derived!
Base pointer to derived says: I am derived!
Downcasted pointer says: I am derived!
Pointers to underlying derived: 3

참고 항목