-
Notifications
You must be signed in to change notification settings - Fork 16
/
memory.txt
117 lines (102 loc) · 6.95 KB
/
memory.txt
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
106
107
108
109
110
111
112
113
114
115
116
MEMORY
auto_ptr <WVAR> #Smart pointer : comme un pointeur, mais alloue
#dynamiquement de la mémoire à *WVAR, et désalloue
#automatiquement la mémoire pointée par *WVAR,
#lorsqu'il est détruit lui-même (en général perte de
#portée) (technique dite de RAII : Ressource
#Acquisition Is Initialization).
#Intérêt :
# - Evite les problèmes de memory leak :
# - lorsque auto_ptr hors de portée, désallocation :
# pas besoin de faire des delete
# - si exception survient, désallocation :
# exception-safe
# - RAII sert aussi aux mutexs
...::element_type #Typedef depuis WVAR
AUTO_PTR([ADR]) #Construit un AUTO_PTR lié à la VAR pointé par ADR.
#N'alloue pas la mémoire d'ADR.
#Si celle-ci est déjà associée à un autre AUTO_PTR,
#cela provoquera un segfault, car le deux AUTO_PTR
#tenteront de reset() -> double free. Eviter donc cela.
#ADR est par défaut NULL.
AUTO_PTR(AUTO_PTR2) #Transfert l'ownership : AUTO_PTR2 n'est plus associé à
AUTO_PTR = AUTO_PTR2 #son ADR : devient un pointeur null.
*AUTO_PTR #Renvoie une référence du pointeur sous-jacent
#déréférencé.
#Si contient NULL, provoque segfault.
AUTO_PTR-> #Renvoie l'underlying pointeur.
AUTO_PTR.get() #Permet aussi de savoir s'il s'agit d'un pointeur null.
AUTO_PTR.release() #AUTO_PTR cesse d'être associé à WVAL (devient une sorte
#de pointeur NULL). Renvoie WVAL. Devient associé à NULL
AUTO_PTR.reset([WVAL]) #Comme release(), mais :
# - L'ancien WVAL est désalloué et détruit.
# - si un argument est précisé (de type WVAR), il
# devient associé à ce dernier
auto_ptr <WVAR> #Un AUTO_PTR peut être typecasted vers un autre AUTO_PTR
#avec un autre template.
AllocatorConcept<WVAR> #Décrit une policy class indiquant comment allouer/
#désallouer la mémoire.
#Utilisé par exemple par les constructors des containers
#Requirements :
# - typedefs value_type, pointer, reference,
# const_pointer, const_reference, size_type,
# difference_type (tous sauf premier doivent avoir
# nothrow guarentee)
# - DefaultConstructible et CopyConstructible
# - lance exception std::bad_alloc en cas de problème
# avec allocate()
# - destructors, constructors, address(), deallocate()
# doivent avoir la nothrow guarentee.
T.allocate(SIZE_TYP_VAL,#Alloue SIZE_TYP_VAL * sizeof(T) octets (sans construire
T<void>::CONST_POINTER) #T), et renvoie un POINTER vers l'espace alloué.
#CONST_POINTER est un hint indiquant un espace pouvant
#être utilisé.
T.deallocate(POINTER, #Désalloue SIZE_TYPE_VAL * sizeof(T) octets, commençant
SIZE_TYPE_VAL) #à POINTER (sans détruire T).
T.construct(POINTER, #Construit un objet T à l'adresse POINTER, avec le
CONST_REFERENCE) #CopyConstructor T(CONST_REFERENCE) (sans allouer la
#mémoire à POINTER)
T.destroy(POINTER) #Détruit un objet T à l'adresse POINTER (sans désallouer
#la mémoire)
T.max_size() #Renvoie le nombre maximum SIZE_TYP_VAL de T pouvant
#théoriquement être alloué via allocate().
T.address #Renvoie un [CONST_]POINTER vers l'adresse de
([CONST_]REFERNCE) const#[CONST_]REFERENCE
allocator #Standard allocator, utilisé par défaut par les
#containers.
# - value_type : T
# - pointer : T*
# - reference : T&
# - const_pointer : T const*
# - const_reference : T const&
# - size_type : size_t
# - difference_type : ptrdiff_t
# - allocate() : new T[SIZE_TYPE_VAL], mais sans
# constructor
# - deallocate() : delete T[SIZE_TYPE_VAL], mais
# sans destructor
# - construct() : new ((void*)POINTER) T(CONST_REF)
# - destroy() : ((T*)POINTER)->~T()
get_temporary_buffer<T> #Equivaut à malloc(PTRDIFF_T_VAL * sizeof(T)), sauf que
(PTRDIFF_T_VAL) #renvoie une STD::PAIR<T*,PTRDIFF_T>, où first est le
#pointeur tel que retourné par malloc (NULL si problème)
#et second le nombre de sizeof(T) octets alloués
#(0 si problème). Doit être désalloué avec
#return_temporary_buffer.
#Utilité : si pas assez d'espace, essaie quand même
#d'allouer un nombre maximal d'octets, bien que
# < PTRDIFF_T_VAL
return_temporary_buffer #
(ADR) #Equivaut à free(ADR), pour get_temporary_buffer
raw_storage_iterator #T1 respecte OutputIt., et T2 est
<T1, T2> #std::iterator_traits<T1>::value_type
#Adaptor, agissant comme T1, sauf que :
# *RAW_STORAGE_ITERATOR = T2_VAL
#Invoque en fait :
# RAW_STORAGE_ITERATOR = new T2_TYPE(T2_VAL)
#Le nouvel itérateur devient non Readable.
#Le premier ne marche pas si le container de
#RAW_STORAGE_ITERATOR est non-initialisé (tel que
#retourné par malloc())