Bonjour à tous,
voici mon pointeur intelligent,
cette une class qui sutilise comme un pointeur normale (ou presque) mais elle gère toute seule la suppression des allocations de mêmoire.
je l'ai consue surtout pour comprendre les templates mais je vous le pose pour voir si vous voyez
des bugs car il saurat implenté dans un projet plus gros.
Source / Exemple :
#ifndef _IPointer_H
#define _IPointer_H
#include <map>
template<class T>
class IPointer
{
public :
//destructeur
~IPointer()throw();
//constructeur par defaut
IPointer() : m_Ptrs((T*)0)
{}
//constructer par pointeur
IPointer(T* Ptr);
//constructeur par copie
IPointer(const IPointer& Ptr);
//operateur de déferencement
T& operator * ()const ;
T* operator ->()const ;
//operateur de positionnement
T operator -- (int) ;
T operator ++ (int) ;
//operateur de renvoit
operator T*() const ;
//operateur =
const IPointer& operator =(const IPointer& Ptr) ;
const IPointer& operator = (T* Ptr) ;
//echange d'addresse
void AddressSwap( IPointer& Ptr) ;
//echange de valeur
void ValueSwap( IPointer& Ptr) ;
//comparéson de valeur
bool ValueCmp(const IPointer& Ptr) ;
private:
// pointeur
T* m_Ptrs;
//map de sauvegarde addresse
typedef std::map< IPointer*,T*>mapBlock;
mapBlock Block;
};
//////////////////////////////////////
//destructeur
//
// suprime la savegarde pointeur
//////////////////////////////////////
template<class T>inline IPointer<T>::~IPointer()throw()
{
delete Block[this];
}
//////////////////////////////////////////
//constructeur par pointeur
//
// copie l'address pointé dans Block
// initialise le pointeur sur l'addresse pointé
//////////////////////////////////////////////
template<class T>inline IPointer<T>::IPointer(T* Ptr)
{
Block[this]=Ptr;
m_Ptrs=Ptr;
}
////////////////////////////////////////////////
// constructeur par copie
//
// copie l'address pointé dans Block
// initialise le pointeur sur l'addresse pointé
//////////////////////////////////////////////
template<class T>inline IPointer<T>::IPointer(const IPointer<T>& Ptr)
{
Block[this]=Ptr;
m_Ptrs=Ptr;
}
////////////////////////////////////////////
//operateur de renvoit
//
// retourne la valeur pointée
//
// throw pointeur non initialisé
//////////////////////////////////////////////
template<class T>inline T& IPointer<T>::operator * ()const
{
if(m_Ptrs!=(T*)0)
return *m_Ptrs;
throw m_Ptrs;
}
////////////////////////////////////////////////////
//opérateur d'accès
//
// renvoie pointeur constant sur la donner
//////////////////////////////////////////////////////
template<class T>inline T* IPointer<T>::operator ->()const
{
if(m_Ptrs!=(T*)0)
return m_Ptrs;
throw m_Ptrs;
}
////////////////////////////////////////////////////
//opérateur ++
//
// positionne le pointeur dans le tableau de +1
//////////////////////////////////////////////////////
template<class T>inline T IPointer<T>::operator ++ (int)
{
if(m_Ptrs!=(T*)0)
m_Ptrs++;
}
////////////////////////////////////////////////////
//opérateur --
//
// positionne le pointeur dans le tableau de -1
//////////////////////////////////////////////////////
template<class T>inline T IPointer<T>::operator -- (int)
{
if(m_Ptrs!=(T*)0)
m_Ptrs--;
}
//////////////////////////////////////////////////////
//opérateur de renvoit
//
//retourne le pointeur constant
////////////////////////////////////////////////////////
template<class T>inline IPointer<T>::operator T*() const
{
return m_Ptrs;
}
////////////////////////////////////////////////////////////////
//opérateur égale
////////////////////////////////////////////////////////////////
template<class T>inline const IPointer<T>& IPointer<T>::operator =(const IPointer<T>& Ptr)
{
Block[this]=Ptr.m_Ptrs;
m_Ptrs=Ptr.m_Ptrs;
return *this;
}
////////////////////////////////////////////////////////////////
//opérateur égale
////////////////////////////////////////////////////////////////
template<class T>inline const IPointer<T>& IPointer<T>::operator = (T* Ptr)
{
if(m_Ptrs!=Ptr)
{
Block[this]=Ptr;
m_Ptrs=Ptr;
}
return *this;
}
////////////////////////////////////////////////////////////////
//fonction AddressSwap()
//
//échange d'addresse pointé
////////////////////////////////////////////////////////////////
template<class T>inline void IPointer<T>::AddressSwap( IPointer& Ptr)
{
T* tem= m_Ptrs;
m_Ptrs= Ptr.m_Ptrs;
Ptr.m_Ptrs=tem;
}
////////////////////////////////////////////////////////////////
//fonction ValueSwap()
//
//échange de valeur pointé
////////////////////////////////////////////////////////////////
template<class T>inline void IPointer<T>::ValueSwap( IPointer& Ptr)
{
if(m_Ptrs==((T*)0)||Ptr.m_Ptrs==((T*)0))
throw(m_Ptrs,Ptr.m_Ptrs);
T tem= *m_Ptrs;
- m_Ptrs= *Ptr.m_Ptrs;
- Ptr.m_Ptrs=tem;
}
////////////////////////////////////////////////////////////////
//fonction ValueCmp
//
//Compare les valeur pointé
////////////////////////////////////////////////////////////////
template <class T>inline bool IPointer<T>::ValueCmp(const IPointer& Ptr)
{
return (*Ptr.m_Ptrs==*m_Ptrs) ? 1 : 0;
}
#endif
Conclusion :
exemple d'utilisation :
#include <IPointer>
#include <iostream>
void param(const char _cCpar);//déclaration de param (fonction pour les testes voir plus bas)
int main(int ircv,char** arcv)
{
int Y=4444;
int X=1000;
IPointer<int>Ptrs1=&Y;
IPointer<int>Ptrs2 =&X;
std::cout<<"Ptrs1 : "<<Ptrs1<<" Ptrs1 : "<<*Ptrs1<<std::endl<<"Ptrs2 : "<<Ptrs2<<" Ptrs2 : "
<<*Ptrs2<<std::endl<<std::endl;
std::cout<<"Ptrs1.AddressSwap(Ptrs2);"<<std::endl<<std::endl;
Ptrs1.AddressSwap(Ptrs2);
std::cout<<"Ptrs1 : "<<Ptrs1<<" Ptrs1 : "<<*Ptrs1<<std::endl<<"Ptrs2 : "<<Ptrs2<<" Ptrs2 : " <<*Ptrs2<<std::endl<<std::endl;
std::cout<<"Ptrs1.ValueSwap(Ptrs2);"<<std::endl<<std::endl;
Ptrs1.ValueSwap(Ptrs2);
std::cout<<"Ptrs1 : "<<Ptrs1<<" Ptrs1 : "<<*Ptrs1<<std::endl<<"Ptrs2 : "<<Ptrs2<<" Ptrs2 : "<<*Ptrs2<<std::endl;
system("pause");
}
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.