Boost 绑定占位符参数等于可变参数模板参数的数量

Question

我想知道是否可以使用传递给可变参数模板的参数数量作为 boost::bind 调用中的占位符。

像这样的事情：

template <typename ... Args>

boost::bind(&function, this, anArg, _1));         //If Args count equals 1
boost::bind(&function, this, anArg, _1, _2));     //If Args count equals 2
boost::bind(&function, this, anArg, _1, _2, _3)); //If Args count equals 3

这可能吗？

谢谢

Answer 1

肯定有一种部分专业化的方法。
你的可变参数不能立即知道参数的数量，对吧？您必须使用编译时递归，在此期间您可以使用 boost::mpl 堆叠您的参数（或使用简单的整数常量增量对它们进行计数）。
然后在最后一个非变量递归调用（带有 0 arg）中，您在容器上调用 mpl::size （或者如果您选择这种方式，则仅使用整数计数器）来调用像其他答案一样的 Callable，它包含所有参数，在类型列表的开头加上一个完整的模板参数。这就是你的专长。您为每个参数数量创建一个调用程序，该调用程序将根据其特殊数量的参数调用正确的绑定。
（Callable 结构（部分）根据参数整数模板参数的数量进行专门化。即使 Call 函数采用最大数量的参数，它也只包装正确的 boost::bind 调用，例如 bind(.., _1,_2) 对于可调用<2, T1, T2, T3>)
这并不可怕，但我确认我过去在 C++03 中使用过这种方法。

Answer 2

也许你应该更详细地解释一下你想做什么。如果您只是寻找一种解决方案来处理参数类型不同的三个不同签名，您可以这样做：

template<typename signature>
struct callable;

template<typename P0, typename P1, typename P2>
struct callable<void (P0, P1, P2)>
{
    void bind()
    {
        boost::bind(&callable::operator(), this, _1, _2, _3);
    }

    void operator()(P0, P1, P2) {}
};

Answer 3

这不是特定问题的答案，而是您可能试图解决的问题的一个很好的解决方法。

我在实现通用委托机制时遇到了同样的问题。我的解决方案是在绑定调用之上使用包装器，专门用于变体。虽然它不能解决问题，但它确实将冗余代码最小化为绑定调用，最重要的是为我提供了一个可以在任何地方使用的基于可变参数的委托系统。

template<class CALLBACK_TARGET_CLASS, typename RETURN_TYPE>
std::function<RETURN_TYPE()> BindFunction(RETURN_TYPE (CALLBACK_TARGET_CLASS::*memberFunction)(), CALLBACK_TARGET_CLASS* callbackTarget)
{
    return std::bind(memberFunction, callbackTarget);
}

template<class CALLBACK_TARGET_CLASS, typename RETURN_TYPE, typename P0>
std::function<RETURN_TYPE()> BindFunction(RETURN_TYPE (CALLBACK_TARGET_CLASS::*memberFunction)(P0), CALLBACK_TARGET_CLASS* callbackTarget)
{
    return std::bind(memberFunction, callbackTarget, std::placeholders::_1);
}

template<class CALLBACK_TARGET_CLASS, typename RETURN_TYPE, typename P0, typename P1>
std::function<RETURN_TYPE()> BindFunction(RETURN_TYPE (CALLBACK_TARGET_CLASS::*memberFunction)(P0, P1), CALLBACK_TARGET_CLASS* callbackTarget)
{
    return std::bind(memberFunction, callbackTarget, std::placeholders::_1, std::placeholders::_2);
}



template<typename RETURNTYPE, typename... ARGS>
struct Delegate
{
    std::function<RETURN_TYPE (ARGS...)> callbackFunction;

    template<class CALLBACK_TARGET_CLASS>
    void Bind(CALLBACK_TARGET_CLASS* callbackTarget, RETURN_TYPE (CALLBACK_TARGET_CLASS::*memberFunction)(ARGS...))
    {
        callbackFunction = BindFunction<CALLBACK_TARGET_CLASS, RETURN_TYPE, ARGS...>(memberFunction, callbackTarget); 
    }

    void Callback(ARGS... params)
    {
        callbackFunction(params...);
    }
};

使用使我们看起来像这样..

class Foo
{
public:
    void Bar(int x);
}

Foo foo;
Delegate<void, int> myDelegate;

myDelegate.Bind(&foo, &Foo::Bar);

myDelegate.Callback(3);

Answer 4

使用可变参数模板无法直接使用 _1、_2、...。您需要使用扩展宏来代替。

但是，您可以将这些占位符包装在模板化工厂中，以模板参数 1 获取 _1，2 获取 _2，等等...

gcc / msvc 等实现已经将占位符定义为模板化结构（分别为 std::_Placeholder 和 std:: _Ph) 所以你可以这样定义你的工厂：

struct ph_factory {
    template<size_t holder>
    static std::_Placeholder<holder> make_ph() {
        return std::_Placeholder<holder>();
    }
};

这样定义后，你可以用你想要的所有占位符扩展一个参数包：

struct tester {

    template<size_t ... holders>
    void test(int val) {
        auto callable = std::bind(&tester::call, this, val, ph_factory::make_ph<holders>()...);
        callable('a', 42, 'c');
    }

    void call(int v1, char c1, int v2, char c2) {
        cout << "calling :" << v1 << " " << c1 << " " << v2 << " " << c2 << endl;
    }
};

所以下面的代码将输出“calling:10 c 42 a"

int main() {
    tester t;
    t.test<3,2,1>(10);
}

使用 make_indice 等技巧将使您有可能实现最初的目标。