Discussion :

[JolyLoic]

Il y a un petit soucis que vous n'avez pas soulevé dans ces smart pointer, le voici:

Tu veux dire :

Le pointeur me semble rudimentaire.Il ne supporte pas par exemple les opération entre pointeurs sur types différents, mais liés.

[code]template<class T>
template<class Y>
c2smart_ptr(const c2smart_ptr<Y> & r)
:f_ptr(r.get()) { Attach(reinterpret_cast<const c2smart_ptr<T> *>(&r)); }

Le reinterpret_cast est très rarement un bon choix... A choisir, je ferait plutôt une classe de base non templatée pour tous les smart ptrs qui gérerait la liste.

Je n'ai pas vu l'opérateur = non plus, par exemple. Ni d'opérateur de type dynamic_pointer_cast

[camboui]

Désolé, je n'avais pas compris ta phrase à propos du polymorphisme.

Pour l'opérator= version template, il ne me semble pas indispensable, mais il apporte une optimisation je suppose.

Pour le dynamic_pointer_cast, j'y songerais quand j'en aurais besoin.

Sinon voici mon smart pointer "définitif", celui que je vais utiliser en sus de boost::shared_ptr. Il est basé sur le tout premier dont question dans cette discussion. Il est "auto intrusif", donc sans avoir les contraintes de CComPtr ou boost::intrusive_ptr (il ne faut rien réécrire quoi).
Merci à Médinoc et à toi JolyLoic pour vos remarques (surtout ton post #31, ce fut le déclic).

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
template<class T>
class b2smart_ptr
{
	class intra_counter
	{
		long f_cnt;
		long Keep() { return ++f_cnt; }
		long Release() { return --f_cnt; }
	public:
		static T *Init()
		{
			char *cptr=new char[sizeof(intra_counter)+sizeof(T)];
			intra_counter *pac=reinterpret_cast<intra_counter *>(cptr);
			pac->f_cnt=1;
			return reinterpret_cast<T *>(pac+1);
		}
		static T *Copy(T *p)
		{
			if (p)
				(reinterpret_cast<intra_counter *>(p)-1)->Keep();
			return p;
		}
		static void Done(T *p)
		{
			if (p)
			{
				intra_counter *pac=(reinterpret_cast<intra_counter *>(p)-1);
				if (pac->Release()==0)
				{
					p->~T();
					delete[] reinterpret_cast<char *>(pac);
				}
			}
		}
		static void Copy(T **pp,T *p)
		{
			if (p)
				(reinterpret_cast<intra_counter *>(p)-1)->Keep();
			Done(*pp);
			*pp=p;
		}
	};
 
	T *f_ptr;
	explicit b2smart_ptr(T *ptr)
		:f_ptr(ptr) {}
public:
	b2smart_ptr()
		:f_ptr(0) {}
	template<class Y>
	b2smart_ptr(const b2smart_ptr<Y> & r)
		{ f_ptr=intra_counter::Copy(r.get()); }
	b2smart_ptr(const b2smart_ptr<T> & r)
		{ f_ptr=intra_counter::Copy(r.f_ptr); }
	template<class Y>
	b2smart_ptr<T> & operator=(const b2smart_ptr<Y> & r)
		{ intra_counter::Copy(&f_ptr,r.get()); return *this; }
	b2smart_ptr<T> & operator=(const b2smart_ptr<T> & r)
		{ intra_counter::Copy(&f_ptr,r.f_ptr); return *this; }
	~b2smart_ptr()
		{ intra_counter::Done(f_ptr); }
	bool operator,(bool b) const
		{ return f_ptr!=0 && bool(*f_ptr)==b; }
	operator bool() const
		{ return f_ptr!=0; }
	T & operator*() const
		{ return *f_ptr; }
	T *operator->() const
		{ return f_ptr; }
	T *get() const
		{ return f_ptr; }
 
	static b2smart_ptr<T> make()
	{
		T *ptr=intra_counter::Init();
		new(ptr)T();// !!!
		return b2smart_ptr<T>(ptr);
	}
 
	template<class A1>
	static b2smart_ptr<T> make(A1 const & a1)
	{
		T *ptr=intra_counter::Init();
		new(ptr)T(a1);// !!!
		return b2smart_ptr<T>(ptr);
	}
 
	template<class A1,class A2>
	static b2smart_ptr<T> make(A1 const & a1,A2 const & a2)
	{
		T *ptr=intra_counter::Init();
		new(ptr)T(a1,a2);// !!!
		return b2smart_ptr<T>(ptr);
	}
 
	template<class A1,class A2,class A3>
	static b2smart_ptr<T> make(A1 const & a1,A2 const & a2,A3 const & a3)
	{
		T *ptr=intra_counter::Init();
		new(ptr)T(a1,a2,a3);// !!!
		return b2smart_ptr<T>(ptr);
	}
};
 
#define NEW_PTR(T) b2smart_ptr<T>::make

Je voulais un smart pointer "léger". boost::shared_ptr est trop lourd dans la plupart des cas rencontrés, bien qu'il ait l'avantage de couvrir tous les besoins (ceux qui l'ont pondu se sont grattés pour je suppose).
Voilà, merci à tous, et, surtout, n'hésitez pas si vous y voyez un bug flagrant

[Matthieu Brucher]

De mon point de vue, shared_ptr ne couvre pas tous les besoins. Pour commencer, il n'est pas intrusif. Ensuite, il y a un compteur de référence, ça ne m'arrange pas si je sais que je ne vais pas partager ce pointeur, ...

[Médinoc]

De mon point de vue, shared_ptr ne couvre pas tous les besoins. Pour commencer, il n'est pas intrusif. Ensuite, il y a un compteur de référence, ça ne m'arrange pas si je sais que je ne vais pas partager ce pointeur, ...

Mais si tu ne partages pas un pointeur, plutôt que d'utiliser un shared_ptr<> qui sert à ça, tu vas utiliser un scoped_ptr<>...

[Matthieu Brucher]

Et ?
Est-ce que j'ai dit le contraire ? Je te rassure, j'utilise déjà ce pointeur partout dans mon code. Ce n'est pas comme si j'avais écrit un tutoriel sur les smart pointers de Boost

[Alp]

Mais si tu ne partages pas un pointeur, plutôt que d'utiliser un shared_ptr<> qui sert à ça, tu vas utiliser un scoped_ptr<>...

Je pense que ce que Matthieu a voulu dire c'est que shared_ptr n'est pas la solution magique et qu'il ne faut pas oublier ses homologues chez Boost (weak|scoped_ptr) car on a trop tendance à les oublier. C'est bien ça ?

[Matthieu Brucher]

Je pense que ce que Matthieu a voulu dire c'est que shared_ptr n'est pas la solution magique et qu'il ne faut pas oublier ses homologues chez Boost (weak|scoped_ptr) car on a trop tendance à les oublier. C'est bien ça ?

Exact

[Médinoc]

OK, au temps pour moi