C ++中的回调函数

时间：2010-02-19 17:16:47

标签： c++ callback function-pointers

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

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

10 个答案:

答案 0 :(得分：355)

注意：大多数答案都涵盖了函数指针，这是实现＆＃34;回调＆＃34;的一种可能性。 C ++中的逻辑，但到目前为止并不是我认为最有利的。

什么是回调（？）以及使用它们的原因（！）

回调是一个类或函数接受的 callable （见下文），用于根据该回调自定义当前逻辑。

使用回调的一个原因是编写泛型代码，该代码与被调用函数中的逻辑无关，并且可以在不同的回调中重复使用。

标准算法库<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）中的 callables 是什么？

有关更正式的说明，请参阅cppreference上的C++ concepts: Callable。

回调功能可以通过C ++（11）中的几种方式实现，因为几个不同的东西结果是可调用* ：

  • 函数指针（包括指向成员函数的指针）
  • std::function个对象
  • Lambda表达式
  • 绑定表达式
  • 函数对象（具有重载函数调用操作符operator()的类）

* 注意：指向数据成员的指针也是可调用的，但根本不调用任何函数。

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

  • X.1＆＃34;写作＆＃34;此帖子中的回调意味着声明并命名回调类型的语法。
  • X.2＆＃34; Calling＆＃34;回调是指调用这些对象的语法。
  • X.3＆＃34;使用＆＃34;回调是指使用回调将参数传递给函数时的语法。

注意：从C ++ 17开始，像f(...)这样的调用可以写成std::invoke(f, ...)，它也处理指向成员案例的指针。

1。函数指针

功能指针是最简单的＆＃39; （在一般性方面;在可读性方面可以说是最差的）类型，回调可以有。

让我们有一个简单的函数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声明为我们提供了让事情更具可读性的选项，因为typedef的{​​{1}}也可以写成：

f_int_t

在哪里（至少对我而言）using f_int_t = int(*)(int); 是新类型别名更清楚，并且对函数指针类型的识别也更容易

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

f_int_t

1.2回拨呼号

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

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

可以使用函数指针调用带函数指针的回调函数。

使用带函数指针回调的函数非常简单：

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.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

可能的回调可能是

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

2。指向成员函数的指针

指向成员函数（某些类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}; ）的指针是一种特殊类型的（甚至更复杂的）函数指针，它需要类型为C的对象才能进行操作。

C

2.1编写指向成员函数/类型表示法的指针

某些类struct C { int y; int foo(int x) const { return x+y; } }; 的指向成员函数类型的指针具有符号

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;

2.2回拨呼号

通过对解除引用的指针使用成员访问操作，可以针对类型为// 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); 的对象调用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

2.3回调使用符号和兼容类型

可以使用类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); } 的成员函数指针调用带有类T的成员函数指针的回调函数。

使用一个带成员函数回调指针的函数是-in类似于函数指针 - 也很简单：

T

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）

<functional>类是用于存储，复制或调用callables的多态函数包装器。

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

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

std::function

3.2回叫呼号

类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; 已定义std::function，可用于调用其目标。

operator()

3.3回调使用符号和兼容类型

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 } 回调比函数指针或指向成员函数的指针更通用，因为可以传递不同的类型并将其隐式转换为std::function对象。

3.3.1函数指针和指向成员函数的指针

函数指针

std::function

或指向成员函数的指针

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

可以使用。

3.3.2 Lambda表达式

lambda表达式的未命名闭包可以存储在int a = 2; C my_c{7}; // aggregate initialization int b = stdf_C_foobar(a, c, &C::foo); // b == 11 == ( 2 + (7+2) ) 对象中：

std::function

3.3.3 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) 个词组

可以传递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 )

3.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 ) 重载的类的对象也可以存储在operator()对象中。

std::function

3.4示例

更改函数指针示例以使用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 ) 

std::function

为该函数提供了更多的实用工具，因为（见3.3）我们有更多的可能性来使用它：

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

4。模板化回调类型

使用模板，调用回调的代码可能比使用// 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.1编写（类型表示法）和调用模板化回调

通过使用模板进行推广，即进一步的std::function代码可以实现：

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

4.2使用模板化回调和兼容类型的示例

模板化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; } 回调方法std::function的兼容类型与上述类型相同（参见3.4）。

然而，使用模板化版本，使用的回调的签名可能会稍微改变：

stdf_transform_every_int_templ

注意：// 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

答案 1 :(得分：151)

还有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);
}

答案 2 :(得分：66)

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

答案 3 :(得分：37)

Callback function是一个传递给例程的方法，并在某个时刻被传递给它的例程调用。

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

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

答案 4 :(得分：11)

接受的答案非常有用且非常全面。但是，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&)>，它描述了这个函数作为将调用它的函数的输入参数

答案 5 :(得分：8)

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

根据反馈进行修改：

尽管这个答案得到了负面的反馈，但这并没有错。我会尝试更好地解释我来自哪里。

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

但是，回调函数和函数指针不是同义词。函数指针是一种语言机制，而回调函数是一种语义概念。函数指针不是实现回调函数的唯一方法 - 您还可以使用仿函数甚至花园种类的虚函数。使函数调用回调的原因不是用于标识和调用函数的机制，而是调用的上下文和语义。说某事是回调函数意味着调用函数和被调用的特定函数之间的分离大于正常，调用者和被调用者之间的概念耦合更松散，调用者可以明确控制被调用的内容。宽松的概念耦合和调用者驱动的函数选择的模糊概念使得某些东西成为回调函数，而不是使用函数指针。

例如，IFormatProvider的.NET文档说“GetFormat是一种回调方法”，即使它只是一种普通的接口方法。我认为没有人会认为所有虚方法调用都是回调函数。是什么让GetFormat成为一个回调方法，不是传递或调用它的机制，而是调用者调用哪个对象的GetFormat方法的语义。

某些语言包含具有显式回调语义的功能，通常与事件和事件处理相关。例如，C＃具有事件类型，其语法和语义是围绕回调的概念明确设计的。 Visual Basic有 Handles 子句，它显式地声明了一个方法作为回调函数，同时抽象出委托或函数指针的概念。在这些情况下，回调的语义概念被集成到语言本身中。

另一方面，C和C ++几乎没有明确地嵌入回调函数的语义概念。机制在那里，集成的语义不是。你可以很好地实现回调函数，但是要获得更复杂的东西，其中包括显式回调语义，你必须在C ++提供的基础上构建它，例如Qt对它们Signals and Slots的作用。

简而言之，C ++拥有实现回调所需的功能，通常可以非常轻松地使用函数指针。它没有的是关键字和功能，其语义特定于回调，例如 raise ， emit ， Handles ， event + = ，等等。如果您来自具有这些类型元素的语言，C ++中的本机回调支持将会感到绝对。

答案 6 :(得分：6)

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

答案 7 :(得分：4)

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

在C ++中，最好让回调函数调用一个classes方法。执行此操作时，您可以访问成员数据。如果使用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);
}

答案 8 :(得分：0)

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

  

示例：Document-View Signals可用于实现灵活性   文档 - 视图体系结构。该文件将包含一个信号   每个视图可以连接。以下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;
};

答案 9 :(得分：-1)

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

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);
}
相关问题
最新问题