Pointeur intelligent

Télécharger le projet
Commenter

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;
}
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

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.