fcppt::shared_ptr< Type, Deleter > Class Template Reference

Detailed Description

template<typename Type, typename Deleter = fcppt::default_deleter>
class fcppt::shared_ptr< Type, Deleter >

A shared pointer class that gets the deleter as a template parameter.

A shared pointer shares ownership of a single pointer with other shared pointers. How many shared pointers actually own a pointer is kept track of as a reference count. Copying shared pointers increases the count by one, while destroying shared pointers decrases the count by one. If the count reaches zero, the object that is pointed to will be destroyed.

The class is implemented using std::shared_ptr, so it will inherit most of its traits. This means that the class also uses type erasure for its deleter and internal ref count.

Template Parameters

Type	The type the shared pointer points to
Deleter	A deleter class that must be callable with a pointer to Type.

Public Types
using	impl_type = std::shared_ptr<Type>
	The type of the std::shared_ptr used to implement this class.
using	element_type = typename impl_type::element_type
	The element type, which is Type.
using	value_type = element_type
	Same as element_type.
using	pointer = element_type *
	The pointer type, same as value_type *
using	reference = std::add_lvalue_reference_t<element_type>
	The reference type, same as value_type &
using	count_type
	The reference count type.

Public Member Functions
template<typename Other >
	shared_ptr (Other *pointer)
	Constructs a shared_ptr from a compatible pointer type.
template<typename Other , typename Alloc >
	shared_ptr (Other *pointer, Alloc const &allocator)
	Constructs a shared_ptr from a compatible pointer type and allocator.
template<typename Other >
	shared_ptr (fcppt::weak_ptr< Other, Deleter > const &ref)
	Constructs a shared_ptr from a compatible weak_ptr.
	shared_ptr (shared_ptr const &)
	shared_ptr (shared_ptr &&) noexcept
template<typename Other >
	shared_ptr (fcppt::shared_ptr< Other, Deleter > const &ref)
	Constructs a shared_ptr from a compatible shared_ptr.
template<typename Other >
	shared_ptr (fcppt::shared_ptr< Other > const &ref, pointer data)
	Constructs a shared_ptr that shares ownership with another.
template<typename Other >
	shared_ptr (std::unique_ptr< Other, Deleter > &&ref)
template<typename Other >
	shared_ptr (fcppt::unique_ptr< Other, Deleter > &&ref)
	Constructs a shared_ptr from a compatible unique_ptr.
shared_ptr &	operator= (shared_ptr const &)
shared_ptr &	operator= (shared_ptr &&) noexcept
template<typename Other >
shared_ptr &	operator= (fcppt::shared_ptr< Other, Deleter > const &ref)
	Assigns a shared_ptr from a compatible shared_ptr.
template<typename Other >
shared_ptr &	operator= (fcppt::unique_ptr< Other, Deleter > &&ref)
	Assigns a shared_ptr from a compatible unique_ptr.
	~shared_ptr () noexcept
	Destroys this shared_ptr.
reference	operator* () const
	Dereferences the owned pointer.
pointer	operator-> () const
	Dereferences a member of the owned object.
pointer	get_pointer () const
	Returns a pointer to the owned object.
bool	unique () const
	Returns if this shared_ptr is the only owner of the current object.
count_type	use_count () const
	The use count.
void	swap (shared_ptr &other) noexcept
	Swaps the shared_ptr.
impl_type	std_ptr () const
	Returns the underlying std::shared_ptr object.
template<typename Other >
	shared_ptr (fcppt::detail::make_shared_wrapper< Other > &&)

Friends
template<typename Other , typename OtherDeleter >
class	shared_ptr
class	fcppt::weak_ptr< Type, Deleter >

Member Typedef Documentation

count_type

template<typename Type , typename Deleter = fcppt::default_deleter>

using fcppt::shared_ptr< Type, Deleter >::count_type

Initial value:

 
      
      long

The reference count type.

element_type

template<typename Type , typename Deleter = fcppt::default_deleter>

using fcppt::shared_ptr< Type, Deleter >::element_type = typename impl_type::element_type

The element type, which is Type.

impl_type

template<typename Type , typename Deleter = fcppt::default_deleter>

using fcppt::shared_ptr< Type, Deleter >::impl_type = std::shared_ptr<Type>

The type of the std::shared_ptr used to implement this class.

pointer

template<typename Type , typename Deleter = fcppt::default_deleter>

using fcppt::shared_ptr< Type, Deleter >::pointer = element_type *

The pointer type, same as value_type *

reference

template<typename Type , typename Deleter = fcppt::default_deleter>

using fcppt::shared_ptr< Type, Deleter >::reference = std::add_lvalue_reference_t<element_type>

The reference type, same as value_type &

value_type

template<typename Type , typename Deleter = fcppt::default_deleter>

using fcppt::shared_ptr< Type, Deleter >::value_type = element_type

Same as element_type.

Constructor & Destructor Documentation

shared_ptr() [1/10]

template<typename Type , typename Deleter = fcppt::default_deleter>

template<typename Other >

fcppt::shared_ptr< Type, Deleter >::shared_ptr ( Other * pointer )

explicit

Constructs a shared_ptr from a compatible pointer type.

Contructs a shared_ptr from pointer, taking ownership over it.

Template Parameters

Other

A type, so that Other * is implicitly convertible to Type *

Parameters

pointer

The pointer to take ownership of

shared_ptr() [2/10]

template<typename Type , typename Deleter = fcppt::default_deleter>

template<typename Other , typename Alloc >

fcppt::shared_ptr< Type, Deleter >::shared_ptr	(	Other *	pointer,
		Alloc const &	allocator )

Constructs a shared_ptr from a compatible pointer type and allocator.

Contructs a shared_ptr from pointer, taking ownership over it, also using allocator to manage the reference counts.

Template Parameters

Other	A type, so that Other * is implicitly convertible to Type *
Alloc	An allocator type

Parameters

pointer	The pointer to take ownership of
allocator	The allocator to use for reference counting

shared_ptr() [3/10]

template<typename Type , typename Deleter = fcppt::default_deleter>

template<typename Other >

fcppt::shared_ptr< Type, Deleter >::shared_ptr ( fcppt::weak_ptr< Other, Deleter > const & ref )

explicit

Constructs a shared_ptr from a compatible weak_ptr.

Constructs a shared_ptr from the weak_ptr ref. If the weak_ptr still refers to a shared_ptr, then this constructor will behave as if the copy constructor with that shared_ptr was invoked instead. Otherwise, the shared_ptr will be constructed as empty.

Template Parameters

Other

A type, so that Other * is implicitly convertible to Type *

Parameters

ref	The weak_ptr to copy from

shared_ptr() [4/10]

template<typename Type , typename Deleter = fcppt::default_deleter>

fcppt::shared_ptr< Type, Deleter >::shared_ptr

(

shared_ptr< Type, Deleter > const &

)

shared_ptr() [5/10]

template<typename Type , typename Deleter = fcppt::default_deleter>

fcppt::shared_ptr< Type, Deleter >::shared_ptr ( shared_ptr< Type, Deleter > && )

noexcept

shared_ptr() [6/10]

template<typename Type , typename Deleter = fcppt::default_deleter>

template<typename Other >

fcppt::shared_ptr< Type, Deleter >::shared_ptr ( fcppt::shared_ptr< Other, Deleter > const & ref )

explicit

Constructs a shared_ptr from a compatible shared_ptr.

Template Parameters

Other

A type, so that Other * is convertible to Type *

shared_ptr() [7/10]

template<typename Type , typename Deleter = fcppt::default_deleter>

template<typename Other >

fcppt::shared_ptr< Type, Deleter >::shared_ptr	(	fcppt::shared_ptr< Other > const &	ref,
		pointer	data )

Constructs a shared_ptr that shares ownership with another.

Constructs a shared_ptr that shares ownership with ref and stores data. This is useful for implementing dynamic_pointer_cast and so on.

Template Parameters

Other

A type, so that Other * is convertible to Type *

Parameters

ref	The shared pointer to share ownership with
data	The pointer this shared_ptr will point to

shared_ptr() [8/10]

template<typename Type , typename Deleter = fcppt::default_deleter>

template<typename Other >

fcppt::shared_ptr< Type, Deleter >::shared_ptr ( std::unique_ptr< Other, Deleter > && ref )

explicit

shared_ptr() [9/10]

template<typename Type , typename Deleter = fcppt::default_deleter>

template<typename Other >

fcppt::shared_ptr< Type, Deleter >::shared_ptr ( fcppt::unique_ptr< Other, Deleter > && ref )

explicit

Constructs a shared_ptr from a compatible unique_ptr.

Constructs a shared_ptr from the unique_ptr ref. If the unique_ptr holds a pointer, then this shared_ptr will take ownership. Otherwise, the shared_ptr will be empy.

Template Parameters

Other

A type, so that Other * is implicitly convertible to Type *

Parameters

ref	The unique_ptr to take ownership from

~shared_ptr()

template<typename Type , typename Deleter = fcppt::default_deleter>

fcppt::shared_ptr< Type, Deleter >::~shared_ptr ( )

noexcept

Destroys this shared_ptr.

If this shared_ptr is empty, nothing happens. Otherwise, the shared count will be decreased by one, possibly leading to the destruction of the object. Deletion will be done calling Deleter().

shared_ptr() [10/10]

template<typename Type , typename Deleter = fcppt::default_deleter>

template<typename Other >

fcppt::shared_ptr< Type, Deleter >::shared_ptr ( fcppt::detail::make_shared_wrapper< Other > && )

explicit

Member Function Documentation

get_pointer()

template<typename Type , typename Deleter = fcppt::default_deleter>

pointer fcppt::shared_ptr< Type, Deleter >::get_pointer ( ) const

nodiscard

Returns a pointer to the owned object.

Returns a pointer to the owned object or the null pointer if the shared_ptr is empty.

operator*()

template<typename Type , typename Deleter = fcppt::default_deleter>

reference fcppt::shared_ptr< Type, Deleter >::operator* ( ) const

nodiscard

Dereferences the owned pointer.

Returns a reference to the owned object.

Warning

The behaviour is undefined if the shared_ptr is empty.

operator->()

template<typename Type , typename Deleter = fcppt::default_deleter>

pointer fcppt::shared_ptr< Type, Deleter >::operator-> ( ) const

nodiscard

Dereferences a member of the owned object.

Returns a pointer to the owned object.

Warning

The behaviour is undefined if the shared_ptr is empty.

operator=() [1/4]

template<typename Type , typename Deleter = fcppt::default_deleter>

template<typename Other >

shared_ptr & fcppt::shared_ptr< Type, Deleter >::operator=

(

fcppt::shared_ptr< Other, Deleter > const &

ref

)

Assigns a shared_ptr from a compatible shared_ptr.

Assigns this shared_ptr from ref. In any case, the reference count of the current shared_ptr will be decreased by one, possibly leading to the destruction of the object. If ref is empty, then this shared_ptr will also be empty. Otherwise, the shared count of ref will be increased by one and this shared_ptr will also take ownership.

Template Parameters

Other

A type, so that Other * is implicitly convertible to Type *

Parameters

ref	The shared_ptr to assign from

operator=() [2/4]

template<typename Type , typename Deleter = fcppt::default_deleter>

template<typename Other >

shared_ptr & fcppt::shared_ptr< Type, Deleter >::operator=

(

fcppt::unique_ptr< Other, Deleter > &&

ref

)

Assigns a shared_ptr from a compatible unique_ptr.

Assigns this shared_ptr from ref. In any case, the reference count of the current shared_ptr will be decreased by one, possibly leading to the destruction of the object. If ref is empty, then this shared_ptr will also be empty. Otherwise, this shared_ptr will take onwerhsip of the pointer from ref.

Template Parameters

Other

A type, so that Other * is implicitly convertible to T *

Parameters

ref	The shared_ptr to assign from

operator=() [3/4]

template<typename Type , typename Deleter = fcppt::default_deleter>

shared_ptr & fcppt::shared_ptr< Type, Deleter >::operator= ( shared_ptr< Type, Deleter > && )

noexcept

operator=() [4/4]

template<typename Type , typename Deleter = fcppt::default_deleter>

shared_ptr & fcppt::shared_ptr< Type, Deleter >::operator=

(

shared_ptr< Type, Deleter > const &

)

std_ptr()

template<typename Type , typename Deleter = fcppt::default_deleter>

impl_type fcppt::shared_ptr< Type, Deleter >::std_ptr ( ) const

nodiscard

Returns the underlying std::shared_ptr object.

swap()

template<typename Type , typename Deleter = fcppt::default_deleter>

void fcppt::shared_ptr< Type, Deleter >::swap ( shared_ptr< Type, Deleter > & other )

noexcept

Swaps the shared_ptr.

Swaps the shared_ptr with other.

Parameters

other

The shared_ptr to swap with

unique()

template<typename Type , typename Deleter = fcppt::default_deleter>

bool fcppt::shared_ptr< Type, Deleter >::unique ( ) const

nodiscard

Returns if this shared_ptr is the only owner of the current object.

If the shared_ptr is empty, the behaviour is unspecified. Otherwise, true will be returned if this shared_ptr is the only shared_ptr that takes part in the ownership of the currently owned object.

use_count()

template<typename Type , typename Deleter = fcppt::default_deleter>

count_type fcppt::shared_ptr< Type, Deleter >::use_count ( ) const

nodiscard

The use count.

If this shared_ptr is empty, 0 will be returned. Otherwise, the number of shared_ptr objects owning the currently owned object will be returned.

Note

This type is long because std::shared_ptr also uses long.

Friends And Related Symbol Documentation

shared_ptr

template<typename Type , typename Deleter = fcppt::default_deleter>

template<typename Other , typename OtherDeleter >

friend class shared_ptr

friend

fcppt::weak_ptr< Type, Deleter >

template<typename Type , typename Deleter = fcppt::default_deleter>

friend class fcppt::weak_ptr< Type, Deleter >

friend