DGtal::CountedPtr< T > Class Template Reference

Aim: Smart pointer based on reference counts. More...

#include <DGtal/base/CountedPtr.h>

Inheritance diagram for DGtal::CountedPtr< T >:

Data Structures
struct	Counter

Public Member Functions
	CountedPtr (T *p=0)
	~CountedPtr ()
	CountedPtr (const CountedPtr &r) noexcept
CountedPtr &	operator= (const CountedPtr &r)
T &	operator* () const noexcept
T *	operator-> () const noexcept
T *	get () const noexcept
bool	unique () const noexcept
bool	operator== (const T *other) const
bool	operator!= (const T *other) const
unsigned int	count () const
T *	drop ()
void	selfDisplay (std::ostream &out) const
bool	isValid () const

Private Member Functions
void	acquire (Counter *c) noexcept
void	release ()

Private Attributes
Counter *	myCounter
	The counter object pointed by this smart pointer. More...

Friends
class	CountedPtrOrPtr< T >
	Friend class which needs to access to CountedPtr.myCounter. More...
class	CountedConstPtrOrConstPtr< T >
	Friend class which needs to access to CountedPtr.myCounter. More...

Detailed Description

template<typename T>
class DGtal::CountedPtr< T >

Aim: Smart pointer based on reference counts.

Description of template class 'CountedPtr'

It is a standard smart pointer by reference counts. Of course, only dynamically allocated objects may be pointed by a smart pointer. The CountedPtr<T> holds a pointer to a CountedPtr::Counter object. This Counter object holds the pointer to the dynamically allocated object and an integer representing the number of smart pointers currently pointing to this Counter.

struct A{};
CountedPtr<A> smart_p1( new A );
CountedPtr<A> smart_p2( new A );
smart_p2 = smart_p1;  // second object is freed, first object is now shared.

Template Parameters

T	any data type.

Taken from http://ootips.org/yonat/4dev/smart-pointers.html

Definition at line 79 of file CountedPtr.h.

Constructor & Destructor Documentation

CountedPtr() [1/2]

template<typename T >

DGtal::CountedPtr< T >::CountedPtr ( T *  p = 0 )

inlineexplicit

Default Constructor and constructor from pointer.

Creates a new CountedPtr, either null if p is 0 or pointing to the given address p.

Parameters

p	either 0 or a pointer on a dynamically allocated object of type T.

Definition at line 119 of file CountedPtr.h.

                                  : myCounter(0) 
    { 
      if (p) myCounter = new Counter(p);
    }

References DGtal::CountedPtr< T >::myCounter.

~CountedPtr()

template<typename T >

DGtal::CountedPtr< T >::~CountedPtr ( )

inline

Destructor. If it was the last CountedPtr pointing on the object, delete it.

Definition at line 128 of file CountedPtr.h.

    { 
      release(); 
    }

References DGtal::CountedPtr< T >::release().

CountedPtr() [2/2]

template<typename T >

DGtal::CountedPtr< T >::CountedPtr ( const CountedPtr< T > &  r )

inlinenoexcept

Copy Constructor.

Performs a smart copy. The CountedPtr only references the same object as r. There is now one more reference on the same object.

Parameters

r	the object to copy.

Definition at line 142 of file CountedPtr.h.

    {
      acquire(r.myCounter);
    }

References DGtal::CountedPtr< T >::acquire().

Member Function Documentation

acquire()

template<typename T >

void DGtal::CountedPtr< T >::acquire ( Counter *  c )

inlineprivatenoexcept

Tells this smart pointer that it should reference the counter c. If c is not null, the number of reference counts is incremented.

Parameters

c	any counter (except this.myCounter).

Definition at line 265 of file CountedPtr.h.

    { // increment the count
        myCounter = c;
        if (c) ++c->count;
    }

References DGtal::CountedPtr< T >::Counter::count, and DGtal::CountedPtr< T >::myCounter.

Referenced by DGtal::CountedPtr< T >::CountedPtr(), and DGtal::CountedPtr< T >::operator=().

count()

template<typename T >

unsigned int DGtal::CountedPtr< T >::count ( ) const

inline

Note

For debug.

Returns

the number of smart pointers pointing to the same object as 'this'.

Definition at line 236 of file CountedPtr.h.

    {
      return myCounter->count;
    }

References DGtal::CountedPtr< T >::Counter::count, and DGtal::CountedPtr< T >::myCounter.

Referenced by testCountedConstPtrOrConstPtrMemory(), testCountedPtrMemory(), and testCountedPtrOrPtrMemory().

drop()

template<typename T >

T* DGtal::CountedPtr< T >::drop ( )

inline

Gives back the pointer without deleting him. Deletes only the Counter.

Returns

the address that was pointed by this smart pointer

Note

Use with care.

Precondition

'isValid()' and 'unique()'.

Definition at line 249 of file CountedPtr.h.

    { 
      ASSERT( isValid() );
      ASSERT( unique() );
      T* tmp = myCounter->ptr;
      delete myCounter;
      myCounter = 0; 
      return tmp;
    }

References DGtal::CountedPtr< T >::isValid(), DGtal::CountedPtr< T >::myCounter, DGtal::CountedPtr< T >::Counter::ptr, and DGtal::CountedPtr< T >::unique().

get()

template<typename T >

T* DGtal::CountedPtr< T >::get ( ) const

inlinenoexcept

Secured member access operator.

Returns

a pointer on the object that is pointed by the smart pointer or 0 if the object is not valid ('isValid()' is false).

Definition at line 195 of file CountedPtr.h.

    {
      return myCounter ? myCounter->ptr : 0;
    }

References DGtal::CountedPtr< T >::myCounter, and DGtal::CountedPtr< T >::Counter::ptr.

Referenced by DGtal::CountedPtr< T >::operator!=(), DGtal::GraphVisitorRange< TGraphVisitor >::GenericConstIterator< TAccessor >::operator*(), DGtal::GraphVisitorRange< TGraphVisitor >::GenericConstIterator< TAccessor >::operator->(), DGtal::GraphVisitorRange< TGraphVisitor >::GenericConstIterator< TAccessor >::operator==(), DGtal::CountedPtr< T >::operator==(), testCountedConstPtrOrConstPtrMemory(), testCountedPtrMemory(), and testCountedPtrOrPtrMemory().

isValid()

template<typename T >

bool DGtal::CountedPtr< T >::isValid

(

)

const

Checks the validity/consistency of the object.

Returns

'true' if the object is valid, 'false' otherwise.

Referenced by DGtal::CountedPtr< T >::drop().

operator!=()

template<typename T >

bool DGtal::CountedPtr< T >::operator!= ( const T *  other ) const

inline

Inequality operator !=

Parameters

other

any other pointer.

Returns

'true' if 'this' points to a different address than other.

Definition at line 226 of file CountedPtr.h.

    {
      return get() != other;
    }

References DGtal::CountedPtr< T >::get().

operator*()

template<typename T >

T& DGtal::CountedPtr< T >::operator* ( ) const

inlinenoexcept

Dereferencing operator.

Returns

a reference on the object that is pointed by the smart pointer.

Precondition

'isValid()' is true

Definition at line 174 of file CountedPtr.h.

    {
      return *myCounter->ptr;
    }

References DGtal::CountedPtr< T >::myCounter, and DGtal::CountedPtr< T >::Counter::ptr.

operator->()

template<typename T >

T* DGtal::CountedPtr< T >::operator-> ( ) const

inlinenoexcept

Member access operator.

Returns

a pointer on the object that is pointed by the smart pointer.

Precondition

'isValid()' is true

Definition at line 184 of file CountedPtr.h.

    {
      return myCounter->ptr;
    }

References DGtal::CountedPtr< T >::myCounter, and DGtal::CountedPtr< T >::Counter::ptr.

operator=()

template<typename T >

CountedPtr& DGtal::CountedPtr< T >::operator= ( const CountedPtr< T > &  r )

inline

Assignment.

Performs a smart assignment. The current referenced object is dropped (and possibly freed if it was the last smart pointer pointing on it). Then, this CountedPtr only references the same object as r. There is now one more reference on the same object.

Parameters

r	the object to copy.

Returns

a reference on 'this'.

Definition at line 159 of file CountedPtr.h.

    {
      if (this != &r)
        {
          release();
          acquire(r.myCounter);
        }
      return *this;
    }

References DGtal::CountedPtr< T >::acquire(), and DGtal::CountedPtr< T >::release().

operator==()

template<typename T >

bool DGtal::CountedPtr< T >::operator== ( const T *  other ) const

inline

Equality operator ==

Parameters

other

any other pointer.

Returns

'true' if 'this' points to other.

Definition at line 215 of file CountedPtr.h.

    {
      return get() == other;
    }

References DGtal::CountedPtr< T >::get().

release()

template<typename T >

void DGtal::CountedPtr< T >::release ( )

inlineprivate

Tells this smart pointer to that it should release its current counter. If this counter was shared then the number of reference counts is decremented, else both the object pointed by the counter and the counter are freed. In all cases, this smart pointer becomes invalid.

Definition at line 278 of file CountedPtr.h.

    { // decrement the count, delete if it is 0
        if (myCounter) {
            if (--myCounter->count == 0) {
                delete myCounter->ptr;
                delete myCounter;
            }
            myCounter = 0;
        }
    }

References DGtal::CountedPtr< T >::Counter::count, DGtal::CountedPtr< T >::myCounter, and DGtal::CountedPtr< T >::Counter::ptr.

Referenced by DGtal::CountedPtr< T >::operator=(), and DGtal::CountedPtr< T >::~CountedPtr().

selfDisplay()

template<typename T >

void DGtal::CountedPtr< T >::selfDisplay

(

std::ostream &

out

)

const

Writes/Displays the object on an output stream.

Parameters

out	the output stream where the object is written.

unique()

template<typename T >

bool DGtal::CountedPtr< T >::unique ( ) const

inlinenoexcept

Returns

'true' iff the smart pointer is the sole one pointing on this object or if the smart pointer is invalid ('isValid()' is false).

Definition at line 204 of file CountedPtr.h.

    {
      return (myCounter ? myCounter->count == 1 : true);
    }

References DGtal::CountedPtr< T >::Counter::count, and DGtal::CountedPtr< T >::myCounter.

Referenced by DGtal::CountedPtr< T >::drop().

Friends And Related Function Documentation

CountedConstPtrOrConstPtr< T >

template<typename T >

friend class CountedConstPtrOrConstPtr< T >

friend

Friend class which needs to access to CountedPtr.myCounter.

Definition at line 330 of file CountedPtr.h.

CountedPtrOrPtr< T >

template<typename T >

friend class CountedPtrOrPtr< T >

friend

Friend class which needs to access to CountedPtr.myCounter.

Definition at line 330 of file CountedPtr.h.

Field Documentation

myCounter

template<typename T >

Counter* DGtal::CountedPtr< T >::myCounter

private

The counter object pointed by this smart pointer.

Definition at line 308 of file CountedPtr.h.

Referenced by DGtal::CountedPtr< T >::acquire(), DGtal::CountedPtr< T >::count(), DGtal::CountedPtr< T >::CountedPtr(), DGtal::CountedPtr< T >::drop(), DGtal::CountedPtr< T >::get(), DGtal::CountedPtr< T >::operator*(), DGtal::CountedPtr< T >::operator->(), DGtal::CountedPtr< T >::release(), and DGtal::CountedPtr< T >::unique().

---

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

• CountedPtr.h