使用 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？换句话说，对于一些看起来像void (SomeClass*, std::back_insert_iterator<std::vector<T> >, int, bool) 的任意函数签名S 和看起来像void (SomeClass*, std::back_insert_iterator<std::vector<T> >, double, double, bool) 的一些其他任意函数签名O 我如何编写这个模板类，使得Operate 的签名为@第一个为 987654332@，第二个为 void (double, double, bool)，并将其值传递给 the_operation 的第 3-N 个参数？

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

Answer 1

为什么还要使用绑定？没有它我们也能得到同样的效果。我使用Iter 作为模板，但您可以使用正确的类型填写：

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 的了解非常有限，所以我认为这不是解决从函数类型中删除前两个参数类型问题的最佳方法。 p>

#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