[template] un smart pointer parmi d'autres

Version imprimable

Voir 40 message(s) de cette discussion en une page

03/12/2008, 21h06
JolyLoic

Citation:

Envoyé par camboui

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

Tu veux dire :

Citation:

Envoyé par JolyLoic

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

Citation:

Envoyé par camboui

[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

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:

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 ;)

04/12/2008, 16h30
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, ...
04/12/2008, 16h47
Médinoc

Citation:

Envoyé par 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, ...

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<>...
04/12/2008, 17h18
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 ;)
05/12/2008, 09h19
Alp

Citation:

Envoyé par Médinoc

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 ?
05/12/2008, 09h22
Matthieu Brucher

Citation:

Envoyé par Alp

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 ;)
05/12/2008, 10h33
Médinoc

OK, au temps pour moi :)

Voir 40 message(s) de cette discussion en une page