Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1874 connectés 

  FORUM HardWare.fr
  Programmation
  C++

  Ma class de pointeurs intelligents

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

Ma class de pointeurs intelligents

n°1485651
vincent0
Posté le 03-12-2006 à 16:47:54  profilanswer
 

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
mood
Publicité
Posté le 03-12-2006 à 16:47:54  profilanswer
 

n°1485662
slash33
Posté le 03-12-2006 à 17:12:01  profilanswer
 

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
n°1485684
vincent0
Posté le 03-12-2006 à 17:41:33  profilanswer
 

- "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
n°1485745
slash33
Posté le 03-12-2006 à 20:28:50  profilanswer
 

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. }

n°1485752
bjone
Insert booze to continue
Posté le 03-12-2006 à 20:55:47  profilanswer
 

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.

n°1485812
vincent0
Posté le 03-12-2006 à 22:37:47  profilanswer
 

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;

n°1485815
bjone
Insert booze to continue
Posté le 03-12-2006 à 22:40:37  profilanswer
 

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

Message cité 1 fois
n°1485818
vincent0
Posté le 03-12-2006 à 23:22:30  profilanswer
 

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
n°1486315
tbp
Posté le 04-12-2006 à 19:28:56  profilanswer
 

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.

n°1486329
_darkalt3_
Proctopathe
Posté le 04-12-2006 à 19:47:50  profilanswer
 

[:drapal]


---------------
Töp of the plöp
mood
Publicité
Posté le 04-12-2006 à 19:47:50  profilanswer
 

n°1486340
vincent0
Posté le 04-12-2006 à 20:00:16  profilanswer
 

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
n°1486346
tbp
Posté le 04-12-2006 à 20:08:09  profilanswer
 

/o\


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C++

  Ma class de pointeurs intelligents

 

Sujets relatifs
CSS : class ou idPetit tuto sur les class
Question sur les pointeurs...[Madame Bellepaire, Loches]Class et MVC
Fonction vs Class[Résolut][hibernate] ."CLASS": invalid identifier
Lancement de class MainSavoir la version d'un .class
[C Sharp/Résolu] mémoire et sauts pointeurs: la chasse au gaspipetit problème avec les pointeurs
Plus de sujets relatifs à : Ma class de pointeurs intelligents

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.120 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR