C++11新特性之二——std::bind std::function 高级用法

/*
* File:   main.cpp
* Author: Vicky.H
* Email:  eclipser@163.com
*/
#include <iostream>
#include <functional>
#include <typeinfo>
#include <string.h>

int add1(int i, int j, int k) {
return i + j + k;
}

class Utils {
public:
Utils(const char* name) {
strcpy(_name, name);
}

// 类的成员函数
void sayHello(const char* name) const {
std::cout << _name << " say: hello " << name << std::endl;
}

// 类的静态函数
static int getId() {
return 10001;
}

// 运算符
int operator()(int i, int j, int k) const {
return i + j + k;
}

private:
char _name[32];
};

/*
*  函数绑定
*/
int main(void) {

// 绑定全局函数
auto add2 = std::bind(add1, std::placeholders::_1, std::placeholders::_2, 10);
// 函数add2 = 绑定add1函数，参数1不变，参数2不变，参数3固定为10.
std::cout << typeid(add2).name() << std::endl;
std::cout << "add2(1,2) = " << add2(1, 2) << std::endl;

std::cout << "\n---------------------------" << std::endl;

// 绑定成员函数，没有提供默认值，使用占位符
Utils utils("Vicky");
auto sayHello = std::bind(&Utils::sayHello, utils/*调用者*/, std::placeholders::_1/*参数1*/);
sayHello("Jack");

// 绑定成员函数的时候提供了默认值
auto sayHelloToLucy = std::bind(&Utils::sayHello, utils/*调用者*/, "Lucy"/*固定参数1*/);
sayHelloToLucy();

// 绑定静态成员函数
auto getId = std::bind(&Utils::getId);
std::cout << getId() << std::endl;

std::cout << "\n---------------------------" << std::endl;

// 绑定operator函数
auto add100 = std::bind(&Utils::operator (), utils, std::placeholders::_1, std::placeholders::_2, 100);
std::cout << "add100(1, 2) = " << add100(1, 2) << std::endl;

// 注意：无法使用std::bind()绑定一个重载函数

return 0;
}

#include <iostream>
#include <typeinfo>

void sayHello() {
std::cout << "Hello world !" << std::endl;
}

int sum(int i, int j, int k) {
return i + j + k;
}

template <typename T>
class Func {
public:

Func(T fun) {
if (!fun) {
throw "fun nullptr";
}
_fun = fun;
}
/*
* 通过多个函数模板来实现可变参数的函数调用,
* @param R : 返回值类型
* @param A1，A2，A3，A4，A5 ：参数
*
*/
template<typename R, typename A1, typename A2, typename A3, typename A4, typename A5>
R Call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
return _fun(a1, a2, a3, a4, a5);
}

template<typename R, typename A1, typename A2, typename A3, typename A4>
R Call(A1 a1, A2 a2, A3 a3, A4 a4) {
return _fun(a1, a2, a3, a4);
}

template<typename R, typename A1, typename A2, typename A3>
R Call(A1 a1, A2 a2, A3 a3) {
return _fun(a1, a2, a3);
}

template<typename R, typename A1, typename A2>
R Call(A1 a1, A2 a2) {
return _fun(a1, a2);
}

template<typename R, typename A1>
R Call(A1 a1) {
return _fun(a1);
}

template<typename R>
R Call() {
return _fun();
}

void Call() {
_fun();
}

private:
T _fun;
};

//------------------------------------------------------------------

// 需要引入 函数对象 头文件
#include <functional>

/*
* @param R:返回值类型
* @param ... :可变参数模板
*/
template<typename R = void, typename... Args>
class Fn {
public:
Fn(std::function<R(Args...)> fun) : _fun(fun) {
}

R operator()(Args... args) {
return _fun(args...);
}
private:
std::function<R(Args...) > _fun;
};

/*
* 将函数注册到对象中，通过对象直接调用
*/
int main(void) {

//使用 含有多个不同参数的模板函数 进行注册
Func<void(*)() > sayHelloFunc(sayHello);
sayHelloFunc.Call();

Func<int (*)(int, int, int) > sumFunc(sum);
std::cout << "sumFunc.Call<int>(1, 2, 3) : " << sumFunc.Call<int>(1, 2, 3) << std::endl;

std::cout << "\n---------------------------" << std::endl;

Fn<> sayHelloFn(sayHello);
sayHelloFn();

Fn<int, int, int, int> sumFn(sum);
std::cout << "sumFn(1, 2, 3) : " << sumFn(1, 2, 3) << std::endl;

std::cout << "\n---------------------------" << std::endl;

return 0;
}