Ma class de pointeurs intelligents

Ma class de pointeurs intelligents - C++ - Programmation

Marsh Posté le 03-12-2006 à 16:47:54    

Hello.
 
J'ai fait une classe de pointeur intelligent avec compteur de référence et j'aimerais bien savoir ce que vous en pensez.  

Code :
  1. struct arrayPtr{static bool array;};
  2. bool arrayPtr::array = true;
  4. struct noArrayPtr{static bool array;};
  5. bool noArrayPtr::array = false;
  7. template <class T, class Policy = noArrayPtr> class CSmartPtr
  8. {
  9. public:
  10.  //Constructors and destructor :   
  11.  CSmartPtr(void);
  12.  CSmartPtr(T *Pointer);
  13.  CSmartPtr(const CSmartPtr & );
  14.  ~CSmartPtr(void);
  16.  //Others operators on the pointers :
  17.  const CSmartPtr& operator=(const CSmartPtr & );
  18.  T* operator->(void) const;
  19.  T& operator*(void) const;
  20.  T** operator&(void) const;
  22.  //Comparison :
  23.  bool operator==(const T & ) const;
  24.  bool operator!=(const T & ) const;
  25.  bool operator!(void) const;
  27.  //Casting :
  28.  operator T*(void) const;
  29. private:
  30.  T *data;
  31.  int *ref;
  33. };
  35. //-----------------------------------------------------------------------
  36. // Constructors and destructor  
  37. //-----------------------------------------------------------------------
  38. template<class T, class Policy> inline CSmartPtr<T, Policy>::CSmartPtr(void) : data(NULL), ref(NULL)
  39. {
  40. }
  42. template<class T, class Policy> inline CSmartPtr<T, Policy>::CSmartPtr(T *pointer) : data(pointer), ref(new int(1))
  43. {
  44. }
  46. template<class T, class Policy> inline CSmartPtr<T, Policy>::CSmartPtr(const CSmartPtr &copy) : data(copy.data), ref(copy.ref)
  47. {
  48. if(ref)
  49.  (*ref)++;
  50. }
  52. template<class T, class Policy> inline CSmartPtr<T, Policy>::~CSmartPtr(void)
  53. {
  54. if(ref && (--(*ref) == 0))
  55. {
  56.  delete ref;
  57.  if(Policy::array)
  58.   delete [] data;
  59.  else
  60.   delete data;
  61. }
  62. }
  64. //-----------------------------------------------------------------------
  65. // Others operators on the pointers
  66. //-----------------------------------------------------------------------
  67. template<class T, class Policy> inline const CSmartPtr<T, Policy>& CSmartPtr<T, Policy>::operator=(const CSmartPtr &copy)
  68. {
  69. if(ref && (--(*ref) == 0))
  70. {
  71.  delete ref;
  72.  if(Policy::array)
  73.   delete [] data;
  74.  else
  75.   delete data;
  76. }
  78. data = copy.data;
  79. ref = copy.ref;
  80. if(ref)
  81.  (*ref)++;
  83. return *this;
  84. }
  86. template<class T, class Policy> inline T* CSmartPtr<T, Policy>::operator->(void) const
  87. {
  88. return data;
  89. }
  91. template<class T, class Policy> inline T& CSmartPtr<T, Policy>::operator*(void) const
  92. {
  93. return *data;
  94. }
  97. template<class T, class Policy> inline T** CSmartPtr<T, Policy>::operator&(void) const
  98. {
  99. return &data;
  100. }
  102. //-----------------------------------------------------------------------
  103. // Comparison
  104. //-----------------------------------------------------------------------
  105. template<class T, class Policy> inline bool CSmartPtr<T, Policy>::operator==(const T &other) const
  106. {
  107. return (data == other.data);
  108. }
  110. template<class T, class Policy> inline bool CSmartPtr<T, Policy>::operator!=(const T &other) const
  111. {
  112. return !(data == other.data);
  113. }
  115. template<class T, class Policy> inline bool CSmartPtr<T, Policy>::operator!(void) const
  116. {
  117. return data == 0;
  118. }
  120. //-----------------------------------------------------------------------
  121. // Casting
  122. //-----------------------------------------------------------------------
  123. template<class T, class Policy> inline CSmartPtr<T, Policy>::operator T*(void) const
  124. {
  125. return data;
  126. }


 
- Voyez-vous des erreurs ou des améliorations possible à faire ?
- Y a-t-il des choses que l'ont peut faire avec un pointeur normal et qu'ont ne peut pas faire avec ma classe ?
 
Quand je fait ceci, j'ai une erreur à la compilation, comment pourrait-je régler le problème ? :
CSmartPtr<float> pf;
CSmartPtr<int> pi2(new int);
pf = (float *)pi2;
 
En vous remerciant.


Message édité par vincent0 le 03-12-2006 à 23:20:36
Reply

Marsh Posté le 03-12-2006 à 16:47:54   

Reply

Marsh Posté le 03-12-2006 à 17:12:01    

C'est pas le principe de l'auto_ptr de la STL?
 
Je ne comprends pas le fonctionnement du compteur ref (surtout en ref* totalement maso).
 
Ca ne fait aucune distinction entre pointeur volatile, de pile et de tas, alloué ou non alloué (faire un delete sur un pointeur non alloué avec new c'est le crash assuré).
 
y en a qui vont te dire d'utiliser boost.
 
Edit: ah et puis le compteur ne distingue pas si c'est le même pointeur qu'on affecte ou un autre. Vraiment je ne comprends la logique.


Message édité par slash33 le 03-12-2006 à 17:22:48
Reply

Marsh Posté le 03-12-2006 à 17:41:33    

- "C'est pas le principe de l'auto_ptr de la STL?" Non, avec auto_ptr on ne peut avoir qu'un seul pointeur valide vers le même objet...
- "y en a qui vont te dire d'utiliser boost" Oui peut-être mais je fait surtout ça pour apprendre.
 
"ref" est un compteur qui compte le nombre de fois que l'objet est pointé.
Donc quand "ref" arrive à 0, on peut faire un delete de l'objet.
 
Exemple:
{
CSmartPtr<int> pi(new int); //ref=1 (pi pointe vers un int)
CSmartPtr<int> pi2 = pi; //ref=2 (pi et pi2 pointe vers le même int)
} //pi est detruit donc ref est décrémenté de 1, ensuite pi2 est detruit donc ref tombe à 0 et je supprime le "int".
 
Est-ce plus clair ?


Message édité par vincent0 le 03-12-2006 à 17:42:41
Reply

Marsh Posté le 03-12-2006 à 20:28:50    

Code :
  1. {
  2. CSmartPtr<int> pi(new int);
  3. int mon_int = -1234;
  4. CSmartPtr<int> pi2(&mon_int);
  6. // pi est détruit, le pointeur est libéré
  7. // pi2 est détruit, le système crash
  8. }

Reply

Marsh Posté le 03-12-2006 à 20:55:47    

en même temps boost::shared_ptr<> doit se comporter de la même manière si tu lui passes un pointeur qui pointe sur un truc temporaire.

Reply

Marsh Posté le 03-12-2006 à 22:37:47    

D'ailleur je ne pense pas que ça possible de régler ce problème !?
 
Personne ne sais comment je pourrait permettre ce genre de chose ? :
CSmartPtr<float> pf;
CSmartPtr<int> pi2(new int);
pf = (float *)pi2;

Reply

Marsh Posté le 03-12-2006 à 22:40:37    

bin c'est un peu dangeureux dans l'idée :D

Message cité 1 fois
Reply

Marsh Posté le 03-12-2006 à 23:22:30    

bjone a écrit :

bin c'est un peu dangeureux dans l'idée :D


Oui mais bon ça fonctionne quand même avec les pointeurs normals :D
 
Je vient d'éditer mon premier message en mettant la nouvelle version de ma classe CSmartPtr qui peut maintenant fonctionner avec des tableaux, qu'en pensez-vous ?:
CSmartPtr<float, arrayPtr> pi = new float[30];
CSmartPtr<float, noArrayPtr> pi2 = new float;
CSmartPtr<float> pi3 = new float;

Message cité 1 fois
Message édité par vincent0 le 03-12-2006 à 23:25:56
Reply

Marsh Posté le 04-12-2006 à 19:28:56    

vincent0 a écrit :

Oui mais bon ça fonctionne quand même avec les pointeurs normals :D


Tout dépend de ce qu'on entend par fonctionner, parce que c'est l'exemple type d'aliasing.
 
Note: un pointeur normal, des pointeurs normaux.

Reply

Marsh Posté le 04-12-2006 à 19:47:50    

[:drapal]


---------------
Töp of the plöp
Reply

Marsh Posté le 04-12-2006 à 19:47:50   

Reply

Marsh Posté le 04-12-2006 à 20:00:16    

J'ai un autre problème moins dangereux et plus important (comme ça tout le monde sera heureux ;) )
 

Code :
  1. class A
  2. {
  3. };
  5. class B : public A
  6. {
  7. };
  8. //....
  9. CSmartPtr<A> p1;
  10. CSmartPtr<B> p2 = new B;
  11. p1 = p2;


 
Comment feriez-vous pour que ce code compile et fonctionne correctement ? merci...


Message édité par vincent0 le 04-12-2006 à 20:00:53
Reply

Marsh Posté le 04-12-2006 à 20:08:09    

/o\

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed