#include <iostream>
#include <string>
#include <boost\bind.hpp>

using namespace std;
using namespace boost;

int func(int x, int y)
{
return x + y;
}

struct struct_func
{
int func(int x, int y)
{
return x*y;
}
};

int main(int argc, char *argv[])
{
// 绑定普通函数
auto ref = boost::bind(func, 20, 10)();
cout << "绑定调用: " << ref << endl;

// 绑定函数指针
typedef decltype(&func) f_type;
f_type ptr_a = func;
int x = 100, y = 200;
cout << "绑定调用: " << boost::bind(ptr_a, _1, _2)(x, y) << endl;
cout << "传入单参数: " << boost::bind(ptr_a, _1, 20)(10) << endl;

// 绑定成员函数
struct_func ptr_b;
auto struct_ref = boost::bind(&struct_func::func, ptr_b, _1, _2)(10, 10);
cout << "绑定调用: " << struct_ref << endl;

getchar();
}

function 参数绑定

#include <iostream>
#include <string>
#include <boost\function.hpp>
#include <boost\bind.hpp>

using namespace std;


float MyFunc(int x, int y)
{
return x + y;
}

struct MyStruct
{
int add(int x, int y)
{
return x *y;
}
};


int main(int argc,char *argv[])
{
// function 指向普通函数
boost::function<float(int, int)> function_ptr;

function_ptr = MyFunc; // 将MyFunc用ptr来存储
if (function_ptr)
{
cout << "调用指针: " << function_ptr(10, 20) << endl;
}
function_ptr = 0;

// function 指向成员函数
boost::function<int(int, int)> struct_ptr;
MyStruct sc;

struct_ptr = boost::bind(&MyStruct::add,&sc, _1, _2);
cout <<"调用指针: " << struct_ptr(10, 20) << endl;
getchar();
}

ref库的使用

#include <iostream>
#include <string>
#include <vector>
#include <boost\bind.hpp>
#include <boost\function.hpp>

using namespace std;

template<typename T>
struct summary
{
typedef void result_type;
T sum;

summary(T v = T()) : sum(v){}
void operator()(T const &x)
{
sum += x;
}
};



int main(int argc, char *argv[])
{
vector<int> vect = { 1, 3, 5, 7, 9 };
summary<int> s; // 定义有状态函数对象

boost::function<void(int const&)> func(ref(s)); // function 包装引用

std::for_each(vect.begin(), vect.end(), func);
cout << "求和结果: " << s.sum << endl;

getchar();
}

使用普通回调函数

#include <iostream>
#include <string>
#include <vector>
#include <boost\bind.hpp>
#include <boost\function.hpp>

using namespace std;

// 定义回调函数
void call_back_func(int x)
{
cout << "执行回调函数(数值翻倍): " << x * 2 << endl;
}

class MyClass
{
private:
typedef boost::function<void(int)> func_ptr; // function 类型定义
func_ptr func;
int n;

public:
// 定义构造函数
MyClass(int i) :n(i){}

// 存储回调函数
template<typename CallBack>
void accept(CallBack call)
{
func = call;
}
// 运行函数
void run()
{
func(n);
}
};

int main(int argc, char *argv[])
{
MyClass ptr(10);

ptr.accept(call_back_func); // 传入回调函数
ptr.run();

getchar();
}

带状态的回调函数,ref库传递引用

#include <iostream>
#include <string>
#include <vector>
#include <boost\bind.hpp>
#include <boost\function.hpp>

using namespace std;

class MyClass
{
private:
typedef boost::function<void(int)> func_ptr; // function 类型定义
func_ptr func;
int n;

public:
// 定义构造函数
MyClass(int i) :n(i){}

// 存储回调函数
template<typename CallBack>
void accept(CallBack call)
{
func = call;
}
// 运行函数
void run()
{
func(n);
}
};


class call_back_obj
{
private:
int x;

public:
call_back_obj(int i) :x(i){}
void operator()(int i)
{
cout << "回调函数: " << i * x << endl;
}
};


int main(int argc, char *argv[])
{
MyClass ptr(10);
call_back_obj call_obj(2);

ptr.accept(ref(call_obj));

ptr.run();
ptr.run();

getchar();
}

通过类绑定多个callback

#include <iostream>
#include <string>
#include <vector>
#include <boost\bind.hpp>
#include <boost\function.hpp>

using namespace std;

class MyClass
{
private:
typedef boost::function<void(int)> func_ptr; // function 类型定义
func_ptr func;
int n;

public:
// 定义构造函数
MyClass(int i) :n(i){}

// 存储回调函数
template<typename CallBack>
void accept(CallBack call)
{
func = call;
}
// 运行函数
void run()
{
func(n);
}
};

class call_back_factory
{
public:
void call_back_func_a(int x)
{
cout << "回调函数1: " << x * 2 << endl;
}

void call_back_func_b(int x, int y)
{
cout << "回调函数2: " << x * y << endl;
}
};

int main(int argc, char *argv[])
{
MyClass ptr(10);
call_back_factory factory;

ptr.accept(bind(&call_back_factory::call_back_func_a, factory, _1));
ptr.run();

ptr.accept(bind(&call_back_factory::call_back_func_b, factory, _1, 200));
ptr.run();
getchar();
}

信号与槽 一个信号关联多个槽,信号发出后,槽函数相应。

#include <iostream>
#include <string>
#include <boost\signals2.hpp>

using namespace std;

void slots_a()
{
cout << "slots_a called" << endl;
}

void slots_b()
{
cout << "slots_b called" << endl;
}

int main(int argc, char *argv[])
{

// 简单的链接
boost::signals2::signal<void()> sig; // 定义信号对象

sig.connect(&slots_a);
sig.connect(&slots_b);

sig(); // 发射信号

getchar();
}

信号的返回值

#include <iostream>
#include <string>
#include <boost\signals2.hpp>

using namespace std;

template<int T,int C>
struct slots
{
int operator()(int x)
{
return x + T + C;
}
};

int main(int argc, char *argv[])
{

boost::signals2::signal<int(int)> sig;

// 0 代表组
sig.connect(0,slots<10,20>());

int ref = *sig(5);
cout << "获取返回值: " << ref << endl;

getchar();
}

合并器的使用

#include <iostream>
#include <string>
#include <numeric>
#include <boost\signals2.hpp>

using namespace std;


template<int T, int C>
struct slots
{
int operator()(int x)
{
return x + T + C;
}
};


template<typename T>
class combiner
{
T v;

public:
typedef std::pair<T, T> result_type;
combiner(T t = T()) : v(t){} // 构造函数

template<typename InputIterator>
result_type operator()(InputIterator begin, InputIterator end) const
{
// 为空则返回0
if (begin == end)
return result_type();

vector<T> vec(begin, end); // 容器保存插槽调用结果

T sum = std::accumulate(vec.begin(), vec.end(), v);
T max = *std::max_element(vec.begin(), vec.end());

return result_type(sum, max);
}
};

int main(int argc, char *argv[])
{
boost::signals2::signal<int(int), combiner<int>> sig;

sig.connect(0, slots<10, 20>());

auto x = sig(2);
cout << x.first << x.second << endl;;
getchar();
}

版权声明:本博客文章与代码均为学习时整理的笔记,文章 [均为原创] 作品,转载请 [添加出处] ,您添加出处是我创作的动力!