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

From cppreference.com

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros(C++20)
Language support library
Concepts library(C++20)
Diagnostics library
Memory management library
Metaprogramming library(C++11)
General utilities library
Containers library
Iterators library
Ranges library(C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library(C++17)
Concurrency support library(C++11)
Execution control library(C++26)
Technical specifications
Symbols index
External libraries

[edit]

Memory management library

voidify

(exposition only*)

Allocators

allocator
allocator_traits (C++11)
allocation_result (C++23)
scoped_allocator_adaptor (C++11)
pmr::polymorphic_allocator (C++17)

allocator_arg (C++11)
uses_allocator (C++11)
uses_allocator_construction_args (C++20)
make_obj_using_allocator (C++20)
uninitialized_construct_using_allocator (C++20)

Uninitialized memory algorithms

uninitialized_copy
uninitialized_fill
uninitialized_move (C++17)
uninitialized_copy_n (C++11)
uninitialized_fill_n
uninitialized_move_n (C++17)
construct_at (C++20)

uninitialized_default_construct (C++17)
uninitialized_value_construct (C++17)
destroy (C++17)
uninitialized_default_construct_n (C++17)
uninitialized_value_construct_n (C++17)
destroy_n (C++17)
destroy_at (C++17)

Constrained uninitialized memory algorithms

ranges::uninitialized_copy (C++20)
ranges::uninitialized_fill (C++20)
ranges::uninitialized_move (C++20)
ranges::uninitialized_copy_n (C++20)
ranges::uninitialized_fill_n (C++20)
ranges::uninitialized_move_n (C++20)
ranges::construct_at (C++20)

ranges::uninitialized_default_construct (C++20)
ranges::uninitialized_value_construct (C++20)
ranges::destroy (C++20)
ranges::uninitialized_default_construct_n (C++20)
ranges::uninitialized_value_construct_n (C++20)
ranges::destroy_n (C++20)
ranges::destroy_at (C++20)

Memory resources

pmr::memory_resource (C++17)
pmr::get_default_resource (C++17)
pmr::set_default_resource (C++17)
pmr::new_delete_resource (C++17)
pmr::pool_options (C++17)

pmr::null_memory_resource (C++17)
pmr::synchronized_pool_resource (C++17)
pmr::unsynchronized_pool_resource (C++17)
pmr::monotonic_buffer_resource (C++17)

Explicit lifetime management
start_lifetime_as (C++23)
start_lifetime_as_array (C++23)

Types for composite class design
indirect (C++26)
polymorphic (C++26)

Uninitialized storage(until C++20)

raw_storage_iterator (until C++20*)
get_temporary_buffer (until C++20*)

return_temporary_buffer (until C++20*)

Garbage collector support(until C++23)

declare_reachable (C++11)(until C++23)
declare_no_pointers (C++11)(until C++23)
pointer_safety (C++11)(until C++23)

undeclare_reachable (C++11)(until C++23)
undeclare_no_pointers (C++11)(until C++23)
get_pointer_safety (C++11)(until C++23)

Low level memory
management

operator newoperator new[]

operator deleteoperator delete[]

(C++11)

(C++11)

(C++17)

(C++20)

(C++17)

(C++11)

(C++11)

(C++11)

(until C++17*)

(C++11)

(C++17)

(C++26)

(C++26)

enable_shared_from_this

(C++11)

(C++11)

(C++11)

(C++23)

(C++23)

(C++11)

(C++20)

(C++11)

(C++11)

(C++20)

is_sufficiently_aligned

(C++26)

C Library

malloc
calloc
realloc

free
aligned_alloc (C++17)

[edit]

std::shared_ptr

Member functions
shared_ptr::shared_ptr
shared_ptr::~shared_ptr
shared_ptr::operator=
Modifiers
shared_ptr::reset
shared_ptr::swap
Observers
shared_ptr::get
shared_ptr::operator*shared_ptr::operator->
shared_ptr::operator[] (C++17)
shared_ptr::use_count
shared_ptr::unique (until C++20*)
shared_ptr::operator bool
shared_ptr::owner_before
shared_ptr::owner_hash (C++26)
shared_ptr::owner_equal (C++26)
Non-member functions
swap(std::shared_ptr)
make_sharedmake_shared_for_overwrite (C++20)
allocate_sharedallocate_shared_for_overwrite (C++20)
static_pointer_castdynamic_pointer_castconst_pointer_castreinterpret_pointer_cast (C++17)
get_deleter
operator==operator!=operator<operator<=operator>operator>=operator<=> (until C++20)(until C++20)(until C++20)(until C++20)(until C++20)(C++20)
operator<<
atomic_xxx functions(until C++26*)
Helper classes
atomic<std::shared_ptr> (C++20)
hash<std::shared_ptr>
Deduction guides(C++17)

[edit]

Defined in header`<memory>`
template<class T,class U> std::shared_ptr<T> static_pointer_cast(conststd::shared_ptr<U>& r)noexcept;	(1)	(since C++11)
template<class T,class U> std::shared_ptr<T> static_pointer_cast(std::shared_ptr<U>&& r)noexcept;	(2)	(since C++20)
template<class T,class U> std::shared_ptr<T> dynamic_pointer_cast(conststd::shared_ptr<U>& r)noexcept;	(3)	(since C++11)
template<class T,class U> std::shared_ptr<T> dynamic_pointer_cast(std::shared_ptr<U>&& r)noexcept;	(4)	(since C++20)
template<class T,class U> std::shared_ptr<T> const_pointer_cast(conststd::shared_ptr<U>& r)noexcept;	(5)	(since C++11)
template<class T,class U> std::shared_ptr<T> const_pointer_cast(std::shared_ptr<U>&& r)noexcept;	(6)	(since C++20)
template<class T,class U> std::shared_ptr<T> reinterpret_pointer_cast(conststd::shared_ptr<U>& r)noexcept;	(7)	(since C++17)
template<class T,class U> std::shared_ptr<T> reinterpret_pointer_cast(std::shared_ptr<U>&& r)noexcept;	(8)	(since C++20)

Creates a new instance ofstd::shared_ptr whose stored pointer is obtained fromr's stored pointer using a cast expression.

Ifr is empty, so is the newshared_ptr (but its stored pointer is not necessarily null). Otherwise, the newshared_ptr will share ownership with the initial value ofr, except that it is empty if thedynamic_cast performed bydynamic_pointer_cast returns a null pointer.

LetY betypenamestd::shared_ptr<T>::element_type, then the resultingstd::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 thedynamic_cast is a null pointer value, the returnedshared_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 fromU* toT* is well formed:

1,2) The behavior is undefined unlessstatic_cast<T*>((U*)nullptr) is well formed.

3,4) The behavior is undefined unlessdynamic_cast<T*>((U*)nullptr) is well formed.

5,6) The behavior is undefined unlessconst_cast<T*>((U*)nullptr) is well formed.

7,8) The behavior is undefined unlessreinterpret_cast<T*>((U*)nullptr) is well formed.

After calling the rvalue overloads(2,4,6,8),r is empty andr.get()== nullptr, except thatr is not modified fordynamic_pointer_cast(4) if thedynamic_cast fails.

(since C++20)

[edit]Parameters

the pointer to convert

[edit]Notes

The expressionsstd::shared_ptr<T>(static_cast<T*>(r.get())),std::shared_ptr<T>(dynamic_cast<T*>(r.get())) andstd::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!

[edit]Possible implementation

static_pointer_cast
template<class T,class U>std::shared_ptr<T> static_pointer_cast(conststd::shared_ptr<U>& r)noexcept{auto p=static_cast<typenamestd::shared_ptr<T>::element_type*>(r.get());returnstd::shared_ptr<T>{r, p};}
dynamic_pointer_cast
template<class T,class U>std::shared_ptr<T> dynamic_pointer_cast(conststd::shared_ptr<U>& r)noexcept{if(auto p=dynamic_cast<typenamestd::shared_ptr<T>::element_type*>(r.get()))returnstd::shared_ptr<T>{r, p};elsereturnstd::shared_ptr<T>{};}
const_pointer_cast
template<class T,class U>std::shared_ptr<T> const_pointer_cast(conststd::shared_ptr<U>& r)noexcept{auto p=const_cast<typenamestd::shared_ptr<T>::element_type*>(r.get());returnstd::shared_ptr<T>{r, p};}
reinterpret_pointer_cast
template<class T,class U>std::shared_ptr<T> reinterpret_pointer_cast(conststd::shared_ptr<U>& r)noexcept{auto p=reinterpret_cast<typenamestd::shared_ptr<T>::element_type*>(r.get());returnstd::shared_ptr<T>{r, p};}

[edit]Example

Run this code

#include <iostream>#include <memory> class Base{public:int a;virtualvoid 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 hierarchyauto downcastedPtr= std::dynamic_pointer_cast<Derived>(basePtr);if(downcastedPtr){std::cout<<"Downcasted pointer says: ";        downcastedPtr->f();} // All pointers to derived share ownershipstd::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