使用boost :: bind，但允许任何其他参数通过

Question

我正在放在一起“简单”的模板类。它提供了一个用于在数据库上执行某些操作的界面，所以还有其他成员（主要用于在容器成员上操作）。但是，对于我们的目的，模板类看起来像这样：

template<typename T, //the type of objects the class will be manipulating 
     typename S> //the signature of the function the class will be using 
FunctionHandler 
{ 
private: 
    std::vector<T> container; 
    boost::function<S> the_operation; 
    SomeClass* pSC; //a database connection; implementation unimportant 

    //some other members--not relevant here 
public: 
    boost::function<???> Operate; 
    FunctionHandler(boost::function<S> the_operation_) 
     : the_operation(the_operation_) 
    { 
     Operate = boost::bind(the_operation, pSC, std::back_inserter<std::vector<T> >, 
           /*infer that all other parameters passed to Operate 
           should be passed through to the_operation*/); 
    } 

    //other peripheral functions 
} 

我的问题是双重的。

1. 作为Operate的模板参数，我该怎么做。即什么取代???
2. 我该如何告诉boost::bind它应该通过其他参数Operate到the_operation？换句话说，对于一些任意的函数签名S，看起来像void (SomeClass*, std::back_insert_iterator<std::vector<T> >, int, bool)和看起来像void (SomeClass*, std::back_insert_iterator<std::vector<T> >, double, double, bool)我怎么写这个模板类，使得Operate有void (int, bool)第一和void (double, double, bool)第二签名一些其他任意函数签名O，和将其值传递给the_operation的第3个参数？

在我的搜索中，我找不到任何与此相似的问题。

Answer 1

为什么即使使用绑定？没有它，我们可以得到相同的效果。我使用Iter作为模板，但你可以在whater权类型为填充：

template <typename S, typename Iter> 
class Operator 
{ 
    boost::function<S> func_; 
    SomeClass* cls_; 
    Iter iter_; 

public: 
    Operator(function<S> func, SomeClass* cls, Iter iter) 
    : func_(func), cls_(cls), iter_(iter) 
    { } 

    // one for each # of args 
    typename boost::result_of< 
     boost::function<S>(SomeClass*, Iter) 
    >::type operator()() const { 
     return func_(cls_, iter_); 
    } 

    template <typename A> 
    typename boost::result_of< 
     boost::function<S>(SomeClass*, Iter, A) 
    >::type operator()(A a) const { 
     return func_(cls_, iter_, a); 
    } 

    template <typename A, typename B> 
    typename boost::result_of< 
     boost::function<S>(SomeClass*, Iter, A, B) 
    >::type operator()(A a, B b) const { 
     return func_(cls_, iter_, a, b); 
    } 

    // etc. 
}; 

我们正在做的所有operator() S的，但他们只会被实例化了，如果他们被调用 - 所以只要你打电话给正确的人（对于任何解决方案，你都必须），这是有效的。

Answer 2

不幸的是，没有办法“推断”所有其余的参数。您必须指定所有正确的占位符。从C++ 03开始，我们可以使用大量的模板特化。

template <typename S> struct Operate; 

template <typename R, typename Iter> 
struct Operate<R(SomeClass*, Iter)> 
{ 
    using namespace boost; 

    function<R()> op_; 

    Operator(function<R(SomeClass*, Iter)> op, SomeClass* cls, Iter iter) 
    : op_(bind(op, cls, iter)) 
    { } 
}; 

template <typename R, typename Iter, typename A> 
struct Operate<R(SomeClass*, Iter, A)> 
{ 
    using namespace boost; 

    function<R(A)> op_; 

    Operator(function<R(SomeClass*, Iter, A)> op, SomeClass* cls, Iter iter) 
    : op_(bind(op, cls, iter, _1)) 
    { } 
}; 

template <typename R, typename Iter, typename A, typename B> 
struct Operate<R(SomeClass*, Iter, A, B)> 
{ 
    using namespace boost; 

    function<R(A, B)> op_; 

    Operator(function<R(SomeClass*, Iter, A, B)> op, SomeClass* cls, Iter iter) 
    : op_(bind(op, cls, iter, _1, _2)) 
    { } 
}; 

// etc. 

它很冗长，但如果你不能使用C++ 11，我不知道你还能做什么。其中，为完整性：

template <typename R, typename Iter, typename... Extra> 
struct Operator<R(SomeClass*, Iter, Extra...)> 
{ 
    std::function<R(SomeClass*, Iter, Extra...)> op_; 
    SomeClass* cls_; 
    Iter iter_; 

    Operator(function<R(SomeClass*, Iter, Extra...)> op, SomeClass* cls, Iter iter) 
    : op_(op), cls_(cls), iter_(iter) 
    { } 

    R operator()(Extra... args) const { 
     return op_(cls_, iter_, args...); 
    } 
}; 

Answer 3

我对boost.MPL的知识不幸相当有限，所以我不认为这是解决问题的最好方法，从功能类型中删除前两个参数类型。

#include <boost/function_types/components.hpp> 
#include <boost/function_types/function_type.hpp> 
#include <boost/mpl/erase.hpp> 
#include <boost/mpl/begin_end.hpp> 
#include <boost/mpl/advance.hpp> 
#include <boost/mpl/int.hpp> 

template<typename F, int N> 
class remove_first_N_param_types 
{ 
     typedef typename boost::function_types::components<F>::type 
    components; 
     typedef typename boost::mpl::begin<components>::type 
    beg; 
     typedef typename boost::mpl::advance<beg, boost::mpl::int_<1 >>::type 
    beg_param; 
     typedef typename boost::mpl::advance<beg, boost::mpl::int_<1+N>>::type 
    beg_param_plus_N; 
     typedef typename boost::mpl::erase<components, 
              beg_param, beg_param_plus_N>::type 
    erased_first_N_params; 

public: 
     typedef typename boost::function_types:: 
     function_type<erased_first_N_params>::type 
    type; 
}; 

Live example