POINTEUR INTELLIGENT
cptpingu
Messages postés
3837
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
28 mars 2023
-
27 juil. 2010 à 11:57
Ilsundal Messages postés 79 Date d'inscription lundi 23 décembre 2002 Statut Membre Dernière intervention 1 mars 2011 - 27 août 2010 à 11:02
Ilsundal Messages postés 79 Date d'inscription lundi 23 décembre 2002 Statut Membre Dernière intervention 1 mars 2011 - 27 août 2010 à 11:02
Cette discussion concerne un article du site. Pour la consulter dans son contexte d'origine, cliquez sur le lien ci-dessous.
https://codes-sources.commentcamarche.net/source/52089-pointeur-intelligent
https://codes-sources.commentcamarche.net/source/52089-pointeur-intelligent
27 août 2010 à 11:02
pour commencer, on ne code pas dans les .h si tu veux faire ça, utilise des .hpp. Sinon bien peu d'interet. (PS : enleve vlc.h il sert a rien)
28 juil. 2010 à 21:07
En général j'utilise new/delete (T* donc) car l'objet n'est pas libéré à la sortie de la méthode, mais avec un Pointeur<T> je perd ce comportement.
28 juil. 2010 à 00:06
Un grand merci pour ces remarques, j'en prends bonne note.
Je vais retravailler mes sources avec toutes ses infos.
Encore merci :)
27 juil. 2010 à 11:57
* Pas besoin de stdio.h ou string.h, seul cstddef est nécessaire pour "l'opérateur new"
* Quand tu as une méthode == et une méthode !=, ne fait pas de copier coller. Ecrit l'une des deux, et inverse la condition pour l'autre.
* delete 0 n'est pas une erreur. Ça ne fera rien. Donc inutile de faire un test avant, tu peux directement faire un "delete truc" en toute sécurité.
* Différencie un attribut de classe d'une variable normale. Par convention, on met souvent un "_" devant.
* Initialise un maximum d'élément à l'aide la liste d'initialisation dans un constructeur.
* Quand tu as un "return", inutile de faire un "else". Le return est débranchant et quittera la fonction.
* Je t'ai simplifié quelques expressions.
Sinon, je n'ai pas constaté de fuite mémoire ou de bug.
#ifndef POINTER_HH_
# define POINTER_HH_
#include <cstddef>
template <class C>
class Pointeur
{
private:
void* operator new (size_t) { return 0; }
void operator delete (void*) { }
public:
Pointeur()
: _pData(0)
{
}
Pointeur(C src)
: _pData(new C(src))
{
}
Pointeur(C* src)
: _pData(src)
{
}
Pointeur(Pointeur<C>& src)
: _pData(src._pData)
{
src._pData = 0;
}
~Pointeur ()
{
delete _pData;
}
C* operator=(C* src)
{
delete _pData;
_pData = src;
return _pData;
}
C* operator=(C src)
{
delete _pData;
_pData = new C(src);
return _pData;
}
C* operator=(Pointeur<C>& src)
{
delete _pData;
_pData = src._pData;
src._pData = 0;
return _pData;
}
bool dataIsNull() const
{
return _pData == 0;
}
bool operator!=(C* src) const { return *_pData != *src; }
bool operator==(C* src) const { return !operator==(src); }
bool operator!=(C src) const { return *_pData != src; }
bool operator==(C src) const { return !operator==(src); }
bool operator==(Pointeur<C>& src) const
{
return _pData == src._pData ||
(_pData && src._pData && *_pData == *src._pData);
}
bool operator!=(Pointeur<C>& src) const
{
return !operator==(src);
}
operator const C*() const {return _pData;}
operator const C&() const {return *_pData;}
operator C*() const {return _pData;}
operator C&() const {return *_pData;}
C& operator*() const {return *_pData;}
protected:
C* _pData;
};
#endif /* !POINTER_HH_ */