C++ 技术中心

   :: 首页 :: 联系 ::  :: 管理
  150 Posts :: 0 Stories :: 83 Comments :: 0 Trackbacks

公告

郑重声明:本BLOG所发表的原创文章,作者保留一切权利。必须经过作者本人同意后方可转载,并注名作者(天空)和出处(CppBlog.com)。作者Email:6549168@qq.com

留言簿(5)

搜索

  •  

最新随笔

最新评论

评论排行榜

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

/* 
 * File:   main2.cpp
 * Author: Vicky.H
 * Email:  eclipser@163.com
 
*/
#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;
    }

    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>

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 (*)(intintint) > 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<intintintint> sumFn(sum);
    std::cout << "sumFn(1, 2, 3) : " << sumFn(1, 2, 3) << std::endl;

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

    return 0;
}

Hello world !
sumFunc.Call<int>(1, 2, 3) : 6


---------------------------
Hello world !
sumFn(1, 2, 3) : 6


---------------------------

上面的例子非常有趣,使用了2种方案,将一个函数,注册到一个对象/仿函数中,并且通过一个对象/仿函数来直接调用调用。
例子显而易见的,第2种方案更佳简洁,并且对传递参数有明确的判断,当参数类型或数量不正确的时候,编译器将导致失败。
这种方案,可以将类的成员变量直接作为函数的参数使用,或者,如我:
http://blog.csdn.net/eclipser1987/article/details/23926395
这篇文章中,无法直接调用脚本函数类,有了好的解决办法。这个我将随后补充。

#include <list>
#include <functional>

template<typename Args>
class Fns
{
private:

    std::list<std::function<void(Args)> > _calls;

public:

    virtual ~Fns()
    {
        _calls.clear();
    }

    void connect(std::function<void(Args)> fct)
    {
        _calls.push_back(fct);
    }

    template<typename Object>
    void connect(Object* objectvoid (Object::*method)(Args))
    {
        _calls.push_back([object,method](Args args){(*object.*method)(args);});
    }

    template<typename Object>
    void connect(Object* objectvoid (Object::*method)(Argsconst)
    {
        _calls.push_back([object,method](Args args){(*object.*method)(args);});
    }

    template<typename Object>
    void connect(const Object* objectvoid (Object::*method)(Argsconst)
    {
        _calls.push_back([object,method](Args args){(*object.*method)(args);});
    }

    void emit(Args args)
    {
        for(auto call : _calls)
            call(args);
    }
};

#include <cstdio>
#include "Signal.hpp"

class Foo
{
public:

    void bar(int x, int y)
    {
        printf("Foo::bar(%d, %d)\n", x, y);
    }
};

void foobar(int x, int y)
{
    printf("foobar(%d, %d)\n", x, y);
}

int main(void)
{
    Foo foo;
    Fns<intint> s;

    // Connect a function
    s.connect(foobar);
    // Connect a class method
    s.connect(&foo, &Foo::bar);
    // Create and connect some lambda expression
    s.connect([&foo](int x, int y){ 
        printf("lambda::"); foo.bar(x, y); 
    });
    // Emit the signal !
    s.emit(4, 2);
    getchar();
    return 0;
}

foobar(4, 2)
Foo::bar(4, 2)
lambda::Foo::bar(4, 2)
posted on 2016-06-13 15:39 C++技术中心 阅读(326) 评论(0)  编辑 收藏 引用 所属分类: C++ 基础

只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理