-
Notifications
You must be signed in to change notification settings - Fork 16
/
function_bind_mem_fn.txt
203 lines (178 loc) · 11.1 KB
/
function_bind_mem_fn.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
FUNCTION BIND MEM_FN
/=+===============================+=\
/ : : \
)==: FUNCTION :==(
\ :_______________________________: /
\=+===============================+=/
HEADER ==> #<boost/function.hpp>
function<TYPE(TYPE2...)>#Classe désignant un fonctor, avec une return value TYPE
#et des arguments de type TYPE2... (y compris void sauf
#si CLASSFK)
#Permet d'utiliser un callback prenant n'importe quel
#PREDIC.
FUNCTION = PREDIC #Assigne PREDIC à FUNCTION. PREDIC peut être :
FUNCTION(PREDIC) # - tout fonctor, dont ceux renvoyés par un bind,
# un mem_fun, un lambda fonctor de boost::lambda
# - FUNC_ADR
# - &CLASS::CLASSFK, auquel cas :
# - FUNCTION devra prendre CLASS_ADR en premier ARG
# - premier TYPE2 doit être CLASS*
#PREDIC doit correspondre au template de FUNCTION.
#PREDIC est copié par value, si l'on veut une référence,
#on peut utiliser boost::ref(PREDIC) ou
#boost::cref(PREDIC)
#Si PREDIC pose un overloading problem, utiliser
#static_cast comme pour boost::bind
FUNCTION(PREDIC
[, ALLOCATOR]) #ALLOCATOR est possible.
FUNCTION([ARGS]) #Exécute PREDIC([ARGS])
FUNCTION = 0 #Fait que FUNCTION est un null functor. Une FUNCTION
FUNCTION.clear() #non-initialisé est également un null functor.
#Exécuter un null functor lance une exception
#boost::bad_function_call (enfant de std::runtime_error)
( FUNCTION ) #Renvoie true si FUNCTION est un null functor.
FUNCTION.empty() #Contraire.
function<...>::
argument_type #Seulement si 1 seul argument.
function<...>::
first_argument_type
function<...>::
second_argument_type #Seulement si 2 arguments.
function<...>::
result_type #Quel que soit le nombre d'arguments.
function<...>::argN_type#Quel que soit le nombre d'arguments. N est un nombre.
FUNCTION.arity #Nombre d'arguments.
FUNCTION == PREDIC #Test si FUNCTION contient PREDIC.
PREDIC == FUNCTION #Si PREDIC est un fonctor, il doit :
FUNCTION != PREDIC # - être EqualityComparable
PREDIC != FUNCTION # - ou une fonction :
# template <class T, class U>
# bool function_equal(const PREDIC_TYPE&,
# const FUNCTION_TYPE&)
# doit être définie.
#FUNCTION == FUNCTION2 est impossible
FUNCTION.target
<PREDIC_TYPE>() #Renvoie &PREDIC (ou NULL si null functor)
FUNCTION.contains #Renvoie true si contient précisément PREDIC_VAR
(PREDIC_VAR) #(et non un PREDIC du même type, mais pas ce
#PREDIC_VAR)
FUNCTION.target_type() #Equivaut à typeid(PREDIC)
swap(FUNCTION, FUNCTIN2)#
PORTABILITÉ ==> #Au moins :
# - g++ 2.95
# - MSVC++ 7.1
# - Comeau C++ 4.2.45.2
# - Intel C++ 5.0
# - SGI MIPSpro 7.3.0
# - Compaq cxx 6.2
#Si syntaxe ne marche pas, essayer
#functionN<TYPE, TYPE2...>, où N est le nombre
#d'éléments du template.
/=+===============================+=\
/ : : \
)==: BIND :==(
\ :_______________________________: /
\=+===============================+=/
HEADER ==> #<boost/bind.hpp>
bind(PREDIC, ARG...) #Comme std::bind*, crée un PREDIC (et non un enfant de
#std::[un|bin]ary_functor, donc pas les mêmes typedefs)
#dont certains arguments sont déjà définis, ce qui
#permet par exemple de faire d'un N_PREDIC un
#UNARY_PREDIC ou BINARY_PREDIC pour utilisation avec
#les std:: ou boost:: algorithmes.
#PREDIC, et le TYPE de PREDIC doivent être
#CopyConstructible, et leur constructor ne doit pas
#lancer d'exceptions.
#Par exemple, si ARG est non CopyConstructible (dont *this pour une CLASSFK), utiliser [c]ref( ARG ).
#Différences :
# - pour chaque ARG, premier/prochain argument de
# PREDIC sera :
# - VAL : bind avec VAL
# - _VAL : bind avec l'argument numéro VAL du BIND
# produit (== du BIND.operator())
# - il doit y avoir autant d'ARG... que le nombre
# d'ARG de PREDIC (9 maximum, 0 possible)
# - PREDIC peut être non seulement BINARY_FUNCTOR,
# mais tout fonctor, FUNC_ADR ou CLASSFK.
# Pas de typedefs nécessaires avec les fonctors.
# - Si PREDIC est une CLASSFK :
# - ARG1 de BIND peut (et doit) être CLASS_ADR ou
# CLASS_VAR (CLASS_VAR crée une copie temporaire
# contrairement à CLASS_ADR)
# - ARG1 de ARG... est donc en général "_1", avec
# "new CLASS" en premier argument de BIND.
# - les ARG... sont copiés par valeur. Pour un call by
# référence, utiliser boost::[c]ref(VAL).
PREDIC ET OVERLOADS ==> #Si PREDIC peut correspondre a plusieurs overload en
#même temps car :
# - même return type
# - et même nombre d'arguments
# - et arguments transtypables / différentes constness
# (const overload)
#Alors préciser l'argument :
# - static_cast<TYPE>(PREDIC) au lieu de PREDIC
# - TYPE doit préciser l'overload :
# - un const à la fin (ou non) pour le const overload
# - le TYPE de la return value ou des arguments
# - si PREDIC est une &CLASS::CLASSFK, TYPE est
# "TYPE (CLASS::*) () [const]"
bind<TYPE>(PREDIC, #TYPE est le return type de PREDIC.
ARG...) #Syntaxe nécessaire si :
# - PREDIC est un fonctor et ne contient pas un
# typedef result_type
# - PREDIC est une FUNC_ADR ou CLASSFK utilisant la C
# calling convention (et non stdcall ou pascal)
# - cas notamment des variadiques fonctions, et de
# plusieurs extern "C" fonctions
bind(boost::type<TYPE> #Même chose pour TYPE.
(), PREDIC, ARG...) #Syntaxe si les deux du dessus ne marchent pas
#(notamment MSVC avant 7.0).
PORTABILITÉ ==> #Macros à définir avant d'inclure <boost/bind.hpp> si
#on utilise comme PREDIC :
# - une Win32 API fonction :
# #define BOOST_BIND_ENABLE_STDCALL
# - une Windows COM fonction :
# #define BOOST_MEM_FN_ENABLE_STDCALL
# - une Mac toolbox fonction :
# #define BOOST_BIND_ENABLE_PASCAL
!bind(PREDIC, ARGS) #Equivaut à bind(logical_not<...>(), bind(PREDIC, ARGS))
bind(PREDIC,ARGS) == VAL#Equivaut à bind(equal_to<...>(),bind(PREDIC, ARGS),VAL)
# - VAL peut être une VAL normal, une _VAL ou un
# bind(...)
# - marche aussi avec !=, <, <=, >, >=, &&, ||
#Ex :
# - std::find_if(..., ..., bind(logical_or<...>(),
# bind(equal_to<...>(), bind(&CLASS::GETTER, _1),
# VAL), bind(equal_to<...>(),
# bind(&CLASS::GETTER, _1), VAL2))
# => std::find_if(..., ..., bind(&CLASS::GETTER, _1)
# == VAL || bind(&CLASS::GETTER, _1) == VAL2)
HEADER ==> #<boost/bind/apply.hpp>
bind(boost::apply #Fait que le PREDIC utilisé sera le premier ARG...
<TYPE>(), ARG...) #(peut être "_1").
/=+===============================+=\
/ : : \
)==: MEM_FN :==(
\ :_______________________________: /
\=+===============================+=/
HEADER ==> #<boost/mem_fn.hpp>
mem_fn(&CLASS::CLASSFK) #Rassemble fonctionnalités de mem_fun et mem_fun_ref
mem_fn(&CLASS::CLASSDT) #et :
# - peut prendre une CLASSFK avec n'importe quel
# nombre d'arguments
# - peut exécuter avec un smart pointer
# - avec CLASSDT, MEMFN(ARG) renvoie une référence
# vers ARG->CLASSDT& (ou ARG.CLASSDT&)
MEMFN(CLASS_ADR[, ARGS])#Exécute CLASS_ADR->CLASSFK([ARGS]).
MEMFN(CLASS_VAR[, ARGS])#Exécute CLASS_VAR.CLASSFK([ARGS]).
MEMFN(SMARTPTR[, ARGS]) #Exécute get_pointer(SMARTPTR)->CLASSFK([ARGS]).
#Les smart pointers de boost:: et de la std::
#définissent get_pointer(), ce qui revient à faire
#SMARTPTR->CLASSFK([ARGS]).
MEMFN_TYPE::result_type #Une fonction prenant dans son template le type d'un
#MEMFN peut utiliser T::result_type qui désigne le
#return type de CLASSFK.
PORTABILITÉ ==> #Si CLASSFK est une COM méthode, faire un
# #define BOOST_MEM_FN_ENABLE_STDCALL