-
Notifications
You must be signed in to change notification settings - Fork 16
/
functional.txt
230 lines (196 loc) · 14.9 KB
/
functional.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
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
FUNCTIONAL
HEADER ==> #<functional>
/=+===============================+=\
/ : : \
)==: RESUME :==(
\ :_______________________________: /
\=+===============================+=/
Attention :
- FUNC_ADR_UNI/BI : FUNC_ADR prenant un ou deux arguments
- CLASSFK_UNI/BI :
- CLASSFK prenant un ou deux arguments (y compris le premier CLASS_ADR implicite).
- s'écrit &CLASS::CLASSFK
- Pas de "trinary function" : max deux arguments.
- Pas possible de faire un bind sur une unary_function :
- bind*(ptr_fun(FUNC_ADR_UNI), ...) ou bind*(mem_fun(CLASSFK_UNI), ...) impossible
- préférer utiliser les adaptors
Si erreurs, souvent :
- utilisation de bind sur unary_function
- mauvaise écriture de CLASSFK_UNI/BI
- bind* ou *negate sur un CLASSFK ou FUNC_ADR, sans les transformer en functor via mem_fun ou ptr_fun
- utilisation d'un type sans instantiation
- ex : ALGO(..., ..., less<int>), au lieu de less<int>()
Boost :
- préférer boost::bind() à std::bind*, not*
- préférer boost::function à std::*_function, pointer_to_*_function, ptr_fun, mem_fun*
BASE CLASSES
+-----------------+----------------------+---------------------------------+----------------+
| CLASS | TYPEDEFS / TEMPLATE | EXECUTION (OPERATOR ()) | INSTANTIATION |
+-----------------+----------------------+---------------------------------+----------------+
| unary_function | | (ARG1) | (FUNC_ADR_UNI) |
| <WVAR1, | argument_type | exécute FUNC_ADR_UNI(ARG1) | |
| WVAR2> | result_type | | |
+-----------------+----------------------+---------------------------------+----------------+
| binary_function | | (ARG1, ARG2) | (FUNC_ADR_BI) |
| <WVAR1, | first_argument_type | exécute FUNC_ADR_BI(ARG1, ARG2) | |
| WVAR2, | second_argument_type | | |
| WVAR3> | result_type | | |
+-----------------+----------------------+---------------------------------+----------------+
ENFANTS D'UNARY_FUNCTION (MÊMES TYPEDEFS DISPONIBLES)
+--------------------+--------------------------------------+---------------------------------+-------------+
| CLASS | EXECUTION (OPERATOR ()) | INSTANTIATION | ADAPTOR |
+--------------------+--------------------------------------+---------------------------------+-------------+
| pointer_to_unary_ | (ARG1) | (FUNC_ADR_UNI) | ptr_fun |
| function | exécute FUNC_ADR_UNI(ARG1) | | |
| <WVAR1, WVAR2> | | | |
| [const_]mem_fun_t | (ARG1) | (CLASSFK_UNI) | mem_fun |
| <WVAR1, WVAR2> | exécute ARG1->CLASSFK_UNI() | (const_ : CLASSFK_UNI const {}) | |
| +--------------------------------------+---------------------------------+ |
| [const_]mem_fun_ | | mem_fun_ref |
| ref_t <...> | pareil, mais (ARG1) exécute ARG1.CLASSFK_UNI() | |
| +--------------------------------------+---------------------------------+ |
| binder1st <binary | (ARG2) | (BINARY_FUNCTION, WVAL1) | bind1st |
| _function_type> | exécute BINARY_FUNCTION(WVAL1, ARG2) | | |
| +--------------------------------------+---------------------------------+ |
| binder2nd <...> | pareil, mais (ARG1) exécute BINARY_FUNCTION(ARG1, WVAL2) | bind2nd |
| +--------------------------------------+---------------------------------+ |
| unary_negate <bool | (ARG1) | (BOOL_UNARY_FUNCTION) | not1 |
| _unary_function> | renvoie ! BOOL_UNARY_FUNCTION(ARG1) | | |
| logical_not<WVAR1> | (WVAL1) | (void) | - |
| negate <WVAR1> | renvoie OPERATION WVAL2 | | |
+--------------------+--------------------------------------+---------------------------------+-------------+
ENFANTS DE BINARY_FUNCTION (MÊMES TYPEDEFS DISPONIBLES)
+--------------------+--------------------------------------+---------------------------------+-------------+
| CLASS | EXECUTION (OPERATOR ()) | INSTANTIATION | ADAPTOR |
+--------------------+--------------------------------------+---------------------------------+-------------+
| pointer_to_binary_ | (ARG1, ARG2) | (FUNC_ADR_BI) | ptr_fun |
| function <WVAR1, | exécute FUNC_ADR_BI(ARG1, ARG2) | | |
| WVAR2, WVAR3> | | | |
| +--------------------------------------+---------------------------------+ |
| [const_] | Comme mem_fun_t, mais instantié avec CLASSFK_BI, | mem_fun |
| mem_fun1_t<...> | et (ARG1, ARG2) exécute ARG1->CLASSFK_BI(ARG2) mem_fun | |
| [const_] | Comme mem_fun1_t, mais exécute ARG1.CLASSFK_BI(ARG2) | mem_fun_ref |
| mem_fun1_ref_t<...>| | |
| binary_negate<...> | Comme unary_negate, mais avec une BOOL_BINARY_FUNCTION | not2 |
| +--------------------------------------+---------------------------------+ |
| plus <WVAR> | (WVAL1, WVAL2) | | - |
| minus <WVAR> | renvoie WVAL1 OPERATION WVAL2 | (void) | |
| multiplies <WVAR> | | | |
| divides <WVAR> | | | |
| modulus <WVAR> | | | |
| equal_to <WVAR> | | | |
| not_equal_to <WVAR>| | | |
| greater <WVAR> | | | |
| less <WVAR> | | | |
| greater_equal<WVAR>| | | |
| less_equal <WVAR> | | | |
+--------------------+--------------------------------------+---------------------------------+-------------+
PREDICAT : peut être tout FONCTOR ou FUNC_ADR, du moment qu'il respecte les concepts requis, notamment, éventuellement :
- type de la return value, et des arguments
- nombre d'arguments
- n'effectue pas d'opérations sur les arguments exigeant d'eux des préconditions non requises
- ex : test d'égalité alors que les args ne sont pas forcément EqualityComparable
- n'implique pas de postconditions sur les arguments si pas exigées
- ex : modifier les arguments alors qu'ils doivent être const
Fonction utilisant un prédicat :
- suffit de faire un template <class T> et de déclarer l'argument prédicat "T Predicat", puis de l'utiliser sous la forme Predicat(...)
- Il faut préciser les concepts requis (cf ci-dessus), en essayant d'en avoir le moins possible
Exemple d'utilisation :
- for_each(..., ..., std::bind1st(std::mem_fun(&CLASS::CLASSFK_BI), new CLASS))
- for_each(..., ..., std::bind2nd(std::mem_fun_ref(&CLASS::CLASSFK_BI), CLASS_VAR))
- for_each(..., ..., std::ptr_fun(FUNC_ADR_UNI))
- std::bind1st(std::mem_fun(&CLASS::CLASSFK), new CLASS)(WVAL)
/=+===============================+=\
/ : : \
)==: DETAILS :==(
\ :_______________________________: /
\=+===============================+=/
Pour l'instantiation et l'exécution de l'opérator () des fonctors : cf tableau.
unary_function <WVAR1, #Struct désignant un fonctor prenant un seul argument de
WVAR2> #type WVAR1, et renvoyant une valeur de type WVAR2.
#Il s'agit d'une base class.
unary_function<...>::
argument_type #Typedef depuis WVAR1.
unary_function<...>::
result_type #Typedef depuis WVAR2
binary_function <WVAR1, #Struct désignant un fonctor prenant deux arguments de
WVAR2, WVAR3> #type WVAR1 et WVAR2, et renvoyant une valeur de type
#WVAR3. Même chose qu'unary_function pour ce qui est de
#la base class.
binary_function <...>::
first_argument_type #Typedef depuis WVAR1.
binary_function <...>::
second_argument_type #Typedef depuis WVAR2.
binary_function <...>::
result_type #Typedef depuis WVAR3.
binder1st #Enfant d'unary_function, instantié avec un
<binary_function_type> #BINARY_FUNCTION, dont il fournit le premier argument
#WVAL1 de manière statique lors de l'instantiation.
#WVAL1 doit être de type
#binary_function_type::first_argument_type
bind1st(BINARY_FUNCTION,#Renvoie un BINDER1ST associé à BINARY_FUNCTION et au
WVAL) #premier argument WVAL.
binder2nd #Comme binder1st, mais agit sur le second argument de
<binary_function_type> #BINARY_FUNCTION. WVAL doit être de type
#binary_function_type::second_argument_type
bind2nd(BINARY_FUNCTION,#Renvoie un BINDER2ND associé à BINARY_FUNCTION et au
WVAL) #second argument WVAL.
pointer_to_unary_ #Type d'unary_function, instantiée avec <WVAR1, WVAR2>
function <WVAR1, WVAR2> #dont l'action est copié à partir d'un FONC_ADR, déclaré
#à l'instantiation.
#FONC_ADR doit ne prendre qu'un argument de type WVAR1,
#et renvoyer un WVAR2_VAL.
#Sert à convertir un FONC_ADR en UNARY_FUNCTION.
pointer_to_binary_ #
function <WVAR1, WVAR2, #Même chose, mais binary_function : FONC_VAR prend donc
WVAR3> #deux arguments WVAR1 et WVAR2, et renvoie un WVAR3_VAL.
ptr_fun(FONC_ADR) #Renvoie un POINTER_TO_UNARY_FUNCTION_VAL ou
#POINTER_TO_BINARY_FUNCTION_VAL, transformant ainsi
#FONC_ADR en fonctor.
[const_]mem_fun_t #Comme pointer_to_unary_function <...>, sauf que WVAR2
<WVAR1, WVAR2> #désigne la return value d'une CLASSFK, et WVAR1 est
#la CLASS de cette CLASSFK.
#const_ est si CLASSFK est une CLASSFK const {}.
[const_]mem_fun1_t #Même chose, sauf que la CLASSFK prend un argument de
<WVAR1, WVAR2, WVAR3> #type WVAR3.
mem_fun(CLASSFK_ADR) #Renvoie un [CONST]MEM_FUN[1]_T_VAL, en fonction
#du fait que CLASSFK_ADR prenne 0 ou un seul argument,
#la transformant ainsi en fonctor.
#Le fonctor doit être invoqué sous la forme :
# - FONCTOR(CLASS_ADR[, ARG]).
#Il est en effet nécessaire de lui passer un CLASS_ADR
#en argument.
[const_]mem_fun_ref_t #
<WVAR1, WVAR2>
[const_]mem_fun1_ref_t #
<WVAR1, WVAR2, WVAR3>
mem_fun_ref(CLASSFK_ADR)#Comme mem_fun sauf que le fonctor doit être invoqué
#avec une CLASS_VAR comme argument et non une CLASS_ADR
plus <WVAR> #Fonctors enfants de binary_function, représentant
minus <WVAR> #l'opération arithmétique concernée. Par exemple :
multiplies <WVAR> # - plus <int> plus_fonctor;
divides <WVAR> # cout << plus_fonctor(3, 4)
modulus <WVAR> #Imprime 7.
#On donne souvent ces fonctors comme PREDIC d'un
#algorithme sous forme de CLASS_VAL, par exemple :
# - adjacent_find(FORWD_ITVR1, FORWD_ITVR2,
# not_equal_to<int>())
equal_to <WVAR> #
not_equal_to <WVAR> #
greater <WVAR> #
less <WVAR> #
greater_equal <WVAR> #
less_equal <WVAR> #Même chose pour ==, !=, >, <, >= et <=
logical_and <WVAR> #
logical_or <WVAR> #Même chose pour && et ||
logical_not <WVAR> #Même chose pour ! (négation logique) et - (négation
negate <WVAR> #arithmétique) : il s'agit d'enfants d'unary_function
binary_negate <bool_ #Instantié avec un BOOL_BINARY_FUNCTION, renvoie la
binary_function_type> #négation de celu-ci. Enfant de binary_function.
not2(BOOL_BINARY_FUNCT) #Renvoie un BINARY_NEGATE de BOOL_BINARY_FUNCTION.
unary_negate <bool_ #Comme binary_negate, mais avec un BOOL_UNARY_FUNCTION.
unary_function_type>
not1(FONCTOR) #Comme not2, mais avec unary_negate. Enfant
#d'unary_function.