C ++中的回调函数 | 码农家园

Callback functions in C++

在C++中，何时和如何使用回调函数？

编辑：我想看一个写回调函数的简单示例。

注意：大多数答案覆盖函数指针，这是C++中实现"回调"逻辑的一种可能，但到目前为止，我认为不是最有利的。好的。什么是回调(？)为什么要用它们！！)

回调是类或函数接受的可调用(请参阅下文)，用于根据该回调自定义当前逻辑。好的。

使用回调的一个原因是编写与被调用函数中的逻辑无关的通用代码，可以与不同的回调一起重用。好的。

标准算法库的许多函数使用回调。例如，for_each算法对一系列迭代器中的每个项应用一元回调：好的。

1
2
3
4
5
6
7
8

template<class InputIt, class UnaryFunction>
UnaryFunction for_each(InputIt first, InputIt last, UnaryFunction f)
{
for (; first != last; ++first) {
f(*first);
}
return f;
}

它可以用于首先递增，然后通过传递适当的可调用文件来打印向量，例如：好的。

1
2
3
4

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 <<""; });

哪些版画好的。

1	5 6.2 8 9.5 11.2

回调的另一个应用程序是通知调用者某些事件，这使静态/编译时具有一定的灵活性。好的。

我个人使用的是本地优化库，它使用两种不同的回调：好的。

如果需要基于输入值向量的函数值和渐变，则调用第一个回调(逻辑回调：函数值确定/渐变派生)。
对每个算法步骤调用第二个回调一次，并接收有关算法收敛性的某些信息(通知回调)。

因此，库设计者不负责决定给程序员的信息会发生什么。通过通知回调，他不必担心如何实际确定函数值，因为它们是由逻辑回调提供的。由于库用户的原因，正确处理这些问题是一项任务，可以使库保持苗条和更通用。好的。

此外，回调可以启用动态运行时行为。好的。

想象一下某种游戏引擎类，它有一个被激发的函数，每次用户按下键盘上的一个按钮和一组控制游戏行为的函数。通过回调，您可以在运行时重新决定将采取什么操作。好的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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中的回调，以在按下某个键时获得所需的行为。如果玩家选择改变跳跃按钮，引擎会呼叫好的。

1	game_core_instance.update_keybind(newly_selected_key, &player_jump);

因此，在下次按下该按钮时，更改对key_pressed的调用行为(该调用称为player_jump)。好的。C++中的哪些是可调用的(11)？

参见C++概念：在CPULIST上可调用更正式的描述。好的。

回调功能可以在C++(11)中以多种方式实现，因为几种不同的事物被证明是可调用的*：好的。型

std::function

operator()

型

_{>*注意：指向数据成员的指针也可以调用，但根本没有调用任何函数。_{好的。型详细编写回调的几种重要方法}}

百万千克1x.1"写入"本帖中的回调意味着声明和命名回调类型的语法。百万千克1百万千克1x.2"调用"回调是指调用这些对象的语法。百万千克1百万千克1x.3"使用"回调是指使用回调向函数传递参数时的语法。百万千克1

型

注意：在C++ 17中，像f(...)那样的调用可以被写为EDCOX1(3)，它也处理指向成员实例的指针。好的。型1.函数指针

函数指针是回调可以具有的"最简单"(就一般性而言；就可读性而言，可能是最差的)类型。好的。型

让我们有一个简单的函数foo：好的。型

1	int foo (int x) { return 2+x; }

1.1编写函数指针/类型符号

函数指针类型具有符号好的。型

1
2
3

return_type (*)(parameter_type_1, parameter_type_2, parameter_type_3)
// i.e. a pointer to foo has the type:
int (*)(int)

号

其中命名函数指针类型将类似好的。型

1
2
3
4
5
6
7
8
9
10

return_type (* name) (parameter_type_1, parameter_type_2, parameter_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;

由于f_int_t的typedef也可以写成：好的。型

1	using f_int_t = int(*)(int);

。

其中(至少对我来说)更清楚的是，f_int_t是新的类型别名，对函数指针类型的识别也更容易好的。型

使用函数指针类型回调的函数声明将是：好的。型

1
2
3
4
5

// 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回叫表示法

调用符号遵循简单的函数调用语法：好的。型

1
2
3
4
5
6
7
8
9

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回调使用符号和兼容类型

可以使用函数指针调用接受函数指针的回调函数。好的。型

使用接受函数指针回调的函数相当简单：好的。型

1
2
3
4

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示例

编写的函数不能依赖于回调的工作方式：好的。型

1
2
3
4
5
6
7

void tranform_every_int(int * v, unsigned n, int (*fp)(int))
{
for (unsigned i = 0; i < n; ++i)
{
v[i] = fp(v[i]);
}
}

在可能的情况下，回调可能是好的。型

1 2	int double_int(int x) { return 2x; } int square_int(int x) { return xx; }

。

像这样使用好的。型

1
2
3
4
5

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类型的对象来操作。好的。型

1
2
3
4
5

struct C
{
int y;
int foo(int x) const { return x+y; }
};

。2.1向成员函数/类型符号写入指针

指向某个类T的成员函数类型的指针具有符号好的。型

1
2
3
4

// can have more or less parameters
return_type (T::*)(parameter_type_1, parameter_type_2, parameter_type_3)
// i.e. a pointer to C::foo has the type
int (C::*) (int)

号

其中，指向成员函数的命名指针(与函数指针类似)如下所示：好的。型

1
2
3
4
5
6
7
8
9
10
11

return_type (T::* name) (parameter_type_1, parameter_type_2, parameter_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;

号

示例：声明将指向成员函数回调的指针作为其参数之一的函数：好的。

1
2
3
4
5
6

// 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的指向成员函数的指针。注意：括号是必需的！好的。

1
2
3
4
5
6
7
8
9

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的指针也必须取消引用)：好的。

1
2
3
4
5
6
7
8
9
10
11
12
13

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的成员函数指针调用。好的。

使用一个接受指向成员函数回调的指针的函数——类似于函数指针——也非常简单：好的。

1
2
3

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

三。std::function对象(表头)

std::function类是一个多态函数包装器，用于存储、复制或调用可调用文件。好的。3.1编写std::function对象/类型符号

存储可调用对象的std::function对象的类型如下：好的。

1
2
3
4
5
6

std::function<return_type(parameter_type_1, parameter_type_2, parameter_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()，可用于调用其目标。好的。

1
2
3
4
5
6
7
8
9

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函数指针和指向成员函数的指针好的。

函数指针好的。

1
2
3

int a = 2;
int b = stdf_foobar(a, &foo);
// b == 6 ( 2 + (2+2) )

或指向成员函数的指针好的。

1
2
3
4

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对象中：好的。

1
2
3
4

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表达式的结果。例如，通过将参数绑定到函数指针调用：好的。

1
2
3
4
5
6
7
8

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 )

其中，还可以将对象绑定为用于调用指向成员函数的指针的对象：好的。

1
2
3
4

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对象中。好的。

1
2
3
4
5
6
7
8
9

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。好的。

1
2
3
4
5
6
7

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)我们有更多的可能性使用它：好的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// 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代码：好的。

1
2
3
4
5
6
7
8
9

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]);
}
}

如果回调类型的语法更为一般(也是最简单的)，则为普通的，可以推导出模板化参数：好的。

1
2
3
4
5
6
7
8
9
10
11
12

template<class F>
void transform_every_int_templ(int * v,
unsigned const n, F f)
{
std::cout <<"transform_every_int_templ<"
<< type_name<F>() <<">
";
for (unsigned i = 0; i < n; ++i)
{
v[i] = f(v[i]);
}
}

注意：包含的输出打印为模板化类型F推导的类型名。type_name的实施在本员额结束时给出。好的。

范围一元转换最普遍的实现是标准库的一部分，即std::transform，它还针对迭代类型进行模板化。好的。

1
2
3
4
5
6
7
8
9

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)。好的。

但是，使用模板化版本时，所用回调的签名可能会发生一些变化：好的。

1
2
3
4
5
6
7
8
9
10
11

// 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。好的。

1
2
3
4
5
6
7
8
9
10
11
12

// 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 <<"
";
}

transform_every_int_templ的普通模板化参数可以是所有可能的可调用类型。好的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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
6
7
8
9
10
11
12
13
14
15

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实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#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;
}

好啊。

相关讨论

不，这就像一个残酷的复制/粘贴文档的完整章节给经验丰富的程序员。它不会回答要求一个简单示例和回调概念解释的问题。我自己也是个初学者，这个答案完全无效。
@如果你没注意到：答案有两部分。1。"回调"的一般解释，用一个小例子。2。不同可调用文件的综合列表以及使用回调编写代码的方法。欢迎你不要深入研究细节或阅读整个答案，但仅仅是因为你不想要一个详细的视图，答案无效或"被残忍地复制"并不是这种情况。主题是"C++回调"。即使第1部分对于OP是可以的，其他人可能会发现第2部分是有用的。请随意指出第一部分(而不是-1)缺乏信息或建设性批评。
第一部分对初学者不够友好和清晰。我不能说它没能让我学到一些东西，从而更有建设性。第2部分没有被要求，淹没了页面，这是不可能的，即使你假装它是有用的，尽管事实上，它通常是在专门的文件中找到的，这些详细的信息是在第一时间寻找的。我绝对不会投反对票。一票代表个人意见，请接受并尊重。
BogeyJammer，我不是新的编程，但我是新的"现代C++"。这个答案给了我确切的背景，我需要解释回调角色扮演的角色，特别是C++。行动计划可能没有要求多个例子，但这是惯例，因此，在一个永不停息的探索，教育一个世界的傻瓜，列举所有可能的解决办法，一个问题。如果它读得太像一本书，我唯一能提供的建议就是通过阅读其中的几本来练习一下。
int b = foobar(a, foo); // call foobar with pointer to foo as callback，这是个打字错误，对吗？foo应该是一个指针，让它在afaik中工作。
KOOUFO：C++ 11标准中的EDOCX1 2表示："函数类型T的L值可以转换为一个值为T的指针。"结果是指向函数的指针。"这是一个标准转换，并且这样隐含地发生。"当然可以在这里使用函数指针。
我读到的最好的答案之一。
为什么是"参数"而不是"参数"？有意或连续打字但从未改正？

还有一种C方式进行回调：函数指针

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

//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);
}

现在，如果要将类方法作为回调传递，那么这些函数指针的声明具有更复杂的声明，例如：

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

//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给出了一个很好的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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;
};

我想这个例子说明了一切。

EDCOX1 0是编写C++回调的"现代"方式。

相关讨论

回调函数是一种方法，它被传递到一个例程中，并在某个时刻被传递给它的例程调用。

这对于制作可重用的软件非常有用。例如，许多操作系统API(如Windows API)大量使用回调。

例如，如果您想处理文件夹中的文件，您可以使用自己的例程调用API函数，并且您的例程在指定文件夹中的每个文件上运行一次。这使得API非常灵活。

相关讨论

公认的答案是非常有用的，非常全面。但是，操作状态

I would like to see a simple example to write a callback function.

所以，从C++ 11中，你有EDOCX1，0，所以不需要函数指针和类似的东西：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <functional>
#include <string>
#include <iostream>

void print_hashes(std::function<int (const std::string&)> hash_calculator) {
std::string strings_to_hash[] = {"you","saved","my","day"};
for(auto s : strings_to_hash)
std::cout << s <<":" << hash_calculator(s) << std::endl;
}

int main() {
print_hashes( [](const std::string& str) { /** lambda expression */
int result = 0;
for (int i = 0; i < str.length(); i++)
result += pow(31, i) * str.at(i);
return result;
});
return 0;
}

这个例子在某种程度上是真实的，因为您希望使用不同的哈希函数实现来调用函数print_hashes，为此，我提供了一个简单的例子。它接收一个字符串，返回一个int(所提供字符串的散列值)，语法部分需要记住的就是std::function，它将该函数描述为将调用它的函数的输入参数。

C++中没有一个显式的回调函数的概念。回调机制通常通过函数指针、函数对象或回调对象实现。程序员必须显式地设计和实现回调功能。

根据反馈编辑：

尽管这个答案得到了否定的反馈，但它并没有错。我会努力更好地解释我来自哪里。

C和C++具有实现回调函数所需的一切。实现回调函数的最常见和最简单的方法是将函数指针作为函数参数传递。

但是，回调函数和函数指针不是同义的。函数指针是一种语言机制，而回调函数是一种语义概念。函数指针不是实现回调函数的唯一方法，您还可以使用函数，甚至是各种各样的虚拟函数。使函数调用回调的不是用来标识和调用函数的机制，而是调用的上下文和语义。说什么是回调函数意味着调用函数和被调用的特定函数之间的分离比正常的大，调用方和被调用方之间的概念耦合更松散，调用方对被调用的内容有明确的控制。正是松散的概念耦合和调用驱动的函数选择的模糊概念使某些东西成为回调函数，而不是使用函数指针。

例如，iformatProvider的.NET文档说"getformat是一个回调方法"，尽管它只是一个运行的mill接口方法。我认为没有人会认为所有的虚拟方法调用都是回调函数。使getformat成为回调方法的不是它是如何传递或调用的机制，而是调用方选择将调用哪个对象的getformat方法的语义。

一些语言包括具有显式回调语义的特性，通常与事件和事件处理相关。例如，C具有事件类型，其语法和语义是围绕回调概念明确设计的。VisualBasic有自己的handles子句，它显式地将方法声明为回调函数，同时抽象掉委托或函数指针的概念。在这些情况下，回调的语义概念被集成到语言本身中。

另一方面，C和C++几乎没有显式地嵌入回调函数的语义概念。机制存在，集成语义不存在。你可以很好地实现回调函数，但是为了得到更复杂的东西，包括显式的回调语义，你必须在C++提供的基础之上建立它，比如QT用它们的信号和时隙做了什么。

简而言之，C++具有实现回调所需的功能，通常很容易和简单地使用函数指针。它没有的是关键字和特征，这些语义的语义对回调是特定的，例如提升、EIT、句柄、事件+=等。如果您来自一种具有这些类型元素的语言，则C++中的本机回调支持将感到中性化。

相关讨论

回调函数是C标准的一部分，因此也是C++的一部分。但是，如果您正在使用C++，我建议您使用观察者模式：HTTP://E.WiKiTo.Org/Wik/ObServyType模式。

相关讨论

请参见上面的定义，其中声明回调函数被传递给其他函数，并且在某个时刻被调用。

在C++中，回调函数调用类方法是可取的。执行此操作时，您可以访问成员数据。如果使用C方法定义回调，则必须将其指向静态成员函数。这不是很理想。

下面是如何在C++中使用回调的方法。假设4个文件。每个类都有一对.cpp/.h文件。类C1是具有我们要回调的方法的类。c2调用c1的方法。在这个例子中，回调函数采用了我为读卡器添加的1个参数。该示例不显示任何正在实例化和使用的对象。此实现的一个用例是，当您有一个类将数据读取并存储到临时空间中，另一个类对数据进行后处理时。使用回调函数，对于每一行数据，读取回调然后可以处理它。这种技术减少了所需临时空间的开销。对于返回大量数据的SQL查询尤其有用，这些数据随后必须进行后处理。

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

/////////////////////////////////////////////////////////////////////
// C1 H file

class C1
{
public:
C1() {};
~C1() {};
void CALLBACK F1(int i);
};

/////////////////////////////////////////////////////////////////////
// C1 CPP file

void CALLBACK C1::F1(int i)
{
// Do stuff with C1, its methods and data, and even do stuff with the passed in parameter
}

/////////////////////////////////////////////////////////////////////
// C2 H File

class C1; // Forward declaration

class C2
{
typedef void (CALLBACK C1::* pfnCallBack)(int i);
public:
C2() {};
~C2() {};

void Fn(C1 * pThat,pfnCallBack pFn);
};

/////////////////////////////////////////////////////////////////////
// C2 CPP File

void C2::Fn(C1 * pThat,pfnCallBack pFn)
{
// Call a non-static method in C1
int i = 1;
(pThat->*pFn)(i);
}

Boost的singals2允许您订阅通用成员函数(不带模板！)以一种安全的方式。

Example: Document-View Signals can be used to implement flexible
Document-View architectures. The document will contain a signal to
which each of the views can connect. The following Document class
defines a simple text document that supports mulitple views. Note that
it stores a single signal to which all of the views will be connected.

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

class Document
{
public:
typedef boost::signals2::signal<void ()> signal_t;

public:
Document()
{}

/* Connect a slot to the signal which will be emitted whenever
text is appended to the document. */
boost::signals2::connection connect(const signal_t::slot_type &subscriber)
{
return m_sig.connect(subscriber);
}

void append(const char* s)
{
m_text += s;
m_sig();
}

const std::string& getText() const
{
return m_text;
}

private:
signal_t m_sig;
std::string m_text;
};

Next, we can begin to define views. The following TextView class
provides a simple view of the document text.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class TextView
{
public:
TextView(Document& doc): m_document(doc)
{
m_connection = m_document.connect(boost::bind(&TextView::refresh, this));
}

~TextView()
{
m_connection.disconnect();
}

void refresh() const
{
std::cout <<"TextView:" << m_document.getText() << std::endl;
}
private:
Document& m_document;
boost::signals2::connection m_connection;
};