Question

我正在整理一个简单的＆＃34;模板类。它提供了一个用于对数据库执行某些操作的接口，因此还有其他成员（主要用于对容器成员进行操作）。但是，出于我们的目的，模板类看起来像这样：

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
}

我的问题是双重的。

我将Operate的模板参数放在哪里。即什么取代???
如何告诉boost::bind它应该将Operate的任何其他参数传递给the_operation？换句话说，对于某些看起来像S的任意函数签名void (SomeClass*, std::back_insert_iterator<std::vector<T> >, int, bool)和一些看似O的其他任意函数签名void (SomeClass*, std::back_insert_iterator<std::vector<T> >, double, double, bool)，如何编写此模板类，以便Operate第一个签名为void (int, bool)，第二个签名为void (double, double, bool)，并将其值传递给the_operation的第3个参数？

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

Answer 1

为什么甚至使用bind？没有它我们可以获得相同的效果。我使用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()，但只有在被调用时它们才会被实例化 - 所以只要你调用正确的（对于任何解决方案，你都必须这样做）），这是有效的。

Answer 2

不幸的是，没有办法推断＆＃34;所有其他论点。您必须指定所有正确的占位符。从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

使用boost :: bind但允许传递任何其他参数

3 个答案: