Dario Sassi
291 lines
8.9 KiB
C++
291 lines
8.9 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
||
/**
|
||
\file
|
||
\brief \ru Автоматический указатель.
|
||
\en Smart pointer. \~
|
||
|
||
*/
|
||
////////////////////////////////////////////////////////////////////////////////
|
||
|
||
#ifndef __TEMPL_POINTER_H
|
||
#define __TEMPL_POINTER_H
|
||
|
||
|
||
#include <io_define.h>
|
||
|
||
|
||
////////////////////////////////////////////////////////////////////////////////
|
||
//
|
||
// A pair of smart pointer template classes. Provides basic conversion
|
||
// operator to T*, as well as dereferencing (*), and 0-checking (!).
|
||
// These classes assume that they alone are responsible for deleting the
|
||
// object or array unless Relinquish() is called.
|
||
//
|
||
////////////////////////////////////////////////////////////////////////////////
|
||
|
||
|
||
//------------------------------------------------------------------------------
|
||
/** \brief \ru Базовый класс автоматического указателя.
|
||
\en Base class of smart pointer. \~
|
||
\details \ru Базовый класс автоматического указателя. \n
|
||
\en Base class of smart pointer. \n \~
|
||
\ingroup Base_Tools_SmartPointers
|
||
*/
|
||
// ---
|
||
template<class T>
|
||
class TPointerBase {
|
||
public:
|
||
T & operator * () const { return *P; }
|
||
operator T* () const { return P; }
|
||
|
||
int operator ! () const { return (P == c3d_null);}
|
||
T * Relinquish() {T * p = P; P = c3d_null; return p;}
|
||
|
||
T * Get() { return P; }
|
||
const T * Get() const { return P; }
|
||
|
||
protected:
|
||
TPointerBase( T * pointer ) : P(pointer) {}
|
||
TPointerBase() : P( c3d_null ) {}
|
||
protected:
|
||
T * P;
|
||
private:
|
||
void * operator new( size_t ); // prohibit use of new
|
||
void operator delete( void * p ) { ((TPointerBase<T>*)p)->P = c3d_null; }
|
||
|
||
// СМВ К15 MVS 2012
|
||
private:
|
||
TPointerBase( const TPointerBase<T> & other );
|
||
#ifdef C3D_STANDARD_CXX_11_PARTIAL
|
||
public:
|
||
TPointerBase( TPointerBase<T> && _Right ): P( _Right.P ) { _Right.P = c3d_null; }
|
||
TPointerBase<T> & operator = ( TPointerBase<T> && _Right )
|
||
{
|
||
if ( this != &_Right )
|
||
{ P = _Right.P; _Right.P = c3d_null; }
|
||
return *this;
|
||
}
|
||
#endif // C3D_STANDARD_CXX_11_PARTIAL
|
||
};
|
||
|
||
|
||
//------------------------------------------------------------------------------
|
||
/** \brief \ru Автоматический указатель на объект.
|
||
\en A smart pointer to an object. \~
|
||
\details \ru Автоматический указатель на объект.
|
||
Обеспечивает доступ через оператор "->". \n
|
||
\en A smart pointer to an object.
|
||
Provides an access by the operator "->". \n \~
|
||
\ingroup Base_Tools_SmartPointers
|
||
*/
|
||
// ---
|
||
template<class T>
|
||
class TPointer : public TPointerBase<T> {
|
||
public:
|
||
TPointer() : TPointerBase<T>() {}
|
||
TPointer( T * pointer ) : TPointerBase<T>( pointer ) {}
|
||
~TPointer()
|
||
{
|
||
delete TPointerBase<T>::P;
|
||
}
|
||
public:
|
||
TPointer<T> & operator = ( T * src )
|
||
{
|
||
if ( src != TPointerBase<T>::P )
|
||
{
|
||
delete TPointerBase<T>::P;
|
||
TPointerBase<T>::P = src;
|
||
}
|
||
return *this;
|
||
}
|
||
T * operator ->() { return TPointerBase<T>::P; } // Could throw exception if P==c3d_null
|
||
const T * operator ->() const { return TPointerBase<T>::P; } // Could throw exception if P==c3d_null
|
||
|
||
// СМВ К15 MVS 2012
|
||
#ifndef __MOBILE_VERSION__
|
||
private:
|
||
#endif // __MOBILE_VERSION__
|
||
TPointer( const TPointer<T> & other );
|
||
|
||
#ifdef C3D_STANDARD_CXX_11_PARTIAL
|
||
public:
|
||
TPointer( TPointer<T> && _Right )
|
||
: TPointerBase<T>( std::move(_Right) )
|
||
{ }
|
||
TPointer<T> & operator = ( TPointer<T> && _Right )
|
||
{
|
||
if ( this != &_Right )
|
||
{
|
||
delete TPointerBase<T>::P;
|
||
TPointerBase<T>::P = _Right.P;
|
||
_Right.P = c3d_null;
|
||
}
|
||
return *this;
|
||
}
|
||
#endif // C3D_STANDARD_CXX_11_PARTIAL
|
||
};
|
||
|
||
|
||
//------------------------------------------------------------------------------
|
||
/** \brief \ru Автоматический указатель на объект.
|
||
\en A smart pointer to an object. \~
|
||
\details \ru Автоматический указатель на объект.
|
||
Обеспечивает доступ через оператор "->".
|
||
Есть флаг владения объектом. \n
|
||
\en A smart pointer to an object.
|
||
Provides an access by the operator "->".
|
||
There is a flag of ownership of object. \n \~
|
||
\ingroup Base_Tools_SmartPointers
|
||
*/
|
||
// ---
|
||
template<class T>
|
||
class TOwnPointer : public TPointerBase<T> {
|
||
bool own; // own = false - no delete
|
||
public:
|
||
TOwnPointer() : TPointerBase<T>(), own(true) {}
|
||
TOwnPointer( T * pointer ) : TPointerBase<T>(pointer), own(true) {}
|
||
~TOwnPointer()
|
||
{
|
||
if ( own )
|
||
delete TPointerBase<T>::P;
|
||
}
|
||
public:
|
||
TOwnPointer<T> & operator = ( T * src )
|
||
{
|
||
if ( src != TPointerBase<T>::P )
|
||
{
|
||
if ( own )
|
||
delete TPointerBase<T>::P;
|
||
TPointerBase<T>::P = src;
|
||
}
|
||
return *this;
|
||
}
|
||
T * operator ->() { return TPointerBase<T>::P; } // Could throw exception if P==c3d_null
|
||
bool GetOwn() const { return own; }
|
||
void SetOwn( bool val ) { own = val; }
|
||
|
||
// СМВ К15 MVS 2012
|
||
private:
|
||
TOwnPointer( const TOwnPointer<T> & other );
|
||
TOwnPointer<T> & operator = ( const TOwnPointer<T> & _Right );
|
||
#ifdef C3D_STANDARD_CXX_11_PARTIAL
|
||
public:
|
||
TOwnPointer( TOwnPointer<T> && _Right )
|
||
: TPointerBase<T>( std::move(_Right) )
|
||
, own ( std::move(_Right.own) )
|
||
{ }
|
||
TOwnPointer<T> & operator = ( TOwnPointer<T> && _Right )
|
||
{
|
||
if ( this != &_Right )
|
||
{
|
||
if ( own )
|
||
delete TPointerBase<T>::P;
|
||
TPointerBase<T>::P = _Right.P;
|
||
own = _Right.own;
|
||
_Right.P = c3d_null;
|
||
}
|
||
return *this;
|
||
}
|
||
#endif // C3D_STANDARD_CXX_11_PARTIAL
|
||
};
|
||
|
||
|
||
//------------------------------------------------------------------------------
|
||
/** \brief \ru Автоматический указатель на массив объектов.
|
||
\en A smart pointer to an array of objects. \~
|
||
\details \ru Автоматический указатель на массив объектов.
|
||
Обеспечивает доступ к элементам массива по индексу.
|
||
Удаляет массив через delete[]. \n
|
||
\en A smart pointer to an array of objects.
|
||
Provides an access to elements of array by index.
|
||
Deletes an array by the operator delete[]. \n \~
|
||
\ingroup Base_Tools_SmartPointers
|
||
*/
|
||
// ---
|
||
template<class T>
|
||
class TAPointer : public TPointerBase<T> {
|
||
public:
|
||
TAPointer() : TPointerBase<T>() {}
|
||
TAPointer( T* array ) : TPointerBase<T>( array ) {}
|
||
~TAPointer()
|
||
{
|
||
delete[] TPointerBase<T>::P;
|
||
}
|
||
public:
|
||
TAPointer<T> & operator = ( T * src )
|
||
{
|
||
if ( src != TPointerBase<T>::P )
|
||
{
|
||
delete[] TPointerBase<T>::P;
|
||
TPointerBase<T>::P = src;
|
||
}
|
||
return *this;
|
||
}
|
||
T & operator []( size_t i ) { return TPointerBase<T>::P[i]; } // Could throw exception if P==c3d_null
|
||
|
||
// СМВ К15 MVS 2012
|
||
//private: // g++4.7 KUbuntu
|
||
TAPointer( const TAPointer<T> & other );
|
||
#ifdef C3D_STANDARD_CXX_11_PARTIAL
|
||
public:
|
||
TAPointer(TAPointer<T> && _Right)
|
||
: TPointerBase<T>( std::move(_Right) )
|
||
{ }
|
||
TAPointer<T> & operator = (TAPointer<T> && _Right)
|
||
{
|
||
if (this != &_Right)
|
||
{
|
||
delete[] TPointerBase<T>::P;
|
||
TPointerBase<T>::P = _Right.P;
|
||
_Right.P = c3d_null;
|
||
}
|
||
return *this;
|
||
}
|
||
#endif // C3D_STANDARD_CXX_11_PARTIAL
|
||
};
|
||
|
||
|
||
//------------------------------------------------------------------------------
|
||
// Obsolete, should use TAPointer<char> for char[]'s
|
||
//---
|
||
//------------------------------------------------------------------------------
|
||
/** \brief \ru Автоматический указатель на массив символов.
|
||
\en A smart pointer to an array of symbols. \~
|
||
\details \ru Автоматический указатель на массив символов. \n
|
||
\en A smart pointer to an array of symbols. \n \~
|
||
\warning \ru Устаревший класс, пользуйтесь TAPointer<char>
|
||
\en This class is out-of-date, use TAPointer<char> \~
|
||
\ingroup Base_Tools_SmartPointers
|
||
*/
|
||
// ---
|
||
template <>
|
||
class TPointer<char> : public TPointerBase<char> {
|
||
public:
|
||
TPointer() : TPointerBase<char>() {}
|
||
TPointer( char pointer[] ) : TPointerBase<char>( pointer ) {}
|
||
~TPointer() { delete[] P; }
|
||
public:
|
||
char * operator = ( char src[] ) { delete[] P; return P = src; }
|
||
char * operator = ( const TPointer<char> & src ) { delete[] P; return P = src.P; }
|
||
char & operator []( size_t i ) { return P[i]; }
|
||
#ifdef C3D_STANDARD_CXX_11_PARTIAL
|
||
public:
|
||
TPointer( TPointer<char> && _Right )
|
||
: TPointerBase<char>( std::move(_Right) )
|
||
{ }
|
||
TPointer<char> & operator = ( TPointer<char> && _Right )
|
||
{
|
||
if ( this != &_Right )
|
||
{
|
||
delete[] P;
|
||
P = _Right.P;
|
||
_Right.P = c3d_null;
|
||
}
|
||
return *this;
|
||
}
|
||
#endif // C3D_STANDARD_CXX_11_PARTIAL
|
||
};
|
||
|
||
|
||
#endif // __TEMPL_POINTER_H
|