Smart pointer conversion of C++ base class and derived class: static_pointer_cast, dynamic_pointer_cast, const_pointer_cast, reinterpret_pointer_cast
When we use "bare" pointers to perform up-down conversion on the class level, dynamic_cast can be used. Of course, we can also use static_cast, but dynamic_cast has a type checking function when performing downstream conversion (that is, base class to derived class), while static_cast does not. Therefore, there is a safety problem.
When we use smart pointers, we can use std::static_pointer_cast(), std::dynamic_pointer_cast, std::const_pointer_cast() and std::reinterpret_pointer_cast() if we need to perform up-down conversion at the class level. Their functions are similar to std::static_cast(), std::dynamic_cast, std::const_cast(), and std::reinterpret_cast(), except that the smart pointer std::shared_ptr is converted and std::shared_ptr is returned. Types of.
1. std::static_pointer_cast(): When the pointer is a smart pointer, it is up-converted. Static_cast cannot be converted. At this time, static_pointer_cast is required.
2. std::dynamic_pointer_cast(): When the pointer is a smart pointer, it is down-converted. If dynamic_cast is used, it cannot be converted. At this time, dynamic_pointer_cast is required.
3. std::const_pointer_cast(): The function is similar to std::const_cast()
4. std::reinterpret_pointer_cast(): The function is similar to std::reinterpret_cast()
Defined in header |
||
template< class T, class U > |
(1) | (since C++11) |
template< class T, class U > |
(2) | (since C++20) |
template< class T, class U > |
(3) | (since C++11) |
template< class T, class U > |
(4) | (since C++20) |
template< class T, class U > |
(5) | (since C++11) |
template< class T, class U > |
(6) | (since C++20) |
template< class T, class U > |
(7) | (since C++17) |
template< class T, class U > |
(8) | (since C++20) |
The smart pointer conversion of the base class and the derived class should use std::dynamic_pointer_cast
and std::static_pointer_cast
. Since std::dynamic_pointer_cast
and dynamic_cast
the same principle, std::static_pointer_cast
and static_cast
the same principle
Creates a new instance of std::shared_ptr whose stored pointer is obtained from r
's stored pointer using a cast expression.
If r
is empty, so is the new shared_ptr
(but its stored pointer is not necessarily null). Otherwise, the new shared_ptr
will share ownership with the initial value of r
, except that it is empty if the dynamic_cast
performed by dynamic_pointer_cast
returns a null pointer.
Let Y
be typename std::shared_ptr<T>::element_type, then the resulting std::shared_ptr's stored pointer will be obtained by evaluating, respectively:
1-2) static_cast<Y*>(r.get()).
3-4) dynamic_cast<Y*>(r.get()) (If the result of the dynamic_cast
is a null pointer value, the returned shared_ptr
will be empty.)
5-6) const_cast<Y*>(r.get()).
7-8) reinterpret_cast<Y*>(r.get())
The behavior of these functions is undefined unless the corresponding cast from U*
to T*
is well formed:
1-2) The behavior is undefined unless static_cast<T*>((U*)nullptr) is well formed.
3-4) The behavior is undefined unless dynamic_cast<T*>((U*)nullptr) is well formed.
5-6) The behavior is undefined unless const_cast<T*>((U*)nullptr) is well formed.
7-8) The behavior is undefined unless reinterpret_cast<T*>((U*)nullptr) is well formed.
After calling the rvalue overloads (2,4,6,8), |
(since C++20) |
Parameters
r | - | The pointer to convert |
Notes
The expressions std::shared_ptr<T>(static_cast<T*>(r.get())), std::shared_ptr<T>(dynamic_cast<T*>(r.get())) and std::shared_ptr<T>(const_cast<T*>(r.get())) might seem to have the same effect, but they all will likely result in undefined behavior, attempting to delete the same object twice!
Possible implementation
1、std::static_pointer_cast():
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);
}
2、std::dynamic_pointer_cast()
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>();
}
}
3、std::const_pointer_cast()
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);
}
4、std::reinterpret_pointer_cast()
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);
}
Use example:
#include <iostream>
#include <memory>
struct Base
{
int a;
virtual void f() const { std::cout << "I am base!\n";}
virtual ~Base(){}
};
struct Derived : Base
{
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";
}
Output:
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
Example 2
#include <iostream> // std::cout std::endl
#include <memory> // std::shared_ptr std::dynamic_pointer_cast std::static_pointer_cast
class base
{
public:
virtual ~base(void) = default;
};
class derived : public base
{
};
class test : public base
{
};
int main(void)
{
std::cout << std::boolalpha;
// 两个不同的派生类对象
auto derivedobj = std::make_shared<derived>();
auto testobj = std::make_shared<test>();
// 隐式转换 derived->base
std::shared_ptr<base> pointer1 = derivedobj;
// static_pointer_cast derived->base
auto pointer2 = std::static_pointer_cast<base>(derivedobj);
// dynamic_pointer_cast base->derived
auto pointer3 = std::dynamic_pointer_cast<derived>(pointer1);
std::cout << (pointer3 == nullptr) << std::endl;
// dynamic_pointer_cast base->derived
auto pointer4 = std::dynamic_pointer_cast<test>(pointer1);
std::cout << (pointer4 == nullptr) << std::endl;
return 0;
}
Output result:
false
true
std::reinterpret_pointer_cast()和std::const_pointer_cast()示例:
#include <memory>
#include <cassert>
#include <cstdint>
int main()
{
std::shared_ptr<int> foo;
std::shared_ptr<const int> bar;
foo = std::make_shared<int>(10);
bar = std::const_pointer_cast<const int>(foo);
std::cout << "*bar: " << *bar << std::endl;
*foo = 20;
std::cout << "*bar: " << *bar << std::endl;
std::shared_ptr<std::int8_t[]> p(new std::int8_t[4]{1, 1, 1, 1});
std::shared_ptr<std::int32_t[]> q = std::reinterpret_pointer_cast<std::int32_t[]>(p);
std::int32_t r = q[0];
std::int32_t x = (1 << 8) | (1 << 16) | (1 << 24) | 1;
assert(r == x);
return 0;
}
Output:
*bar: 10
*bar: 20
Press <RETURN> to close this window...