c++11 - 确定 std::bind() 结果的数量和其他特征的标准方法？

Question

这几天我一直在绞尽脑汁，试图找出如何让一个类拥有一个漂亮干净的公共(public)接口(interface)来执行回调机制的注册。回调可以是 C++11 lambda，std::function<void(Type1,Type2)> , std::function<void(Type2)> , std::function<void()> ，或 std::bind() 的结果.

该接口(interface)的关键在于该类的用户只需要了解一个公共(public)接口(interface)，该接口(interface)几乎接受用户可能向其抛出的任何仿函数/回调机制。

显示仿函数和接口(interface)注册的简化类

struct Type1;
struct Type2; // May be the same type as Type1
class MyRegistrationClass
{
public:
    /**
     * Clean and easy to understand public interface:
     * Handle registration of any functor matching _any_ of the following
     *    std::function<void(Type1,Type2)>
     *    std::function<void(Type2)>        <-- move argument 2 into arg 1
     *    std::function<void()>
     *    or any result of std::bind() requiring two or fewer arguments that
     *    can convert to the above std::function< ... > types.
     */
    template<typename F>
    void Register(F f) {
       doRegister(f);
    }
private:
    std::list< std::function< void(Type1, Type2) > > callbacks;


    // Handle registration for std::function<void(Type1,Type2)>
    template <typename Functor>
    void doRegister(const Functor & functor,
                           typename std::enable_if< 
                                   !is_bind_expr<Functor>
                                   && functor_traits<decltype(&Functor::operator())>::arity == 2
                               >::type * = nullptr )
    {
        callbacks.push_back( functor );
    }

    // Handle registration for std::function<void(Type2)> by using std::bind
    // to discard argument 2 ...
    template <typename Functor>
    void doRegister(const Functor & functor, 
                           typename std::enable_if< 
                                   !std::is_bind_expression< Functor >::value
                                   && functor_traits<decltype(&Functor::operator())>::arity == 1
                               >::type * = nullptr )
    {
        // bind _2 into functor
        callbacks.push_back( std::bind( functor,                              std::placeholders::_2 ) );
    }

    // Handle registration for std::function<void(Type2)> if given the results
    // of std::bind()
    template <typename Functor>
    void doRegister(const Functor & functor,
                           typename std::enable_if< 
                                   is_bind_expr<Functor>
///////////////////////////////////////////////////////////////////////////
//// BEGIN Need arity of a bounded argument
///////////////////////////////////////////////////////////////////////////
                                   && functor_traits<decltype(Functor)>::arity == 1  
///////////////////////////////////////////////////////////////////////////
//// END need arity of a bounded argument
///////////////////////////////////////////////////////////////////////////
                               >::type * = nullptr )
    {
        // Push the result of a bind() that takes a signature of void(Type2)
        // and push it into the callback list, it will automatically discard
        // argument1 when called, since we didn't bind _1 placeholder
        callbacks.push_back( functor );
    }

    // And other "doRegister" methods exist in this class to handle the other
    // types I want to support ...
}; // end class

使用enable_if<>的复杂性的唯一原因是打开/关闭某些方法。我们必须这样做，因为当我们想要将 std::bind() 的结果传递给 Register() 方法时，如果我们有这样的简单签名，它可能会模糊地匹配多个注册方法:

void doRegister( std::function< void(Type1, Type2) > arg );
void doRegister( std::function< void(Type2) > arg ); // NOTE: type2 is first arg
void doRegister( std::function< void() > arg );

我没有重新发明轮子，而是引用了traits.hpp然后用我自己的名为“functor_traits”的特征助手包装它，增加对 std::bind() 的支持

这是我到目前为止所想出的方法来识别有界函数“arity”...或者绑定(bind)结果期望的参数数量:

我尝试查找绑定(bind)结果数量

#include <stdio.h>
// Get traits.hpp here: https://github.com/kennytm/utils/blob/master/traits.hpp
#include "traits.hpp" 

using namespace utils;
using namespace std;

void f1() {};
int f2(int) { return 0; }
char f3(int,int) { return 0; }

struct obj_func0 
{
    void operator()() {};
};
struct obj_func1
{
    int operator()(int) { return 0; };
};
struct obj_func2 
{
    char operator()(int,int) { return 0; };
};


/**
 * Count the number of bind placeholders in a variadic list
 */
template <typename ...Args>
struct get_placeholder_count
{
    static const int value = 0;
};
template <typename T, typename ...Args >
struct get_placeholder_count<T, Args...>
{
    static const int value = get_placeholder_count< Args... >::value + !!std::is_placeholder<T>::value;
};


/**
 * get_bind_arity<T> provides the number of arguments 
 * that a bounded expression expects to have passed in. 
 *  
 * This value is get_bind_arity<T>::arity
 */

template<typename T, typename ...Args>
struct get_bind_traits;

template<typename T, typename ...Args>
struct get_bind_traits< T(Args...) >
{
    static const int arity = get_placeholder_count<Args...>::value;
    static const int total_args = sizeof...(Args);
    static const int bounded_args = (total_args - arity);
};

template<template<typename, typename ...> class X, typename T, typename ...Args>
struct get_bind_traits<X<T, Args...>>
{
    // how many arguments were left unbounded by bind
    static const int arity        = get_bind_traits< T, Args... >::arity;

    // total arguments on function being called by bind
    static const int total_args   = get_bind_traits< T, Args... >::total_args;

    // how many arguments are bounded by bind:
    static const int bounded_args = (total_args - arity);

    // todo: add other traits (return type, args as tuple, etc
};

/**
 * Define wrapper "functor_traits" that wraps around existing function_traits
 */
template <typename T, typename Enable = void >
struct functor_traits;

// Use existing function_traits library (traits.hpp)
template <typename T>
struct functor_traits<T, typename enable_if< !is_bind_expression< T >::value >::type > :
    public function_traits<T>
{};

template <typename T>
struct functor_traits<T, typename enable_if< is_bind_expression< T >::value >::type >
{
    static const int arity = get_bind_traits<T>::arity;
};

/**
 * Proof of concept and test routine
 */
int main()
{
    auto lambda0 = [] {};
    auto lambda1 = [](int) -> int { return 0; };
    auto lambda2 = [](int,int) -> char { return 0;};
    auto func0 = std::function<void()>();
    auto func1 = std::function<int(int)>();
    auto func2 = std::function<char(int,int)>();
    auto oper0 = obj_func0();
    auto oper1 = obj_func1();
    auto oper2 = obj_func2();
    auto bind0 = bind(&f1);
    auto bind1 = bind(&f2, placeholders::_1);
    auto bind2 = bind(&f1, placeholders::_1, placeholders::_2);
    auto bindpartial = bind(&f1, placeholders::_1, 1);

    printf("action        : signature       : result\n");
    printf("----------------------------------------\n");
    printf("lambda arity 0: [](){}          : %i\n", functor_traits< decltype(lambda0) >::arity );
    printf("lambda arity 1: [](int){}       : %i\n", functor_traits< decltype(lambda1) >::arity );
    printf("lambda arity 2: [](int,int){}   : %i\n", functor_traits< decltype(lambda2) >::arity );
    printf("func arity   0: void()          : %i\n", functor_traits< function<void()> >::arity );
    printf("func arity   1: int(int)        : %i\n", functor_traits< function<void(int)> >::arity );
    printf("func arity   2: char(int,int)   : %i\n", functor_traits< function<void(int,int)> >::arity );
    printf("C::operator()() arity 0         : %i\n", functor_traits< decltype(oper0) >::arity );
    printf("C::operator()(int) arity 1      : %i\n", functor_traits< decltype(oper1) >::arity );
    printf("C::operator()(int,int) arity 2  : %i\n", functor_traits< decltype(oper2) >::arity );
///////////////////////////////////////////////////////////////////////////
// Testing the bind arity below:
///////////////////////////////////////////////////////////////////////////
    printf("bind arity   0: void()          : %i\n", functor_traits< decltype(bind0) >::arity );
    printf("bind arity   1: int(int)        : %i\n", functor_traits< decltype(bind1) >::arity );
    printf("bind arity   2: void(int,int)   : %i\n", functor_traits< decltype(bind2) >::arity );
    printf("bind arity   X: void(int, 1 )   : %i\n", functor_traits< decltype(bindpartial) >::arity );

    return 0;
}

虽然这个实现在 gcc 和 libstdc++ 中工作，但我不太确定这是否是一个可移植的解决方案，因为它试图分解 std::bind() 的结果......几乎私有(private)的“_Bind”类作为 libstdc++ 的用户，我们确实不需要这样做。

所以我的问题是:如何在不分解 std::bind() 结果的情况下确定绑定(bind)结果的数量？和我们如何实现尽可能支持有界参数的 function_traits 的完整实现？

Answer 1

OP，你的前提有缺陷。您正在寻找某种可以告诉您任何给定对象的例程 x ，有多少个参数 x期望 — 即 x() 中的哪一个, x(a) ，或x(a,b)格式良好。

问题是任何数量的这些替代方案都可能是格式良好的!

在 a discussion on isocpp.org of this very topic ，Nevin Liber 非常正确地写道:

For many function objects and functions, the concepts of arity, parameter type and return type don't have a single answer, as those things are based on how it [the object] is being used, not on how it has been defined.

这是一个具体的例子。

struct X1 {
    void operator() ()        { puts("zero"); }
    void operator() (int)     { puts("one");  }
    void operator() (int,int) { puts("two");  }
    void operator() (...)     { puts("any number"); }

    template<class... T>
    void operator() (T...)    { puts("any number, the sequel"); }
};

static_assert(functor_traits<X1>::arity == ?????);

因此，我们可以实际实现的唯一接口(interface)是我们提供实际参数计数的接口(interface)，并询问是否 x可以使用该数量的参数进行调用。

template<typename F>
struct functor_traits {
    template<int A> static const int has_arity = ?????;
};

...但是如果可以使用 Foo 类型的一个参数来调用它会怎样？ 或两个 Bar 类型的参数？似乎只知道(可能的)数量 x没有用——它并没有真正告诉你如何调用它。了解如何调用x ，我们需要或多或少地知道我们试图传递给它的类型!

所以，此时，STL 至少以一种方式来拯救我们:std::result_of 。 (但是 see here 是 safer decltype 的 result_of 的替代方案；我在这里使用它只是为了方便。)

// std::void_t is coming soon to a C++ standard library near you!
template<typename...> using void_t = void;

template<typename F, typename Enable = void>
struct can_be_called_with_one_int
{ using type = std::false_type; };

template<typename F>  // SFINAE
struct can_be_called_with_one_int<F, void_t<typename std::result_of<F(int)>::type>>
{ using type = std::true_type; };

template<typename F>  // just create a handy shorthand
using can_be_called_with_one_int_t = typename can_be_called_with_one_int<F>::type;

现在我们可以提出类似 can_be_called_with_one_int_t<int(*)(float)> 的问题或can_be_called_with_one_int_t<int(*)(std::string&)>并得到合理的答案。

您可以为 can_be_called_with_no_arguments 构建类似的特征类, ...with_Type2 , ...with_Type1_and_Type2 ，然后使用所有这三个特征的结果来构建您的x的完整图片。的行为——至少是 x 的一部分的行为与您的特定库相关。