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
| tempate <typename Type>
class unique_ptr
{
struct deleter
{
void operator()(T * toDelete) const
{
delete toDelete;
}
};
public:
unique_ptr(Type * ptr = NULL):ptr_(ptr){}
~unique_ptr(){deleter()(ptr_);}
/* accès non constant au pointeur */
Type * get(){return ptr_;}
/* accès constant au pointeur */
const Type * get() const{return ptr_;}
/* renvoie le pointeur et supprime la propriété
* !!! cela signifie que celui qui le reçoit devra se charger de la
* destriction !!!
*/
T * release()
{
T * temp = ptr_;
ptr_=NULL;
}
/* détruit le pointeur actuel et le remplace par un autre */
void reset(T * newPtr = NULL)
{
deleter()(ptr_);
ptr_=newPtr;
}
/* permet de savoir si on a un pointeur valide */
explicit operator bool () const{return ptr_!= NULL;}
/* échange les pointeur entre deux unique_ptr */
void swap(unique_ptr & other)
{
std::swap(ptr_, other.ptr_);
}
/* opérateur de déréférencement */
Type * operator->(){return get();}
const Type * operator->() const{return get();}
Type & operator* () {return *get();}
Type const & operator* () const {return *get();}
/* l'affectation libère la propriété du pointeur source
* au profit du pointeur de destination
*
* si le pointeur de destination dispose d'un pointeur, celui ci est détruit
*/
unique_ptr & operator=(unique_ptr const & other)
{
reset(other.release());
return *this;
}
/* opérateurs de comparaison */
bool operator==(unique_ptr const & other) const
{
return get()==other.get();
}
bool operator!=(unique_ptr const & other) const
{
return !(*this==other);
}
bool operator<(unique_ptr const & other) const
{
return get()<other.get();
}
bool operator<=(unique_ptr const & other) const
{
return !(*this <other);
}
bool operator>(unique_ptr const & other) const
{
return !(*this < other || *this==other);
}
bool operator>=(unique_ptr const & other) const
{
return !(*this < other );
}
private:
T * ptr_;
/* le "mieux que l'on puisse faire" pour interdire la copie en C++03
* est de déclarer le constructeur par copie SANS LE DEFINIR
* dans l'accessibilité privée.
*
* toute tentative de copie se chargera, hors de la classe, par une
* erreur de compilation "is private in this context"
* mais, si on a fait une erreur dans la classe elle-meme, il faudra
* attendre l'édition de liens pour avoir une erreur
* "undefined reference to"
*/
unique_ptr(unique_ptr const &);
}; |
