Discussion :

[Caduchon]

Bonjour à tous,

Étant actuellement à la recherche d'une bonne architecture de mon code, je me penche sur les pointeurs intelligents et en particulier, je suis tombé sur le tutoriel suivant:
http://loic-joly.developpez.com/tuto...mart-pointers/

Et là il y a un point qui me pose un gros problème: Si j'ai bien compris les exemples de la partie II-C-4, la copie du pointeur implique un clonage de l'objet pointé. Sachant que mon objet pointé peut faire plusieurs Go, c'est évidemment impensable !!!
Ne comprenant pas encore très bien le fonctionnement, je ne vois pas très bien quelle alternative je pourrais utiliser pour n'avoir jamais besoin de cloner mon objet pointé (ce qui me semble fort douteux, même pour des petites classes d'ailleurs, le principe du pointeur n'est il pas justement de focaliser plusieurs yeux sur les mêmes données ???)

Je suis tout ouvert à vos solutions éventuelles,

Caduchon.

[dragonjoker59]

En fait tout dépend du type de pointeur que tu utilises. Pour un pointeur intelligent qui a un comportement tel que tu le souhaiterais, il te faut utiliser le 'shared_ptr' qui te permet de copier le pointeur et non la donnée.
Le weak_ptr n'est pas copiable donc il ne t'intéresse pas du tout, le unique_ptr non plus du fait de sa durée de vie très éphémère.

[3DArchi]

Salut,

Étant actuellement à la recherche d'une bonne architecture de mon code, je me penche sur les pointeurs intelligents et en particulier, je suis tombé sur le tutoriel suivant:
http://loic-joly.developpez.com/tuto...mart-pointers/

Excellente initiative car c'est un tutoriel de qualité sur un problème fondamental

Et là il y a un point qui me pose un gros problème: Si j'ai bien compris les exemples de la partie II-C-4, la copie du pointeur implique un clonage de l'objet pointé.

Oui. C'est un choix dans l'exemple de la gestion de la copie du pointeur. Il existe bien d'autre choix bien sur.

Tu peux mettre en place une gestion de la copie par le partage en utilisant un compteur de référence : mais boost::shared_ptr ou std::shared_ptr (si tu as un compilo C++0x ou implémentant TR1) l'ont déjà fait pour toi, alors pas la peine de réinventer la roue.

Une autre solution est effectivement d'interdire le partage en interdisant la copie. C'est l'objectif des boost/std::unique_ptr.

Et ainsi de suite, d'autres politiques de partage peuvent être envisagées.

Tout ça pour dire que la réponse à ta question doit d'abord être de type conception : qui va gérer le pointeur, qui va y avoir accès, quand et comment. Ce sont ces réponses qui te conduiront à identifier la politique de copie que tu dois associer à ton pointeur intelligent. Et à partir de là, le choix entre unique, shared, loic, ou autre sera évident.

[Caduchon]

J'ai finalement abouti à ceci. Ca semble fonctionner, mais je ne serais pas contre un coup d'oeil d'expert pour critiquer.

smart_ptr.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
#ifndef _INCL_SMART_PTR_H__
#define _INCL_SMART_PTR_H__
 
  template <class T> class make_ptr;
 
  template <class T> class smart_ptr
  {
    public:
      smart_ptr();
      smart_ptr(const smart_ptr<T>& p);
      smart_ptr(const make_ptr<T>& mkr);
      ~smart_ptr();
      smart_ptr<T>& operator = (const smart_ptr<T>& p);
      smart_ptr<T>& operator = (const make_ptr<T>& mkr);
      template <class U> operator smart_ptr<U> ();
 
      T& operator * () const;
      T* operator -> () const;
 
    private:
      smart_ptr(T* ptr_t);
 
      T* p_;
      unsigned long int* count_;
 
    template <class> friend class smart_ptr;
    template <class> friend class make_ptr;
  };
 
  template <class T> class make_ptr
  {
    public:
      make_ptr();
      make_ptr(const T& t);
      make_ptr(const make_ptr<T>& mkr);
      ~make_ptr();
 
    private:
      smart_ptr<T>	ptr_;
 
    template <class> friend class smart_ptr;
  };
 
 
 
 
 
 
 
 
  template <class T> inline smart_ptr<T>::smart_ptr() : p_(NULL), count_(NULL)
  {}
 
  template <class T> inline smart_ptr<T>::smart_ptr(const smart_ptr<T>& ptr) : p_(ptr.p_), count_(ptr.count_)
  {
    ++(*count_);
  }
 
  template <class T> inline smart_ptr<T>::smart_ptr(const make_ptr<T>& mkr) : p_(mkr.ptr_.p_), count_(mkr.ptr_.count_)
  {
    ++(*count_);
  }
 
  template <class T> inline smart_ptr<T>::~smart_ptr()
  {
    --(*count_);
    if((*count_) == 0)
    {
      delete p_;
      delete count_;
    }
  }
 
  template <class T> inline smart_ptr<T>& smart_ptr<T>::operator = (const smart_ptr<T>& ptr)
  {
    --(*count_);
    if(*count_ == 0)
    {
      delete p_;
      delete count_;
    }
    p_ = ptr.p_;
    count_ = ptr.count_;
    ++(*count_);
    return *this;
  }
 
  template <class T> inline smart_ptr<T>& smart_ptr<T>::operator = (const make_ptr<T>& mkr)
  {
    --(*count_);
    if(*count_ == 0)
    {
      delete p_;
      delete count_;
    }
    p_ = mkr.ptr_.p_;
    count_ = mkr.ptr_.count_;
    ++(*count_);
    return *this;
  }
 
  template <class T> template <class U> inline smart_ptr<T>::operator smart_ptr<U> ()
  {
    smart_ptr<U> pU;
    pU.p_ = p_;
    pU.count_ = count_;
    ++(*count_);
    return pU;
  }
 
  template <class T> inline T& smart_ptr<T>::operator * () const
  {
    return *p_;
  }
 
  template <class T> inline T* smart_ptr<T>::operator -> () const
  {
    return p_;
  }
 
  template <class T> inline smart_ptr<T>::smart_ptr(T* ptr_t) : p_(ptr_t)
  {
    count_ = new unsigned long int(1);
  }
 
  // ----------------------------------
 
  template <class T> inline make_ptr<T>::make_ptr() : ptr_(new T)
  {}
 
  template <class T> inline make_ptr<T>::make_ptr(const T& t): ptr_(new T(t))
  {}
 
  template <class T> inline make_ptr<T>::make_ptr(const make_ptr<T>& mkr) : ptr_(mkr.ptr_)
  {}
 
  template <class T> inline make_ptr<T>::~make_ptr()
  {}
 
 
#endif

Test.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
#include <iostream>
#include "tools.h"
 
  class A
  {
    public:
      virtual ~A() {}
      virtual std::string who() const = 0;
  };
 
  class B : public A
  {
    public:
      B() {}
      virtual ~B() {}
      virtual std::string who() const { return std::string("class B"); }
  };
 
  class C : public A
  {
    public:
      C() {}
      virtual ~C() {}
      virtual std::string who() const { return std::string("class C"); }
  };
 
 
 
  smart_ptr<A> generatorB()
  {
    smart_ptr<B> p = make_ptr<B>();
    return p;
  }
 
  smart_ptr<A> generatorC()
  {
    smart_ptr<C> p = make_ptr<C>();
    return p;
  }
 
  int main()
  {
    smart_ptr<A> pB = generatorB();
    smart_ptr<A> pC = generatorC();
    std::cout << pB->who() << std::endl;
              << pC->who() << std::endl;
    return 0;
  }

Si vous avez des conseils n'hésitez pas !

Caduchon.

[N i h i l]

Si vous avez des conseils n'hésitez pas !

1/ Relis les conseils précédents.
2/ Utilise boost::shared_ptr.
3/ Goto 1.

4/ Quelle est la différence entre smart_ptr< A > et smart_ptr< A > const ?
5/ Que se passe-t-il la seule instance de smart_ptr< A > est x et que j'éxecute x= x; ?
6/ Si l'allocation de count_ jette une exception, que se passe-t-il ?
7/ Goto 1.

[Goten]

J'ai finalement abouti à ceci. Ca semble fonctionner, mais je ne serais pas contre un coup d'oeil d'expert pour critiquer.

smart_ptr.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
#ifndef _INCL_SMART_PTR_H__
#define _INCL_SMART_PTR_H__
 
  template <class T> class make_ptr;
 
  template <class T> class smart_ptr
  {
    public:
      smart_ptr();
      smart_ptr(const smart_ptr<T>& p);
      smart_ptr(const make_ptr<T>& mkr);
      ~smart_ptr();
      smart_ptr<T>& operator = (const smart_ptr<T>& p);
      smart_ptr<T>& operator = (const make_ptr<T>& mkr);
      template <class U> operator smart_ptr<U> ();
 
      T& operator * () const;
      T* operator -> () const;
 
    private:
      smart_ptr(T* ptr_t);
 
      T* p_;
      unsigned long int* count_;
 
    template <class> friend class smart_ptr;
    template <class> friend class make_ptr;
  };
 
  template <class T> class make_ptr
  {
    public:
      make_ptr();
      make_ptr(const T& t);
      make_ptr(const make_ptr<T>& mkr);
      ~make_ptr();
 
    private:
      smart_ptr<T>	ptr_;
 
    template <class> friend class smart_ptr;
  };
 
 
 
 
 
 
 
 
  template <class T> inline smart_ptr<T>::smart_ptr() : p_(NULL), count_(NULL)
  {}
 
  template <class T> inline smart_ptr<T>::smart_ptr(const smart_ptr<T>& ptr) : p_(ptr.p_), count_(ptr.count_)
  {
    ++(*count_);
  }
 
  template <class T> inline smart_ptr<T>::smart_ptr(const make_ptr<T>& mkr) : p_(mkr.ptr_.p_), count_(mkr.ptr_.count_)
  {
    ++(*count_);
  }
 
  template <class T> inline smart_ptr<T>::~smart_ptr()
  {
    --(*count_);
    if((*count_) == 0)
    {
      delete p_;
      delete count_;
    }
  }
 
  template <class T> inline smart_ptr<T>& smart_ptr<T>::operator = (const smart_ptr<T>& ptr)
  {
    --(*count_);
    if(*count_ == 0)
    {
      delete p_;
      delete count_;
    }
    p_ = ptr.p_;
    count_ = ptr.count_;
    ++(*count_);
    return *this;
  }
 
  template <class T> inline smart_ptr<T>& smart_ptr<T>::operator = (const make_ptr<T>& mkr)
  {
    --(*count_);
    if(*count_ == 0)
    {
      delete p_;
      delete count_;
    }
    p_ = mkr.ptr_.p_;
    count_ = mkr.ptr_.count_;
    ++(*count_);
    return *this;
  }
 
  template <class T> template <class U> inline smart_ptr<T>::operator smart_ptr<U> ()
  {
    smart_ptr<U> pU;
    pU.p_ = p_;
    pU.count_ = count_;
    ++(*count_);
    return pU;
  }
 
  template <class T> inline T& smart_ptr<T>::operator * () const
  {
    return *p_;
  }
 
  template <class T> inline T* smart_ptr<T>::operator -> () const
  {
    return p_;
  }
 
  template <class T> inline smart_ptr<T>::smart_ptr(T* ptr_t) : p_(ptr_t)
  {
    count_ = new unsigned long int(1);
  }
 
  // ----------------------------------
 
  template <class T> inline make_ptr<T>::make_ptr() : ptr_(new T)
  {}
 
  template <class T> inline make_ptr<T>::make_ptr(const T& t): ptr_(new T(t))
  {}
 
  template <class T> inline make_ptr<T>::make_ptr(const make_ptr<T>& mkr) : ptr_(mkr.ptr_)
  {}
 
  template <class T> inline make_ptr<T>::~make_ptr()
  {}
 
 
#endif

Test.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
#include <iostream>
#include "tools.h"
 
  class A
  {
    public:
      virtual ~A() {}
      virtual std::string who() const = 0;
  };
 
  class B : public A
  {
    public:
      B() {}
      virtual ~B() {}
      virtual std::string who() const { return std::string("class B"); }
  };
 
  class C : public A
  {
    public:
      C() {}
      virtual ~C() {}
      virtual std::string who() const { return std::string("class C"); }
  };
 
 
 
  smart_ptr<A> generatorB()
  {
    smart_ptr<B> p = make_ptr<B>();
    return p;
  }
 
  smart_ptr<A> generatorC()
  {
    smart_ptr<C> p = make_ptr<C>();
    return p;
  }
 
  int main()
  {
    smart_ptr<A> pB = generatorB();
    smart_ptr<A> pC = generatorC();
    std::cout << pB->who() << std::endl;
              << pC->who() << std::endl;
    return 0;
  }

Si vous avez des conseils n'hésitez pas !

Caduchon.

smart_ptr<T> x = make_ptr<T>();
x = x; // boum;

Et t'es loin d'offrir les garanties d'exception safety suffisante pour ce genre de classe!
fin bref, using boost::shared_ptr;

[Caduchon]

Malheureusement, j'aimerais dans un premier temps éviter l'utilisation de boost. Son installation sur le cluster de mon entreprise ne dépend pas de moi et je doute que ça puisse être fait dans un délais appréciable. Je dois donc m'en passer pour le moment...

[JolyLoic]

La partie smart_ptr de boost ne demande pas vraiment d'installation, juste la présence des fichiers .hpp dans le répertoire d'include de ton compilateur.

En outre, la plupart des compilateur C++ pas trop vieux intègrent désormais un shared_ptr sans devoir installer quoi que ce soit. Quel compilateur utilises-tu (et quelle version ?) ?