C ++中的回调函数


Answers:


449

注意:大多数答案都涵盖了函数指针,这是在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 对象
  • Lambda表达式
  • 绑定表达式
  • 函数对象(带有重载函数调用运算符的类operator()

* 注意:指向数据成员的指针也是可以调用的,但是根本没有调用任何函数。

详细编写回调的几种重要方法

  • X.1在本文中“编写”回调是指声明和命名回调类型的语法。
  • X.2“调用”回调是指调用那些对象的语法。
  • X.3“使用”回调是指使用回调将参数传递给函数时的语法。

注意:从C ++ 17开始,f(...)可以编写like这样的调用,该调用std::invoke(f, ...)也处理指向成员大小写的指针。

1.函数指针

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

让我们有一个简单的功能foo

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

1.1编写函数指针/类型表示法

函数指针类型具有符号

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

其中一个名为函数指针类型的样子

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;

using声明给我们的选项,以使事情更易读一点点,因为typedeff_int_t也可以写为:

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::*)(parameter_type_1, parameter_type_2, parameter_type_3)
// i.e. a pointer to C::foo has the type
int (C::*) (int)

类似于函数指针的成员函数命名指针如下所示:

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;

示例:声明一个函数,该函数将指向成员函数回调指针作为其参数之一:

// 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可以使用class的成员函数指针来调用采用class的成员函数指针的回调函数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对象(header <functional>

std::function班是一个多态函数包装到存储,复制或调用可调用。

3.1编写std::function对象/类型表示法

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

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::functionoperator()定义了可用于调用其目标的类。

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

注意:包含的输出打印为templated类型推断出的类型名称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;
}

35
@BogeyJammer:如果您没有注意到:答案分为两个部分。1.关于“回调”的一般说明,并举一个小例子。2.各种不同的可调用对象以及使用回调编写代码的方式的完整列表。欢迎您不要详细研究或阅读整个答案,而只是因为您不想获得详细的视图,所以答案不是无效或“残酷地复制”是不是这样。主题是“ c ++回调”。即使第1部分适合OP,其他人也可能觉得第2部分有用。请随意指出第一部分的任何信息或建设性批评,而不是-1。
Pixelchemist

1
第1部分不太适合初学者,而且不够清晰。说它没能学到我一些东西,我就不会更具建设性。第2部分并没有被要求,尽管您假装它很有用,但您仍然假装它很有用,尽管事实上它通常是在专用文档中首先找到这种详细信息的事实。我绝对会留下反对意见。一次投票代表个人意见,因此请接受并尊重。
Bogey Jammer

24
@BogeyJammer我不是编程新手,但是我是“现代c ++”的新手。这个答案为我提供了我需要推理的确切上下文,尤其是关于c ++。OP可能没有要求提供多个示例,但是SO习惯上如此,这是对教育愚人世界的无休止的探索,要求列举所有可能的解决方案。如果它读起来像一本书,则我唯一的建议是通过阅读其中一些内容来进行一些练习。
dcow

int b = foobar(a, foo); // call foobar with pointer to foo as callback,这是错字吧?foo应该是可以使AFAIK正常工作的指针。
konoufo

@konoufo:[conv.func]C ++ 11标准的说:“ 函数类型T的左值可以转换为指针“ T的类型”的prvalue。结果是指向该函数的指针。 “这是标准转换,因此隐式发生。一个人(当然)可以在这里使用函数指针。
Pixelchemist

160

还有执行回调的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);
}

1
类方法示例中有错误。调用应为:(instance。* callback)(1.0f)
CarlJohnson 2012年

感谢您指出这一点。我将同时添加说明通过对象和对象指针进行调用的方法。
拉蒙·扎拉祖阿·B

3
这有std :: tr1:function的缺点,因为回调是按类输入的;当执行调用的对象不知道要调用的对象的类时,使用C样式的回调是不切实际的。
2013年

我如何在不typedef使用回调类型的情况下做到这一点?可能吗
托马什Zato -恢复莫妮卡

1
是的你可以。typedef只是语法糖,以使其更具可读性。如果没有typedef,函数指针的DoWorkObject的定义将是:void DoWorkObject(int (*callback)(float))。对于成员指针将是:void DoWorkObject(int (ClassName::*callback)(float))
Ramon Zarazua B.

68

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 ++回调的“现代”方法。


1
出于兴趣,SM将此例子放在哪本书中?干杯:)
sam-w

5
我知道这很旧,但是因为我几乎开始这样做了,并且最终在我的设置(mingw)上不起作用,如果您使用的是GCC版本<4.x,则不支持此方法。我正在使用的某些依赖项在gcc版本> = 4.0.1中没有大量工作就无法编译,因此我坚持使用良好的老式C风格回调,但效果很好。
OzBarry 2012年

38

回调函数是传递到一个程序中,并呼吁在由其所传递的例程的某一点的方法。

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

例如,如果要使用文件夹中的文件,则可以使用自己的例程调用API函数,并且例程将在指定文件夹中的每个文件中运行一次。这使API非常灵活。


63
这个答案确实不会使普通程序员知道他不知道的任何内容。我在学习C ++的同时还熟悉许多其他语言。总的来说,回调与我无关。
托马什Zato -恢复莫妮卡

17

接受的答案非常有用并且非常全面。但是,OP指出

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

因此,从C ++ 11开始,您std::function不再需要函数指针和类似的东西:

#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<int (const std::string&)>将该函数描述为将调用该函数的输入参数。


在上述所有答案中,这使我了解了什么是回调以及如何使用它们。谢谢。
Mehar Charan Sahai

@MeharCharanSahai很高兴听到它:)不客气。
Miljen Mikic,

9

C ++中没有明确的回调函数概念。回调机制通常是通过函数指针,函子对象或回调对象来实现的。程序员必须明确设计和实现回调功能。

根据反馈进行编辑:

尽管这个答案收到了负面的反馈,但这并没有错。我将尽力更好地解释我的来历。

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

但是,回调函数和函数指针不是同义词。函数指针是一种语言机制,而回调函数是一种语义概念。函数指针不是实现回调函数的唯一方法-您还可以使用函子,甚至可以使用花园类的虚函数。使函数调用回调的并不是用于识别和调用函数的机制,而是调用的上下文和语义。说什么是回调函数,则意味着调用函数和被调用的特定函数之间的分隔比正常情况要大,在调用者和被调用者之间的概念耦合更松散,而调用者对所调用的内容具有显式控制。

例如,IFormatProvider的.NET文档说“ GetFormat是一种回调方法”,尽管它只是一个常规接口方法。我认为没有人会争辩说所有虚拟方法调用都是回调函数。使GetFormat成为回调方法的原因不是其传递或调用方式的机制,而是调用者选择将调用哪个对象的GetFormat方法的语义。

某些语言包括具有显式回调语义的功能,这些语义通常与事件和事件处理相关。例如,C#的事件类型具有明确的语法和语义,这些语法和语义围绕回调的概念进行了专门设计。Visual Basic具有其Handles子句,该子句在抽象化委托或函数指针的概念时明确地将方法声明为回调函数。在这些情况下,回调的语义概念已集成到语言本身中。

另一方面,C和C ++ 几乎没有显式地嵌入回调函数的语义概念。那里有机制,没有集成的语义。您可以很好地实现回调函数,但是要获得更复杂的功能(包括显式回调语义),您必须在C ++提供的功能之上构建它,例如Qt对Signals和Slots所做的事情。

简而言之,C ++拥有实现回调所需的功能,通常很容易且琐碎地使用函数指针。它没有的是关键字和功能,这些关键字和功能的语义特定于回调,例如raiseemitHandlesevent + =等。如果您来自具有这些元素类型的语言,则C ++中的本机回调支持会感到绝望。


1
幸运的是,这不是我访问此页面时阅读的第一个答案,否则我会立即反弹!
ubugnu 2014年

6

回调函数是C标准的一部分,因此也是C ++的一部分。但是,如果您使用的是C ++,我建议您改用观察者模式http : //en.wikipedia.org/wiki/Observer_pattern


1
回调函数不一定与通过作为参数传递的函数指针执行函数同义。根据某些定义,术语回调函数还带有其他语义,可以将刚刚发生的事情或应该发生的时间通知其他代码。从这个角度来看,回调函数不是C标准的一部分,但可以使用作为标准一部分的函数指针轻松实现。
Darryl 2014年

3
“ C标准的一部分,因此也是C ++的一部分。” 这是一个典型的误会,但仍然有误解:-)
赎罪有限2015年

我必须同意。我将保持原样,因为如果现在更改它,只会引起更多的混乱。我的意思是说函数指针(!)是标准的一部分。我同意,说任何与之不同的说法都是误导。
AudioDroid

回调函数以什么方式成为“ C标准的一部分”?我不认为它支持函数和指向函数的指针这一事实意味着它专门将回调作为一种语言概念。此外,如上所述,即使它是准确的,也与C ++没有直接关系。当OP询问“何时及如何”在C ++中使用回调时(这是一个la脚,过于宽泛的问题,但尽管如此),这尤其无关紧要,而您的回答是仅链接的告诫,而是做一些不同的事情。
underscore_d

4

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

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

这是在C ++中使用回调的方法。假设有4个文件。每个类都有一对.CPP / .H文件。C1类是具有我们要回调的方法的类。C2回调C1的方法。在此示例中,回调函数采用1个参数,我为读者着想添加了该参数。该示例未显示任何实例化和使用的对象。此实现的一个用例是,当您有一个类将数据读取并存储到临时空间中,而另一个类对数据进行后期处理时。使用回调函数,对于读取的每一行数据,回调都可以对其进行处理。这种技术减少了所需的临时空间的开销。这对于返回大量数据然后必须进行后处理的SQL查询特别有用。

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

0

Boost的signals2允许您以线程安全的方式订阅通用成员函数(没有模板!)。

示例:文档视图信号可用于实现灵活的文档视图体系结构。该文档将包含每个视图可以连接到的信号。以下Document类定义了一个支持多种视图的简单文本文档。请注意,它存储一个信号,所有视图都将连接到该信号。

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

接下来,我们可以开始定义视图。下面的TextView类提供了文档文本的简单视图。

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

0

接受的答案很全面,但与我只想在此处举例说明的问题有关。我有一个很久以前写的代码。我想按顺序遍历一棵树(左节点然后是根节点,然后是右节点),每当我到达一个节点时,我都希望能够调用任意函数,以便它可以执行所有操作。

void inorder_traversal(Node *p, void *out, void (*callback)(Node *in, void *out))
{
    if (p == NULL)
        return;
    inorder_traversal(p->left, out, callback);
    callback(p, out); // call callback function like this.
    inorder_traversal(p->right, out, callback);
}


// Function like bellow can be used in callback of inorder_traversal.
void foo(Node *t, void *out = NULL)
{
    // You can just leave the out variable and working with specific node of tree. like bellow.
    // cout << t->item;
    // Or
    // You can assign value to out variable like below
    // Mention that the type of out is void * so that you must firstly cast it to your proper out.
    *((int *)out) += 1;
}
// This function use inorder_travesal function to count the number of nodes existing in the tree.
void number_nodes(Node *t)
{
    int sum = 0;
    inorder_traversal(t, &sum, foo);
    cout << sum;
}

 int main()
{

    Node *root = NULL;
    // What These functions perform is inserting an integer into a Tree data-structure.
    root = insert_tree(root, 6);
    root = insert_tree(root, 3);
    root = insert_tree(root, 8);
    root = insert_tree(root, 7);
    root = insert_tree(root, 9);
    root = insert_tree(root, 10);
    number_nodes(root);
}

1
它如何回答这个问题?
Rajan Sharma

您知道已接受的答案是正确且全面的,我认为一般来说无需多说。但是我发布了一个我使用回调函数的例子。
Ehsan Ahmadi
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.