Discussion :

[adel_dz]

Bonjour a tous. Voilà cela fait quelque temps que je bloque au niveau de la conception d'une classe: une classe de SmartPtr mais qui soit thread safe. Ce qui suit est une ebauche de la declaration de cette classe:

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
template<typename Ty,bool IsMultiThread = false>
class SmartPtr;
 
 
template<typename Ty> 
class SmartPtr<Ty,true>
{
	public:
		template<typename Ty> class Proxy;
 
		SmartPtr();
		explicit SmartPtr(Ty* Elt);
		.../...
 
		SmartPtr::Proxy<Ty>* operator -> ();
		const SmartPtr::Proxy<Ty>* operator -> () const;
 
		//??? operator *();	     <--- le probleme est ici.
 
 
		../...
 
};

je veux eviter les instructions du genre:

Code :

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

1
2
3
4
5
6
7
8
struct A
{
	int val;
	A(int i);
};
 
SmartPtr<A> sp(new A(10) );
int* pi = &(*sp).val;

Toute proposition es la bienvenue.
Merci pour votre aide.

[mchk0123]

Qu'est ce que tu entends par "je veux éviter les trucs du genre" ?

Qu'est que tu veux à la place ?

[Luc Hermitte]

Jettes un oeil au chapitre de Modern C++ Design (D'Andrei Alexandrescu) qui est dédié à ce sujet. Tu devrais trouver ce chapitre en ligne sur le site de l'éditeur dans mes souvenirs.

[epsilon68]

et celle de boost, elle est multithread ?
y a-t-il un probleme a les utiliser avec les thread de Qt, de pthread ou autre ?

[Médinoc]

Je ne sais pas pour les shared_ptr<>, mais les intrusive_ptr<> le seront si tu implémente le verrouillage nécessaire dans tes fonctions d'incrémentation/décrémentation du comptage de référence. Là, tu pourras utiliser des mutex, ou encore sous Windows, les fonctions Win32 InterlockedIncrement() et InterlockedDecrement(), etc.

Un truc bien avec les smart pointers, c'est qu'on n'a plus besoin de synchronisation/verrouillage une fois que le nombre de références est inférieur ou égal à 1, permettant une suppression sans problèmes.

[loufoque]

Les smart pointers de boost sont déjà thread-safe.
Par contre shared_ptr n'est pas lock-free (problème lié à sa taille, deux mots et non un)