Yuni::SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP > Class Template Reference

Smart Pointer. More...

#include <smartptr.h>

Inheritance diagram for Yuni::SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP >:

Collaboration diagram for Yuni::SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP >:

Classes
struct	AutomaticConversion
	Empty class to allow if (mySmartPtr) ... More...
struct	DynamicCastArg
class	Promote
	Class Helper to determine the most suitable smart pointer for a class according the current threading policy. More...

Public Types
typedef Static::If< ConversionPolicy::allow, const StoredType &, NeverMatched >::ResultType	ImplicitStoredType
	Implicit - Conversions are allowed.
typedef Static::If<!ConversionPolicy::allow, const StoredType &, NeverMatched >::ResultType	ExplicitStoredType
	Explicit - Conversions are not allowed.
Type alias
typedef T	Type
	Original type.
typedef StorP< T >	StoragePolicy
	The Storage policy.
typedef OwspP< typename StorP< T >::PointerType >	OwnershipPolicy
	The Ownership policy.
typedef ConvP	ConversionPolicy
	The conversion policy.
typedef ChckP< typename StorP< T >::StoredType >	CheckingPolicy
	The checking policy.
typedef ConsP< T >	ConstnessPolicy
	The Constness policy.
typedef StoragePolicy::PointerType	PointerType
	the Pointer type
typedef StoragePolicy::StoredType	StoredType
	The Stored type.
typedef StoragePolicy::ReferenceType	ReferenceType
	The Reference type.
typedef ConstnessPolicy::Type *	ConstPointerType
	The Pointer type (const)
typedef ConstnessPolicy::Type &	ConstReferenceType
	The Reference type (const)
typedef SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP >	SmartPtrType
	Alias to itself.
typedef SmartPtr< T, OwspP, ChckP, ConvP, StorP, Policy::Constness::PropagateConst >	ConstSmartPtrType
	A smart pointer with a const pointer.
typedef SmartPtr< T, OwspP, ChckP, ConvP, StorP, Policy::Constness::DontPropagateConst >	NonConstSmartPtrType
	A smart pointer with a non-const pointer.
typedef Static::If< OwnershipPolicy::destructiveCopy, SmartPtrType, const SmartPtrType >::ResultType	CopyType
	The Type to use for the copy constructor.
typedef std::vector< SmartPtrType >	Vector
	Vector.
typedef std::list< SmartPtrType >	List
	List.

Public Member Functions
template<typename T1 , template< class > class OwspP1, template< class > class ChckP1, class ConvP1 , template< class > class StorP1, template< class > class ConsP1>
	SmartPtr (const SmartPtr< T1, OwspP1, ChckP1, ConvP1, StorP1, ConsP1 > &rhs, const DynamicCastArg &)
	Copy constructor with Dynamic casting.
template<typename T1 , template< class > class OwspP1, template< class > class ChckP1, class ConvP1 , template< class > class StorP1, template< class > class ConsP1>
	SmartPtr (SmartPtr< T1, OwspP1, ChckP1, ConvP1, StorP1, ConsP1 > &rhs, const DynamicCastArg &)
	Copy constructor with Dynamic casting.
template<typename T , template< class > class OwspP, template< class > class ChckP, class ConvP , template< class > class StorP, template< class > class ConsP>
	SmartPtr (typename SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP >::ExplicitStoredType ptr)
template<typename T , template< class > class OwspP, template< class > class ChckP, class ConvP , template< class > class StorP, template< class > class ConsP>
	SmartPtr (typename SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP >::CopyType &rhs)
template<typename T1 , template< class > class OwspP1, template< class > class ChckP1, class ConvP1 , template< class > class StorP1, template< class > class ConsP1>
	SmartPtr (SmartPtr< T1, OwspP1, ChckP1, ConvP1, StorP1, ConsP1 > &rhs, const typename SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP >::DynamicCastArg &)
template<typename T , template< class > class OwspP, template< class > class ChckP, class ConvP , template< class > class StorP, template< class > class ConsP>
SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP > &	operator= (typename SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP >::CopyType &rhs)
template<typename T1 , template< class > class OwspP1, template< class > class ChckP1, class ConvP1 , template< class > class StorP1, template< class > class ConsP1>
SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP > &	operator= (const SmartPtr< T1, OwspP1, ChckP1, ConvP1, StorP1, ConsP1 > &rhs)
template<typename T1 , template< class > class OwspP1, template< class > class ChckP1, class ConvP1 , template< class > class StorP1, template< class > class ConsP1>
SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP > &	operator= (SmartPtr< T1, OwspP1, ChckP1, ConvP1, StorP1, ConsP1 > &rhs)
Constructors & Destructor
	SmartPtr ()
	Default constructor.
	SmartPtr (ExplicitStoredType ptr)
	Constructor with a given pointer, when implicit types are not allowed.
	SmartPtr (ImplicitStoredType ptr)
	Constructor with a given pointer, when implicit types are allowed.
	SmartPtr (const NullPtr &)
	Constructor with a null pointer.
	SmartPtr (CopyType &rhs)
	Copy constructor.
template<typename T1 , template< class > class OwspP1, template< class > class ChckP1, class ConvP1 , template< class > class StorP1, template< class > class ConsP1>
	SmartPtr (const SmartPtr< T1, OwspP1, ChckP1, ConvP1, StorP1, ConsP1 > &rhs)
	Copy constructor.
template<typename T1 , template< class > class OwspP1, template< class > class ChckP1, class ConvP1 , template< class > class StorP1, template< class > class ConsP1>
	SmartPtr (SmartPtr< T1, OwspP1, ChckP1, ConvP1, StorP1, ConsP1 > &rhs)
	Copy constructor.
	SmartPtr (Static::MoveConstructor< SmartPtrType > rhs)
	Move Constructor.
	~SmartPtr ()
	Destructor.
Swap
void	swap (SmartPtr &rhs)
	Swap from another smartptr.
Pointer
PointerType	pointer ()
	Get a pointer to the object, like operator -> would do.
ConstPointerType	pointer () const
	Get a pointer to the object, like operator -> would do.
Operator * / ->
PointerType	operator-> ()
ConstPointerType	operator-> () const
ReferenceType	operator* ()
ConstReferenceType	operator* () const
Operator =
SmartPtr &	operator= (CopyType &rhs)
	Copy.
SmartPtr &	operator= (const NullPtr &)
	Reset.
template<typename T1 , template< class > class OwspP1, template< class > class ChckP1, class ConvP1 , template< class > class StorP1, template< class > class ConsP1>
SmartPtr &	operator= (const SmartPtr< T1, OwspP1, ChckP1, ConvP1, StorP1, ConsP1 > &rhs)
	Copy from another smartptr.
template<typename T1 , template< class > class OwspP1, template< class > class ChckP1, class ConvP1 , template< class > class StorP1, template< class > class ConsP1>
SmartPtr &	operator= (SmartPtr< T1, OwspP1, ChckP1, ConvP1, StorP1, ConsP1 > &rhs)
	Copy from another smartptr.
Comparisons
bool	operator! () const
	Operator ! (to enable if (!mysmartptr) ...)
bool	operator== (const NullPtr &) const
	operator ==
bool	operator!= (const NullPtr &) const
	operator !=
template<typename T1 , template< class > class OwspP1, template< class > class ChckP1, class ConvP1 , template< class > class StorP1, template< class > class ConsP1>
bool	operator== (const SmartPtr< T1, OwspP1, ChckP1, ConvP1, StorP1, ConsP1 > &rhs) const
	operator ==
bool	operator== (const T *rhs) const
	operator ==
template<typename T1 , template< class > class OwspP1, template< class > class ChckP1, class ConvP1 , template< class > class StorP1, template< class > class ConsP1>
bool	operator!= (const SmartPtr< T1, OwspP1, ChckP1, ConvP1, StorP1, ConsP1 > &rhs) const
	Operator !=
bool	operator!= (const T *rhs) const
	Operator !=
template<typename T1 , template< class > class OwspP1, template< class > class ChckP1, class ConvP1 , template< class > class StorP1, template< class > class ConsP1>
bool	operator< (const SmartPtr< T1, OwspP1, ChckP1, ConvP1, StorP1, ConsP1 > &rhs) const
	Operator <
template<typename T1 , template< class > class OwspP1, template< class > class ChckP1, class ConvP1 , template< class > class StorP1, template< class > class ConsP1>
bool	operator> (const SmartPtr< T1, OwspP1, ChckP1, ConvP1, StorP1, ConsP1 > &rhs) const
	Operator >
template<typename T1 , template< class > class OwspP1, template< class > class ChckP1, class ConvP1 , template< class > class StorP1, template< class > class ConsP1>
bool	operator<= (const SmartPtr< T1, OwspP1, ChckP1, ConvP1, StorP1, ConsP1 > &rhs) const
	Operator <=
template<typename T1 , template< class > class OwspP1, template< class > class ChckP1, class ConvP1 , template< class > class StorP1, template< class > class ConsP1>
bool	operator>= (const SmartPtr< T1, OwspP1, ChckP1, ConvP1, StorP1, ConsP1 > &rhs) const
	Operator >=
Cast-Operator
	operator Static::MoveConstructor< SmartPtr > ()
	Cast-Operator.
	operator AutomaticConversion * () const
	Cast-Operator for if (mySmartPtr) ...

Static Public Member Functions
static const T *	WeakPointer (const SmartPtr &ptr)
	Get the internal stored pointer (weak pointer) by the smart pointer (const) More...
static T *	WeakPointer (SmartPtr &ptr)
	Get the internal stored pointer (weak pointer) by the smart pointer. More...
static const T *	WeakPointer (const T *wptr)
	Get the internal stored pointer (weak pointer) by the smart pointer (identity) (const) More...
static T *	WeakPointer (T *wptr)
	Get the internal stored pointer (weak pointer) by the smart pointer (identity) More...
template<class S1 >
static S1	DynamicCast (SmartPtr p)
	Perform a dynamic_cast on a smartptr. More...

Detailed Description

template<class T, template< class > class OwspP = Policy::Ownership::ReferenceCountedMT, template< class > class ChckP = Policy::Checking::None, class ConvP = Policy::Conversion::Allow, template< class > class StorP = Policy::Storage::Pointer, template< class > class ConsP = Policy::Constness::DontPropagateConst>
class Yuni::SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP >

Smart Pointer.

Smart pointers are abstract data type classes to simplify the memory management, especially in a multithreaded context. They simulate a pointer. They behave much like built-in C++ pointers except that they automatically delete the object pointed to at the appropriate time (automatic garbage collection), and can provide additional bounds checking.

here is a simple example :

#include <iostream>
#include <yuni/core/smartptr.h>

struct Foo
{
    Foo(int v) : value(v) {}
    int value;
};

int main(void)
{
    SmartPtr<Foo> ptr;

    // Allocating a new `Foo` instance
    ptr = new Foo(42);

    // Displaying its value, like if it were a standard pointer
    if (ptr)
        std::cout << "Value : " << ptr->value << std::endl;

    // The instance will automatically be deleted when no needed
    return 0;
}

Here is a more complex example, dealing with inheritance :

#include <iostream>
#include <yuni/core/smartptr.h>


struct Foo
{
    Foo()
        :pValue(0)
    {
        std::cout << (void*)this << " Constructor" << std::endl;
    }
    Foo(const int v)
        :pValue(v)
    {
        std::cout << (void*)this << " Constructor, value = " << pValue << std::endl;
    }
    virtual ~Foo()
    {
        std::cout << (void*)this << " Destructor, value = " << pValue << std::endl;
    }

    virtual void print() const {std::cout << "Foo : " << pValue << std::endl;}

protected:
    int pValue;
};

struct Bar : public Foo
{
public:
    Bar() {}
    Bar(const int v)
        :Foo(v)
    {}
    virtual Bar() {}

    virtual void print() const {std::cout << "Bar : " << pValue << std::endl;}
};

int main(void)
{
    Yuni::SmartPtr<Foo>  p1(new Foo(42));
    Yuni::SmartPtr<Bar>  p2(new Bar(72));

    // The original pointer stored by p1 will no longer be needed anymore
    // and will be destroyed
    // For obvious reasons, we can not assign p2 to p1 (`Foo` is a superclass of `Bar`)
    p1 = p2;

    // Print the values, p1 and p2 have the same pointer actually
    p1->print(); // 72
    p2->print(); // 72

    // The original pointer stored in p2 will be destroyed here
    return 0;
}

Note

This smart pointer is thread-safe by default. If you do not need a locking mechanism, you should change the ownership policy.

Warning

Do not use SmartPtr with stack variables !

#include <iostream>
#include <yuni/core/smartptr.h>

struct Foo
{
    int bar;
};

void doSomething(SmartPtr<Foo> p)
{
    std::cout << p->bar << std::endl; // Displays 42

    // The pointer owned by `p` will be deleted at the end of the function
}

int main()
{
    Foo foo;
    foo.bar = 42;
    doSomething(&foo);

    // Foo will be also deleted here
    return 0;
}

Template Parameters

T	The type
OwspP	The ownership policy
ChckP	The Checking policy
ConvP	The Conversion policy
StorP	The Storage policy
ConsP	The Constness policy

Member Function Documentation

DynamicCast()

template<typename T , template< class > class OwspP, template< class > class ChckP, class ConvP , template< class > class StorP, template< class > class ConsP>

template<class S1 >

S1 Yuni::SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP >::DynamicCast ( SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP >  p )

inlinestatic

Perform a dynamic_cast on a smartptr.

Assuming the class B is a descendant of the class A

A::Ptr a = new B();

B::Ptr = A::Ptr::DynamicCast<B::Ptr>(a);

WeakPointer() [1/4]

template<typename T , template< class > class OwspP, template< class > class ChckP, class ConvP , template< class > class StorP, template< class > class ConsP>

const T * Yuni::SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP >::WeakPointer ( const SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP > &  ptr )

inlinestatic

Get the internal stored pointer (weak pointer) by the smart pointer (const)

Note

This method should be used with care, especially in a multithreaded world

Parameters

ptr	The smart pointer

Returns

The internal stored pointer (can be null)

WeakPointer() [2/4]

template<typename T , template< class > class OwspP, template< class > class ChckP, class ConvP , template< class > class StorP, template< class > class ConsP>

T * Yuni::SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP >::WeakPointer ( SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP > &  ptr )

inlinestatic

Get the internal stored pointer (weak pointer) by the smart pointer.

Note

This method should be used with care, especially in a multithreaded world

Parameters

ptr	The smart pointer

Returns

The internal stored pointer (can be null)

WeakPointer() [3/4]

template<typename T, template< class > class OwspP, template< class > class ChckP, class ConvP , template< class > class StorP, template< class > class ConsP>

const T * Yuni::SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP >::WeakPointer ( const T *  wptr )

inlinestatic

Get the internal stored pointer (weak pointer) by the smart pointer (identity) (const)

Note

This method exists to avoid some common mistakes when mixing smartptr and raw pointers

Parameters

wptr	The pointer

Returns

The pointer wptr given in input

WeakPointer() [4/4]

template<typename T, template< class > class OwspP, template< class > class ChckP, class ConvP , template< class > class StorP, template< class > class ConsP>

T * Yuni::SmartPtr< T, OwspP, ChckP, ConvP, StorP, ConsP >::WeakPointer ( T *  wptr )

inlinestatic

Get the internal stored pointer (weak pointer) by the smart pointer (identity)

Note

This method exists to avoid some common mistakes when mixing smartptr and raw pointers

Parameters

wptr	The pointer

Returns

The pointer wptr given in input

---

The documentation for this class was generated from the following files:

• src/yuni/core/smartptr/smartptr.h
• src/yuni/core/smartptr/smartptr.hxx