在c ++中的回调函数
在c ++中，何时以及如何使用回调函数？
编辑：
我想看一个简单的例子来编写一个回调函数。
注意：大部分答案都包含了函数指针，这是C ++中实现“回调”逻辑的一种可能，但到目前为止，并不是我认为最有利的一种。
什么是回调（？）以及为什么要使用它们（！）
回调是类或函数接受的可调用的函数（详见下文），用于根据回调来定制当前的逻辑。
使用回调的一个原因是编写与被调用函数中的逻辑无关的通用代码，并且可以通过不同的回调重用。
标准算法库的许多函数<algorithm>使用回调函数。 例如， for_each算法对一系列迭代器中的每个项目应用一元回调：
template<class InputIt, class UnaryFunction>
UnaryFunction for_each(InputIt first, InputIt last, UnaryFunction f)
{
for (; first != last; ++first) {
f(*first);
}
return f;
}
它可以用于首先递增，然后通过传递适当的可调参数来打印矢量，例如：
std::vector<double> v{ 1.0, 2.2, 4.0, 5.5, 7.2 };
double r = 4.0;
std::for_each(v.begin(), v.end(), [&](double & v) { v += r; });
std::for_each(v.begin(), v.end(), [](double v) { std::cout << v << " "; });
打印
5 6.2 8 9.5 11.2
回调的另一个应用是通知某些事件的调用者，这使得静态/编译时间具有一定的灵活性。
就我个人而言，我使用了一个使用两种不同回调的本地优化库：
因此，库设计者不负责决定通过通知回调给予程序员的信息会发生什么情况，他不必担心如何通过逻辑回调来提供函数值。 把这些事情做好是由于图书馆用户的任务，并保持图书馆的苗条和更通用。
此外，回调可以启用动态运行时行为。
想象一下某种类型的游戏引擎类，它有一个被触发的函数，每次用户按下键盘上的一个按钮和一组控制游戏行为的函数。 通过回调，您可以（在运行时）决定采取何种行动。
void player_jump();
void player_crouch();
class game_core
{
std::array<void(*)(), total_num_keys> actions;
//
void key_pressed(unsigned key_id)
{
if(actions[key_id]) actions[key_id]();
}
// update keybind from menu
void update_keybind(unsigned key_id, void(*new_action)())
{
actions[key_id] = new_action;
}
};
在这里， key_pressed函数使用存储在actions的回调来获得所需的行为，当某个键被按下时。 如果玩家选择改变跳跃按钮，引擎可以打电话
game_core_instance.update_keybind(newly_selected_key, &player_jump);
并且因此在下次游戏中按下按钮时改变对key_pressed （其调用player_jump ）的调用的行为。
C ++（11）中的可调用函数是什么？
请参阅C ++概念：可在cppreference上调用以获得更正式的描述。
回调函数可以通过几种方式在C ++（11）中实现，因为几种不同的东西变成可调用* ：
std::function对象 operator()类operator() ） *注意：指向数据成员的指针也可以调用，但根本没有函数被调用。
详细编写回调的几种重要方法
注意：从C ++ 17开始，像f(...)这样的调用可以写为std::invoke(f, ...) ，它也处理指向成员大小写的指针。
1.函数指针
函数指针是“最简单的”（就一般性而言;在可读性方面可以说是最差的）类型的回调可以有。
让我们有一个简单的函数foo ：
int foo (int x) { return 2+x; }
1.1编写函数指针/类型表示法
函数指针类型具有符号
return_type (*)(paramter_type_1, paramter_type_2, paramter_type_3)
// i.e. a pointer to foo has the type:
int (*)(int)
一个命名的函数指针类型将如何
return_type (* name) (paramter_type_1, paramter_type_2, paramter_type_3)
// i.e. f_int_t is a type: function pointer taking one int argument, returning int
typedef int (*f_int_t) (int);
// foo_p is a pointer to function taking int returning int
// initialized by pointer to function foo taking int returning int
int (* foo_p)(int) = &foo;
// can alternatively be written as
f_int_t foo_p = &foo;
using声明使我们可以选择使事情更具可读性，因为f_int_t的typedef也可以写为：
using f_int_t = int(*)(int);
在哪里（至少对我来说） f_int_t是新的类型别名更清楚，并且函数指针类型的识别也更容易
并且使用函数指针类型的回调函数声明如下：
// foobar having a callback argument named moo of type
// pointer to function returning int taking int as its argument
int foobar (int x, int (*moo)(int));
// if f_int is the function pointer typedef from above we can also write foobar as:
int foobar (int x, f_int_t moo);
1.2回拨呼叫标记
调用符号遵循简单的函数调用语法：
int foobar (int x, int (*moo)(int))
{
return x + moo(x); // function pointer moo called using argument x
}
// analog
int foobar (int x, f_int_t moo)
{
return x + moo(x); // function pointer moo called using argument x
}
1.3回调使用符号和兼容类型
采用函数指针的回调函数可以使用函数指针调用。
使用一个接受函数指针回调的函数非常简单：
int a = 5;
int b = foobar(a, foo); // call foobar with pointer to foo as callback
// can also be
int b = foobar(a, &foo); // call foobar with pointer to foo as callback
1.4例子
函数可以写成，不依赖于回调的工作方式：
void tranform_every_int(int * v, unsigned n, int (*fp)(int))
{
for (unsigned i = 0; i < n; ++i)
{
v[i] = fp(v[i]);
}
}
在可能的情况下回调可能是
int double_int(int x) { return 2*x; }
int square_int(int x) { return x*x; }
用过
int a[5] = {1, 2, 3, 4, 5};
tranform_every_int(&a[0], 5, double_int);
// now a == {2, 4, 6, 8, 10};
tranform_every_int(&a[0], 5, square_int);
// now a == {4, 16, 36, 64, 100};
2.指向成员函数的指针
成员函数指针（某些C类）是一种特殊类型（甚至更复杂）的函数指针，它需要类型C的对象来操作。
struct C
{
int y;
int foo(int x) const { return x+y; }
};
2.1将指针写入成员函数/类型表示法
对于某些类T 成员函数类型的指针具有符号
// can have more or less parameters
return_type (T::*)(paramter_type_1, paramter_type_2, paramter_type_3)
// i.e. a pointer to C::foo has the type
int (C::*) (int)
其中一个指向成员函数的指向指针将类似于函数指针 - 看起来像这样：
return_type (T::* name) (paramter_type_1, paramter_type_2, paramter_type_3)
// i.e. a type `f_C_int` representing a pointer to member function of `C`
// taking int returning int is:
typedef int (C::* f_C_int_t) (int x);
// The type of C_foo_p is a pointer to member function of C taking int returning int
// Its value is initialized by a pointer to foo of C
int (C::* C_foo_p)(int) = &C::foo;
// which can also be written using the typedef:
f_C_int_t C_foo_p = &C::foo;
示例：声明一个将成员函数回调指针作为其参数之一的函数：
// C_foobar having an argument named moo of type pointer to member function of C
// where the callback returns int taking int as its argument
// also needs an object of type c
int C_foobar (int x, C const &c, int (C::*moo)(int));
// can equivalently declared using the typedef above:
int C_foobar (int x, C const &c, f_C_int_t moo);
2.2回拨呼叫标记
指针的成员函数C可以被调用，关于类型的对象C通过使用关于解除引用的指针构件访问操作。 注意：需要使用圆括号！
int C_foobar (int x, C const &c, int (C::*moo)(int))
{
return x + (c.*moo)(x); // function pointer moo called for object c using argument x
}
// analog
int C_foobar (int x, C const &c, f_C_int_t moo)
{
return x + (c.*moo)(x); // function pointer moo called for object c using argument x
}
注意：如果指向C的指针可用，则语法是相同的（ C指针也必须解除引用）：
int C_foobar_2 (int x, C const * c, int (C::*meow)(int))
{
if (!c) return x;
// function pointer meow called for object *c using argument x
return x + ((*c).*meow)(x);
}
// or equivalent:
int C_foobar_2 (int x, C const * c, int (C::*meow)(int))
{
if (!c) return x;
// function pointer meow called for object *c using argument x
return x + (c->*meow)(x);
}
2.3回调使用符号和兼容类型
服用类的成员函数的指针的回调函数T可使用类的成员函数指针调用T 。
使用一个带有指向成员函数回调的指针的函数，类似于函数指针 - 也很简单：
C my_c{2}; // aggregate initialization
int a = 5;
int b = C_foobar(a, my_c, &C::foo); // call C_foobar with pointer to foo as its callback
3. std::function对象（头<functional> ）
std::function类是一个多态函数包装器，用于存储，复制或调用可调用对象。
3.1编写一个std::function对象/类型表示法
存储可调用对象的std::function对象的类型如下所示：
std::function<return_type(paramter_type_1, paramter_type_2, paramter_type_3)>
// i.e. using the above function declaration of foo:
std::function<int(int)> stdf_foo = &foo;
// or C::foo:
std::function<int(const C&, int)> stdf_C_foo = &C::foo;
3.2回拨呼叫标记
std::function类定义了可以用来调用其目标的operator() 。
int stdf_foobar (int x, std::function<int(int)> moo)
{
return x + moo(x); // std::function moo called
}
// or
int stdf_C_foobar (int x, C const &c, std::function<int(C const &, int)> moo)
{
return x + moo(c, x); // std::function moo called using c and x
}
3.3回调使用符号和兼容类型
std::function回调比函数指针或指向成员函数的指针更通用，因为可以传递不同的类型并将其隐式转换为std::function对象。
3.3.1函数指针和成员函数的指针
一个函数指针
int a = 2;
int b = stdf_foobar(a, &foo);
// b == 6 ( 2 + (2+2) )
或者一个指向成员函数的指针
int a = 2;
C my_c{7}; // aggregate initialization
int b = stdf_C_foobar(a, c, &C::foo);
// b == 11 == ( 2 + (7+2) )
可以使用。
3.3.2 Lambda表达式
来自lambda表达式的未命名的闭包可以存储在std::function对象中：
int a = 2;
int c = 3;
int b = stdf_foobar(a, [c](int x) -> int { return 7+c*x; });
// b == 15 == a + (7*c*a) == 2 + (7+3*2)
3.3.3 std::bind表达式
可以传递std::bind表达式的结果。 例如，通过将参数绑定到函数指针调用：
int foo_2 (int x, int y) { return 9*x + y; }
using std::placeholders::_1;
int a = 2;
int b = stdf_foobar(a, std::bind(foo_2, _1, 3));
// b == 23 == 2 + ( 9*2 + 3 )
int c = stdf_foobar(a, std::bind(foo_2, 5, _1));
// c == 49 == 2 + ( 9*5 + 2 )
还可以将对象绑定为指向成员函数的指针的对象：
int a = 2;
C const my_c{7}; // aggregate initialization
int b = stdf_foobar(a, std::bind(&C::foo, my_c, _1));
// b == 1 == 2 + ( 2 + 7 )
3.3.4函数对象
具有适当的operator()重载的类对象也可以存储在std::function对象内。
struct Meow
{
int y = 0;
Meow(int y_) : y(y_) {}
int operator()(int x) { return y * x; }
};
int a = 11;
int b = stdf_foobar(a, Meow{8});
// b == 99 == 11 + ( 8 * 11 )
3.4示例
更改函数指针示例以使用std::function
void stdf_tranform_every_int(int * v, unsigned n, std::function<int(int)> fp)
{
for (unsigned i = 0; i < n; ++i)
{
v[i] = fp(v[i]);
}
}
因为（见3.3）我们有更多的可能性来使用它：
// using function pointer still possible
int a[5] = {1, 2, 3, 4, 5};
stdf_tranform_every_int(&a[0], 5, double_int);
// now a == {2, 4, 6, 8, 10};
// use it without having to write another function by using a lambda
stdf_tranform_every_int(&a[0], 5, [](int x) -> int { return x/2; });
// now a == {1, 2, 3, 4, 5}; again
// use std::bind :
int nine_x_and_y (int x, int y) { return 9*x + y; }
using std::placeholders::_1;
// calls nine_x_and_y for every int in a with y being 4 every time
stdf_tranform_every_int(&a[0], 5, std::bind(nine_x_and_y, _1, 4));
// now a == {13, 22, 31, 40, 49};
4.模板回调类型
使用模板，调用回调的代码可能比使用std::function对象更普遍。
请注意，模板是编译时功能，是编译时多态的设计工具。 如果要通过回调实现运行时动态行为，模板将会有所帮助，但它们不会引发运行时动态。
4.1编写（键入符号）并调用模板化回调
通过使用模板，可以进一步推广即使更进一步的std_ftransform_every_int代码：
template<class R, class T>
void stdf_transform_every_int_templ(int * v,
unsigned const n, std::function<R(T)> fp)
{
for (unsigned i = 0; i < n; ++i)
{
v[i] = fp(v[i]);
}
}
对于回调类型来说，一个更普遍的（也是最简单的）语法是一个普通的，将被推断的模板化的论点：
template<class F>
void transform_every_int_templ(int * v,
unsigned const n, F f)
{
std::cout << "transform_every_int_templ<"
<< type_name<F>() << ">n";
for (unsigned i = 0; i < n; ++i)
{
v[i] = f(v[i]);
}
}
注意：包含的输出将打印为模板类型F推导的类型名称。 在这篇文章的最后给出了type_name的实现。
一个范围的一元转换的最普通的实现是标准库的一部分，即std::transform ，它也是迭代类型的模板。
template<class InputIt, class OutputIt, class UnaryOperation>
OutputIt transform(InputIt first1, InputIt last1, OutputIt d_first,
UnaryOperation unary_op)
{
while (first1 != last1) {
*d_first++ = unary_op(*first1++);
}
return d_first;
}
4.2使用模板回调和兼容类型的示例
模板化std::function回调方法stdf_transform_every_int_templ的兼容类型与上述类型相同（参见3.4）。
但是，使用模板版本，所使用的回调的签名可能会有所变化：
// Let
int foo (int x) { return 2+x; }
int muh (int const &x) { return 3+x; }
int & woof (int &x) { x *= 4; return x; }
int a[5] = {1, 2, 3, 4, 5};
stdf_transform_every_int_templ<int,int>(&a[0], 5, &foo);
// a == {3, 4, 5, 6, 7}
stdf_transform_every_int_templ<int, int const &>(&a[0], 5, &muh);
// a == {6, 7, 8, 9, 10}
stdf_transform_every_int_templ<int, int &>(&a[0], 5, &woof);
注意： std_ftransform_every_int （非模板版本;请参阅上文）可以与foo使用，但不能使用muh 。
// Let
void print_int(int * p, unsigned const n)
{
bool f{ true };
for (unsigned i = 0; i < n; ++i)
{
std::cout << (f ? "" : " ") << p[i];
f = false;
}
std::cout << "n";
}
transform_every_int_templ的纯模板参数可以是每种可能的可调用类型。
int a[5] = { 1, 2, 3, 4, 5 };
print_int(a, 5);
transform_every_int_templ(&a[0], 5, foo);
print_int(a, 5);
transform_every_int_templ(&a[0], 5, muh);
print_int(a, 5);
transform_every_int_templ(&a[0], 5, woof);
print_int(a, 5);
transform_every_int_templ(&a[0], 5, [](int x) -> int { return x + x + x; });
print_int(a, 5);
transform_every_int_templ(&a[0], 5, Meow{ 4 });
print_int(a, 5);
using std::placeholders::_1;
transform_every_int_templ(&a[0], 5, std::bind(foo_2, _1, 3));
print_int(a, 5);
transform_every_int_templ(&a[0], 5, std::function<int(int)>{&foo});
print_int(a, 5);
上面的代码打印出来：
1 2 3 4 5
transform_every_int_templ <int(*)(int)>
3 4 5 6 7
transform_every_int_templ <int(*)(int&)>
6 8 10 12 14
transform_every_int_templ <int& (*)(int&)>
9 11 13 15 17
transform_every_int_templ <main::{lambda(int)#1} >
27 33 39 45 51
transform_every_int_templ <Meow>
108 132 156 180 204
transform_every_int_templ <std::_Bind<int(*(std::_Placeholder<1>, int))(int, int)>>
975 1191 1407 1623 1839
transform_every_int_templ <std::function<int(int)>>
977 1193 1409 1625 1841
上面使用的type_name实现
#include <type_traits>
#include <typeinfo>
#include <string>
#include <memory>
#include <cxxabi.h>
template <class T>
std::string type_name()
{
typedef typename std::remove_reference<T>::type TR;
std::unique_ptr<char, void(*)(void*)> own
(abi::__cxa_demangle(typeid(TR).name(), nullptr,
nullptr, nullptr), std::free);
std::string r = own != nullptr?own.get():typeid(TR).name();
if (std::is_const<TR>::value)
r += " const";
if (std::is_volatile<TR>::value)
r += " volatile";
if (std::is_lvalue_reference<T>::value)
r += " &";
else if (std::is_rvalue_reference<T>::value)
r += " &&";
return r;
}
还有C回调方式：函数指针
//Define a type for the callback signature,
//it is not necessary, but makes life easier
//Function pointer called CallbackType that takes a float
//and returns an int
typedef int (*CallbackType)(float);
void DoWork(CallbackType callback)
{
float variable = 0.0f;
//Do calculations
//Call the callback with the variable, and retrieve the
//result
int result = callback(variable);
//Do something with the result
}
int SomeCallback(float variable)
{
int result;
//Interpret variable
return result;
}
int main(int argc, char ** argv)
{
//Pass in SomeCallback to the DoWork
DoWork(&SomeCallback);
}
现在，如果您想以回调方式传递类方法，则对这些函数指针的声明具有更复杂的声明，例如：
//Declaration:
typedef int (ClassName::*CallbackType)(float);
//This method performs work using an object instance
void DoWorkObject(CallbackType callback)
{
//Class instance to invoke it through
ClassName objectInstance;
//Invocation
int result = (objectInstance.*callback)(1.0f);
}
//This method performs work using an object pointer
void DoWorkPointer(CallbackType callback)
{
//Class pointer to invoke it through
ClassName * pointerInstance;
//Invocation
int result = (pointerInstance->*callback)(1.0f);
}
int main(int argc, char ** argv)
{
//Pass in SomeCallback to the DoWork
DoWorkObject(&ClassName::Method);
DoWorkPointer(&ClassName::Method);
}
Scott Meyers给出了一个很好的例子：
class GameCharacter;
int defaultHealthCalc(const GameCharacter& gc);
class GameCharacter
{
public:
typedef std::function<int (const GameCharacter&)> HealthCalcFunc;
explicit GameCharacter(HealthCalcFunc hcf = defaultHealthCalc)
: healthFunc(hcf)
{ }
int healthValue() const { return healthFunc(*this); }
private:
HealthCalcFunc healthFunc;
};
我认为这个例子说明了一切。
std::function<>是编写C ++回调的“现代”方式。