Instanciation d'un en-tête "shared_ptr.h" en c++ dans la norme avant la 11
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:
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:
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
