使用绑定类似功能调用成员函数

如何实现一个非常简单的boost :: bind版本，它不绑定参数，但提供了一种方法来调用C++类中的成员函数。使用绑定类似功能调用成员函数

这是我第一次尝试：

#include <iostream> 

struct Foo { 
    void x(int i) { std::cout << "Foo " << i << std::endl; } 
}; 

struct Bar { 
    void y(int i) { std::cout << "Bar " << i << std::endl; } 
}; 

template<typename A1, typename I, typename M> 
struct Binder { 
    Binder(I i, M m) : i_(i), m_(m) { } 
    void operator()(A1 a1) { 
     (i_->*m_)(a1); 
    } 

    I i_; 
    M m_; 
}; 

template<typename A1, typename I, typename M> 
Binder<A1, I, M> my_bind(I i, M m) { 
    return Binder<A1, I, M>(i, m); 
} 

int main(int argc, const char *argv[]) 
{ 
    Foo foo; 
    Bar bar; 

    Binder<int, Foo*, void (Foo::*)(int)> b1 = my_bind<int>(&foo, &Foo::x); 
    Binder<int, Bar*, void (Bar::*)(int)> b2 = my_bind<int>(&bar, &Bar::y); 

    b1(1); 
    b2(2); 

    return 0; 
}

上面的实现执行工作，并将打印：

Foo 1 
Bar 2

的问题是，my_bind两所调用返回不同类型的对象。我怎样才能改变程序，使my_bind将返回一个只取决于A1的类型。

来源

2012-10-27 Allan

我想你最好使用'std :: mem_fn（）'。 ...或者你是否愿意绑定参数，例如对象？ –

我已经开始着手这方面的工作，因为需要它在嵌入式应用程序中，其中C++环境不支持异常或标准库。所以，std :: men_fn在我的目标系统上不是aviable ... – Allan

当我想到这个时，它更多的是boost ::函数实现我需要了解 – Allan

问题是，两次调用my_bind会返回不同类型的对象。我怎样才能改变程序，使my_bind将返回一个只取决于A1的类型。

这可能与type erasure有关。

简而言之：

与你喜欢的界面创建摘要类。它可能有一些模板参数。（以下代码中的AbstractBinder）
创建具体实现此接口的类。具体类可能比接口具有更多的模板参数。（以下粘合剂类）
创建持有人类模板的构造 - 它创建混凝土类，但只存储指针，它的基础摘要类。所以，持有者类只具有抽象接口所需的模板参数，而其构造函数具有所需的所有其余模板参数具体类。（下面BinderHolder类）

live demo

用法：

int main() 
{ 
    Foo foo; 
    Bar bar; 

    BinderHolder<int> b1 = my_bind<int>(&foo, &Foo::x); 
    BinderHolder<int> b2 = my_bind<int>(&bar, &Bar::y); 

    b1(1); 
    b2(2); 
}

全码：

template<typename A1> 
struct AbstractBinder 
{ 
    virtual void call(A1 a1)=0; 
    virtual AbstractBinder<A1> *clone()=0; 
    virtual ~AbstractBinder(){} 
}; 

template<typename A1, typename I, typename M> 
struct Binder : AbstractBinder<A1> 
{ 
    Binder(I i, M m) : i_(i), m_(m) { } 
    void call(A1 a1) 
    { 
     (i_->*m_)(a1); 
    } 
    virtual AbstractBinder<A1> *clone() 
    { 
     return new Binder(*this); 
    } 
    I i_; 
    M m_; 
}; 

template<typename A1> 
class BinderHolder 
{ 
    AbstractBinder<A1> *ptr; 
    BinderHolder &operator=(const BinderHolder&); 
public: 
    template<typename I, typename M> 
    BinderHolder(I i, M m) 
     : ptr(new Binder<A1,I,M>(i,m)) 
    { 
    } 
    BinderHolder(const BinderHolder &rhs) 
     : ptr(rhs.ptr->clone()) 
    { 
    } 
    ~BinderHolder() 
    { 
     delete ptr; 
    } 
    void operator()(A1 a1) 
    { 
     ptr->call(a1); 
    } 
}; 

template<typename A1, typename I, typename M> 
BinderHolder<A1> my_bind(I i, M m) { 
    return BinderHolder<A1>(i, m); 
} 

#include <iostream> 

struct Foo { 
    void x(int i) { std::cout << "Foo " << i << std::endl; } 
}; 

struct Bar { 
    void y(int i) { std::cout << "Bar " << i << std::endl; } 
}; 

int main() 
{ 
    Foo foo; 
    Bar bar; 

    BinderHolder<int> b1 = my_bind<int>(&foo, &Foo::x); 
    BinderHolder<int> b2 = my_bind<int>(&bar, &Bar::y); 

    b1(1); 
    b2(2); 
}

P.S.如果您确定所有类都具有相同的大小，那么您可以将堆内分配替换为固定大小的缓存，并添加static_assert以确保安全。

来源

2012-10-27 20:14:46

使用绑定类似功能调用成员函数

回答

相关问题