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 ;
    }   
 
    // 运算符
    int operator()(int i, int j, int k) const {
        return i + j + k;
    }  
 
private:
    char _name[];
};  
 
/*
 *  函数绑定
 */
int main(void) {  
 
    // 绑定全局函数
    auto add2 = std::bind(add1, std::placeholders::_1, std::placeholders::_2, );
    // 函数add2 = 绑定add1函数，参数1不变，参数2不变，参数3固定为10.
    std::cout << typeid(add2).name() << std::endl;
    std::cout << "add2(1,2) = " << add2(, ) << 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, );
    std::cout << "add100(1, 2) = " << add100(, ) << std::endl;  
 
    // 注意：无法使用std::bind()绑定一个重载函数  
 
    return ;
} 

#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>(, , ) << 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(, , ) << std::endl;  
 
    std::cout << "\n---------------------------" << std::endl;  
 
    return ;
}