Bonjour,

Je souhaite connaître la manière d'instancier avant la norme 11 en c++ un en-tête shared_ptr.h (ci-dessous) dans un fichier .cpp de ce type :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
shared_ptr<Personne> p = new Personne(nom)
En effet, le shared_ptr ne peut être instancié avec le makeshared de la norme 11 du c++.

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
#ifndef SHAREDPTR_H
#define SHAREDPTR_H
#include <assert.h>
namespace ag {
//--- classe d'exception
class ref_error {};
 
//--- modèle du pointeur partagé
template <typename T>
class shared_ptr
{
		public:
//--- opérateurs de déréférencement
		T* operator->() const throw()
		{
			assert(ptr_ref!=NULL);
			return ptr_ref->get();
		}
		T& operator*() const throw()
		{
			assert(ptr_ref!=NULL);
			return *(ptr_ref->get());
		}
//--- accès à la donnée interne
		T* get() const throw(){
			assert(ptr_ref!=NULL);
			return ptr_ref->get();
		}
//--- constructeurs / destructeur
		shared_ptr(T* p){ptr_ref=new shared_ptr_ref(p);}
		shared_ptr() throw() :ptr_ref(0){}
		shared_ptr(const shared_ptr& p) throw()
		{
			if(p.ptr_ref)
				p.ptr_ref->Prend(); // prend la responsabilité de l'objet partagé
			ptr_ref=p.ptr_ref;
		}
		~shared_ptr()
		{
			if(ptr_ref)
				ptr_ref->Libere(); // perd la responsabilité de l'objet partagé
		}
//---affectation
		shared_ptr& operator=(const shared_ptr& p)
		{
			if(ptr_ref)
				ptr_ref->Libere(); // perd une responsabilité sur l'ancien objet
			if(p.ptr_ref)
				p.ptr_ref->Prend();// prend une responsabilité sur un nouvel objet
			ptr_ref=p.ptr_ref;
			return *this;
		}
		shared_ptr& operator=(T* ptr)
		{
			if(ptr_ref) ptr_ref->Libere();
			ptr_ref = new shared_ptr_ref(ptr);
			return *this;
		}
 
 
//--- comparaisons
		bool operator==(T* ptr) const
		{
			bool ok=false;
			if(ptr_ref==0)
				ok =(ptr==0);
			else
				ok = (ptr_ref->get()==ptr);
			return ok;
		}
		bool operator!=(T* ptr) const {return !operator==(ptr);}
		operator bool() const
        {
            return (ptr_ref!=0 && ptr_ref->get()!=0);
        }
 
		private:
//--- classe assistante représentant l'objet partagé
		class shared_ptr_ref
		{
				T* ptr; // la donnée interne
				mutable int count; // le comptage de références : mutable car amené à changer même sur un shared_ptr_ref const.
	// on interdit la copie et l'affectation
				shared_ptr_ref(const shared_ptr_ref&);
				void operator=(const shared_ptr_ref&);
 
				public:
	// constructeurs / destructeur
				explicit shared_ptr_ref(T* p) throw() :ptr(p),count(1){}
				~shared_ptr_ref(){delete ptr;}
	// gestion des références
				void Prend() const throw() {++count;}
				void Libere(){--count; if(count==0) delete this;}
	// accès à la donnée interne
				T* get() const throw(){return ptr;}
		};
		mutable shared_ptr_ref* ptr_ref; // référence partagée
};
 
 
} // fin du namespace
#endif
Cette étude me permettra de comprendre de manière basique le fonctionnement des pointeurs intelligents.

D'avance merci