bind-Funktion
Bindet Argumente an ein aufrufbares Objekt.
template<class Fty, class T1, class T2, ..., class TN>
unspecified bind(Fty fn, T1 t1, T2 t2, ..., TN tN);
template<class Ret, class Fty, class T1, class T2, ..., class TN>
unspecified bind(Fty fn, T1 t1, T2 t2, ..., TN tN);
Parameter
Fty
Der Typ des Objekts zu dem Aufruf.TN
Der Typ des Aufrufsarguments N-ten.fn
Das Objekt den Aufruf.tN
Beim N-ten Aufrufsargument.
Hinweise
Die Typen Fty, T1, T2, ..., TN müssen die konstruierbare Kopie sein, und INVOKE(fn, t1, ..., tN) muss ein gültiger Ausdruck für einige Werte w1, w2, ..., wN.
Die erste Vorlagenfunktion gibt ein Weiterleitungsaufrufswrapper g mit einem schwachen Ergebnistyp zurück. Der Zweck von g(u1, u2, ..., uM) ist INVOKE(f, v1, v2, ..., vN, result_of-Klasse<Fty cv (V1, V2, ..., VN)>::type), wobei cv die LebenslaufQualifizierer von g ist und die Werte und Typen der Argumente gebundenen v1, v2, ..., vN bestimmt werden, wie nachfolgend angegeben. Sie verwenden diesen, um Argumente an einen aufrufbaren Objekt zu binden, um ein aufrufbares Objekt mit einer angepassten Argumentliste zu machen.
Die zweite Vorlagenfunktion gibt ein Weiterleitungsaufrufswrapper g mit einem geschachtelten Typ result_type zurück, der ein Synonym für Ret ist. Der Zweck von g(u1, u2, ..., uM) ist INVOKE(f, v1, v2, ..., vN, Ret), wobei cv die LebenslaufQualifizierer von g ist und die Werte und Typen der Argumente gebundenen v1, v2, ..., vN bestimmt werden, wie nachfolgend angegeben. Sie verwenden diesen, um Argumente an einen aufrufbaren Objekt zu binden, um ein aufrufbares Objekt mit einer angepassten Argumentliste und einem angegebenen Rückgabetyp zu machen.
Die gebundenen Werte der Argumente v1, v2, ..., vN und ihrer entsprechenden Typen V1, V2, ..., VN sind vom Typ des entsprechenden Arguments ti vom Typ Ti im Aufruf von bind und der LebenslaufQualifizierer cv des Aufrufswrappers g ab, wie folgt:
wenn ti vom Typ reference_wrapper<T> ist, ist das Argument viti.get() und der Typ Vi ist T&;
wenn der Wert von std::is_bind_expression<Ti>::valuetrue ist, ist das Argument viti(u1, u2, ..., uM) und der Typ Vi ist result_of<Ti cv (U1&, U2&, ..., UN&>::type;
wenn der Wert j aus std::is_placeholder<Ti>::value nicht null ist, ist das Argument viuj und der Typ Vi ist Uj&;
Andernfalls ist das Argument viti und der Typ Vi ist Ti cv &.
Beispielsweise einer Funktion den Ausdruck f(int, int)bind(f, _1, 0) gegeben gibt ein cw zurück Weiterleitungsaufrufswrapper so, dass cw(x)f(x, 0) aufgerufen wird. Der Ausdruck bind(f, 0, _1) gibt ein cw zurück Weiterleitungsaufrufswrapper so, dass cw(x)f(0, x) aufgerufen wird.
Die Anzahl der Argumente in einem Aufruf bind zusätzlich das Argument fn muss gleich die Argumentanzahl sein, die z aufrufbaren Objekt fn übergeben werden können. Somit ist bind(cos, 1.0) richtig, und bind(cos) und bind(cos, _1, 0.0) sind falsch.
Die Anzahl von Argumenten in Funktionsaufruf zum Aufrufswrapper, der von bind zurückgegeben, muss wie der höchste nummerierte Wert von is_placeholder<PH>::value für alle Platzhalterargumente im Aufruf von bind mindestens so groß sein. Somit ist bind(cos, _2)(0.0, 1.0) (und gibt cos(1.0) zurück), richtig, und bind(cos, _2)(0.0) ist falsch.
Beispiel
// std_tr1__functional__bind.cpp
// compile with: /EHsc
#include <functional>
#include <algorithm>
#include <iostream>
using namespace std::placeholders;
void square(double x)
{
std::cout << x << "^2 == " << x * x << std::endl;
}
void product(double x, double y)
{
std::cout << x << "*" << y << " == " << x * y << std::endl;
}
int main()
{
double arg[] = {1, 2, 3};
std::for_each(&arg[0], arg + 3, square);
std::cout << std::endl;
std::for_each(&arg[0], arg + 3, std::bind(product, _1, 2));
std::cout << std::endl;
std::for_each(&arg[0], arg + 3, std::bind(square, _1));
return (0);
}
Anforderungen
Header: <functional>
Namespace: std