Pointeur intelligent

Soyez le premier à donner votre avis sur cette source.

Vue 4 367 fois - Téléchargée 172 fois

Description

Bonjour à tous.

Voici une classe permettant de gérer un pointeur un peu plus intelligemment, afin d'éviter une fuite mémoire en oubliant un "delete".
Ceci est mon premier code source partagé. Alors je suis preneur de toutes remarques sur la manière de commenter le code ou sur le code lui-même.
D'avance merci :)

Source / Exemple :


// ======================================================================= //
// Fichier:     Pointer.h                                                  //
// Description: Template permettant d'éviter une fuite mémoire             //
// Création:    25 juillet 2010                                            //
// Version:     1.0.0.1                                                    //
// ======================================================================= //

#ifndef POINTEUR_H
#define POINTEUR_H

// ======================================================================= //
// Fichiers include                                                        //
// ======================================================================= //
#include <cstddef>

// ======================================================================= //
// Template Pointeur : Template pour gèrer un pointeur sur un objet        //
// ======================================================================= //
template <class C> class Pointeur
{
private:
   void* operator new (size_t) { return 0; }
   void  operator delete (void *) { }

public:
   /* Constructeurs et destructeur */
   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; }
   void operator  ~()
      {
      delete _pData;
      _pData = 0;
      }

   /* Définition des opérateurs d'affectation */
   C* operator = (C* src)
      {
      delete _pData;
      _pData = src;
      return _pData;
      }
   C* operator = (C src)
      {
      /* Vérification de l'existence d'un pointeur afin d'éviter de faire une 
         suppression et une création à chaque modification de valeur. */
      if (!_pData)
         _pData = new C ();

  • _pData = src;
return _pData; } C* operator = (Pointeur<C>& src) { delete _pData; _pData = src._pData; src._pData = 0; return _pData; } /* Fonction permettant de vérifier si le pointeur est null */ bool DataIsNull () const { return _pData == 0; } /* Définition des opérateurs de comparaison */ 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); } /* Définition des opérateurs de lecture */ 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: /* Pointeur sur la donnée */ C *_pData; }; #endif /* POINTEUR_H */

Conclusion :


Exemple d'utilisation:
-----------------------
#include <stdio.h>
#include <string.h>
#include "pointer.h"

int main(int argc, char* argv[])
{
Pointeur<int> var1; /* Création d'un pointeur null */
Pointeur<int> var2 (14); /* Création d'un pointeur avec la valeur 14 */
Pointeur<int> var3;

/* Assignation de la valeur 15. */
/* Comme le pointeur est null, un nouveau pointeur est créé automatiquement. */
var3 = 15;

/* Comparaison des valeurs de deux pointeurs */
/* Si différents, On transfert l'adresse du pointeur var3 dans var1; */
if (var3 != var2)
var1 = var3;

/* Vérification si le pointeur est null */
/* et assignation d'une nouvelle valeur à un pointeur existant */
if (var3.DataIsNull ())
var3 = *var2 + *var1;

return 0;
}

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
79
Date d'inscription
lundi 23 décembre 2002
Statut
Membre
Dernière intervention
1 mars 2011

Salut a toi,

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)
Messages postés
6535
Date d'inscription
lundi 16 décembre 2002
Statut
Modérateur
Dernière intervention
22 août 2010
7
Quel intérêt d'utiliser un Pointeur<T> plutot qu'un T directement?
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.
Messages postés
1
Date d'inscription
samedi 24 juillet 2010
Statut
Membre
Dernière intervention
28 juillet 2010

Salut!
Un grand merci pour ces remarques, j'en prends bonne note.
Je vais retravailler mes sources avec toutes ses infos.
Encore merci :)
Messages postés
3819
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
28 septembre 2020
113
Quelques remarques:
* 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_ */

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.