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 << "
---------------------------" << 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 << "
---------------------------" << 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 << "
---------------------------" << 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 << "
---------------------------" << std::endl;  
  
    return 0;  
}