-
Notifications
You must be signed in to change notification settings - Fork 16
/
type_traits.txt
199 lines (170 loc) · 11.6 KB
/
type_traits.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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
TYPE_TRAITS
HEADERS ==> #<boost/type_traits/....hpp> : metafonction ...
#<boost/type_traits/broken_compiler_spec.hpp> : BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION
#<boost/type_traits/intrinsics.hpp> : BOOST_*
METAGETTER ==> #
integral_constant<T,T_VAL> #
INTEGRAL_CONSTANT<...>::value_type #Typedef depuis T
INTEGRAL_CONSTANT<...>::value #Typedef depuis T_VAL
INTEGRAL_CONSTANT<...>::type #Typedef depuis INTEGRAL_CONSTANT<...> (utile si integral_constant est hérité, et que son
#enfant est utilisé dans un template, car les templates ne se soucient pas de subtype
#polymorphism)
true_type #Typedef depuis integral_constant<bool,true>
false_type #Typedef depuis integral_constant<bool,false>
METAGETTER IS_* ==> #Héritant de true_type ou de false_type (définition signifie "true_type si...") :
is_lvalue_reference #
<T> #TYPE&
is_rvalue_reference #
<T> #TYPE&&
is_array<T> #TYPE[] ou TYPE[VAL] (mais pas TYPE*)
is_pointer<T> #TYPE* (mais pas TYPE*&, TYPE*[]), dont FONC_ADR, mais pas CLASSFK_ADR
METAGETTER IS_*
AUTRES ==> #Ceux qui suivent ne doivent pas être *value_reference, array ou pointeur :
is_void<T> #TYPE est void
is_integral<T> #TYPE est char, short, int, long int ou long long int
is_floating_point<T>#TYPE est float, double ou long double
is_class<T> #TYPE est CLASS ou STRUCT
is_union<T> #TYPE est UNION
is_enum<T> #TYPE est ENUM
is_function<T> #TYPE est un type de fonction (et que pas un type de pointeur de fonction)
is_member_function #
_pointer<T> #CLASSFK_ADR
is_member_object #
_pointer<T> #CLASSDT_ADR
is_complex<T> #TYPE est std::complex<...> (peut être TYPE&)
METAGETTER IS_*
COMPOSITION ==> #
is_reference<T> #is_lvalue_reference<T> || is_rvalue_reference<Y>
is_arithmetic<T> #is_integral<T> || is_floating_point<T>
is_fundamental<T> #is_arithmetic<T> || is_void<T>
is_compound<T> #! is_fundamental<T>
is_scalar<T> #is_arithmetic<T> || is_pointer<T> || is_enum<T> || is_member_function_pointer<T>
is_member_pointer<T>#is_member_function_pointer<T> || is_member_object_pointer<T>
is_object<T> #! ( is_void<T> || is_function<T> || is_reference<T> )
AUTRES METAGETTERS
IS_* ==> #
is_signed<T> #T est un signed integer ou un enum
is_unsigned<T> #T est un unsigned integer
is_const<T> #T est const (false_type pour T const&, T const*, mais pas pour T *const, ni T const[], ni T const
#volatile)
is_volatile<T> #Même chose pour volatile
is_empty<T> #T est une classe ou struct sans CLASSDT ni virtual CLASSFK. Ne marche pas si T est type incomplet.
is_stateless<T> #is_empty<T> && has_trivial_{copy,constructor,destructor}<T>
is_polymorphic<T> #T est une classe polymorphique
is_abstract<T> #T est une classe abstraite
is_pod<T> #T est un POD
has_new_operator<T> #T contient un user-defined operator new
has_nothrow_ #
constructor<T>
has_nothrow_default_#
constructor<T> #T contient un default constructor nothrow (ceux non-user defined sont nothrow, dont types builtins)
has_nothrow_copy<T> #
has_nothrow_copy_ #
constructor<T> #T contient un copy constructor nothrow (ceux non-user defined sont toujours nothrow, dont types builtins)
has_trivial_default_#
constructor<T>
has_trivial_ #
constructor<T> #T a un trivial constructor
has_trivial_ #
destructor<T> #T a un trivial destructor
has_trivial_assign #
<T> #T a un trivial assignement
has_trivial_copy<T> #
has_trivial_copy_ #
constructor<T> #T a un trivial copy constructor
has_virtual_ #
destructor<T> #T a un virtual destructor
is_same<T,U> #T est exactement même type que U, y compris qualifiers.
is_convertible<T,U> #T est transtypable en U. T et U ne doivent pas être incomplets. U ne doit pas être un fonction type.
#Toujours false_type si U est abstract class ou array. Ne doit pas y avoir d'héritage ambigu.
is_base_of<T,U> #T est parent de U, ou T est U. T et U ne doivent pas être des types incomplets.
is_virtual_base_of #
<T,U> #T est virtual parent de U. T et U ne doivent pas être des types incomplets.
METAGETTER HERITANT
D'INTEGRAL_CONSTANT
==> #
alignment_of<T> #
::value #Alignement de T * NOMBRE, sous forme de SIZE_T_VAL. NOMBRE dépend de l'implémentation, en général 1.
rank<T>::value #Nombre de dimensions. 0 si ! is_array<T>, 2 pour une matrice, etc.
extent<T #Taille de la dimension n°SIZE_T_VAL (par défaut 0, celle de gauche) du type d'array T. 0 si
[,SIZ_T_VAL]>::value#! is_array<T>, si taille incomplète (TYPE[] au lieu de TYPE[NOMBRE]) ou si SIZE_T_VAL > rank<T>::value
METAGETTER SANS
HERITAGE ==> #
type_with_alignment #Type de POD aligné à SIZE_T_VAL octets. SIZE_T_VAL doit être multiple de 2, <= 32. Si 1, type est char,
<SIZE_T_VAL>::type #sinon struct vide alignée sur SIZE_T_VAL octets.
aligned_storage #
<SIZE_T_VAL1,
SIZE_T_VAL2>::type #Struct vide aligné sur SIZE_T_VAL2 octets (multiple de 2, <= 32), de taille SIZE_T_VAL1 octets.
function_traits<T> #Nombre d'argument de T sous forme de SIZE_T_VAL. T doit être un type de fonction (utilisé remove_pointer
::arity #si type de pointeur de fonction).
function_traits<T>
::result_type #Result type de T. Même chose pour T.
function_traits<T>
::argN_type #Type de l'argument numero N de T. Même chose pour T. N doit être un nombre.
common_type<T...> #Type pouvant transtyper tous les T...
::type #Commence par faire un common_type entre les deux premiers T, puis le résultat et le 3ème T, etc.
#Tous les T... doivent être complete types.
#Souvent return type d'une fonction à template avec plusieurs types génériques différents en argument.
#Préférer boost::typeof quand c'est possible.
METASETTER ==> #
make_signed<T>::type #Si is_unsigned<T>, rend signed. Si enum -> unsigned int.
make_unsigned<T>::type #Si is_signed<T>, rend unsigned. Si enum -> signed int.
add_const<T>::type #T const (si TYPE& -> TYPE&, et non TYPE& const)
add_volatile<T>::type #T volatile (si TYPE& -> TYPE&, et non TYPE& volatile)
add_cv<T>::type #add_const<add_volatile<T> >
add_pointer<T>::type #T* (si TYPE& -> TYPE*, et non TYPE&* ou TYPE**)
add_lvalue_reference #T& (si TYPE& -> TYPE& ; si TYPE&& -> TYPE& ; si void -> void ; si TYPE* -> TYPE*&)
add_rvalue_reference #T&& (si TYPE& -> TYPE& ; si TYPE&& -> TYPE&& ; si void -> void ; si TYPE* -> TYPE*&&)
remove_const<T>::type #T, moins top-level const, si présent
remove_volatile<T>::type #T, moins top-level volatile, si présent
remove_cv<T>::type #remove_const<remove_volatile<T> >
remove_pointer<T>::type #T, moins un * (un seul), si présent
remove_reference<T>::type #T, moins & ou &&, si présent
remove_extent<T>::type #T, moins top-level [], si présent (array)
remove_all_extents<T> #
::type #T, moins tous les [], si présent (array)
decay<T>::type #typename remove_reference<typename remove_extent<T>::type>::type>
#Si T est array ou function type, rajoute T* en plus
floating_point_promotion #
<T>::type #Si float -> double (sinon identique, dont double et long double)
integral_promotion<T> #
::type #Si char, short ou enum -> int (sinon identique, dont int, long int et long long int)
promote<T>::type #floating_point_promotion<typename integral_promotion<T>::type>::type
conditional<bool,T,U> #
::type #Si BOOL est true, T, sinon U
SPECIALIZATION ==> #On peut spécialiser toutes ces classes si l'on veut un comportement particulier pour une classe donnée.
PORTABILITE ==> #Pour tous ceux qui suivent, utiliser macro BOOST_*( T ), au lieu de *<T>::value :
# - sauf is_scalar, is_union, is_convertible
# - mais y compris, is_class, is_polymorphic, alignment_of
# - Problème avec Borland 5, Metrowerks 8- :
# - is_convertible, is_enum (donc is_scalar)
# - MSVC++ 8.0+, g++ 4.3+, Greenhills 6.0+, Intel C++ 11.0+, Borland :
# - is_union (macro BOOST_IS_UNION defined)
# - has_nothrow_* (macro BOOST_HAS_NOTHROW_* defined) (donc is_stateless)
# - has_trivial_* (macro BOOST_HAS_TRIVIAL_* defined)
# - has_virtual_destructor (macro BOOST_HAS_VIRTUAL_DESTRUCTOR defined)
# - is_pod (macro BOOST_IS_POD defined)
# - g++ 4.3+, MSVC++ 7.1+, Intel C++ 7.1+, Comeau 4.3.2+ :
# - is_abstract (macro BOOST_NO_IS_ABSTRACT defined)
# - is_convertible
# - Borland :
# - is_base_of pour un héritage privé, ou un héritage ambigu (diagramme en diamand)
# - Pas de partial specialization :
# - is_empty pour les abstract types
#Pas besoin de macros :
# - Pas de partial specialization :
# - add*, remove*, conditional, common_type, decay, *_promotion, make_*signed, promote : cependant on
# peut définir BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION( TYPE ) pour tout TYPE utilisant
# ces metafunctions, pour régler le problème.
# - is_*reference pour type de fonction et TYPE const volatile.
# - is_scalar, is_pod, is_stateless, is_base_of pour les function types.
# - is_same pour les abstract, incomplete et function types.
# - function_traits
# - Problème avec Borland, et compilers ayant pas de SFINAE (BOOST_NO_SFINAE defined) :
# - has_new_operator
# - Rvalue references :
# - is_rvalue_reference (donc is_reference), add_rvalue_reference
# - Pas de variadic templates :
# - common_type : que 3 T... possibles, mais on peut imbriquer (macro BOOST_NO_VARIADIC_TEMPLATES)