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

Создает новый экземпляр std::shared_ptr , чей хранимый указатель получается из хранимого указателя r с использованием выражения приведения типа.

Если r пуст, то новый shared_ptr также будет пустым (но его сохранённый указатель не обязательно нулевой). В противном случае новый shared_ptr будет разделять владение с начальным значением r , за исключением случая, когда он оказывается пустым, если dynamic_cast , выполняемый dynamic_pointer_cast , возвращает нулевой указатель.

Пусть 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};
}

` и `` сохранены без изменений. C++ специфические термины не переведены.

Пример

#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 для восходящего преобразования в иерархии классов
    basePtr = std::static_pointer_cast<Base>(derivedPtr);
    std::cout << "Base pointer to derived says: ";
    basePtr->f();
    // dynamic_pointer_cast для нисходящего/поперечного преобразования в иерархии классов
    auto downcastedPtr = std::dynamic_pointer_cast<Derived>(basePtr);
    if (downcastedPtr)
    {
        std::cout << "Downcasted pointer says: ";
        downcastedPtr->f();
    }
    // Все указатели на производный класс разделяют владение
    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

Смотрите также