几天来，我一直在绞尽脑汁，试图弄清楚如何让一个类有一个漂亮干净的公共接口来执行回调机制的注册。回调可以是 C++11 lambda、std::function<void(Type1,Type2)>、std::function<void(Type2)>、std::function<void()>或std::bind().
这个接口的关键是该类的用户只需要知道一个公共接口，该接口几乎可以接受用户可能抛出的任何函子/回调机制。
显示仿函数和接口注册的简化类
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”的 trait helper 包装了它，它增加了对 std::bind() 的支持
到目前为止，这就是我想出的识别有界函数“arity”的方法......或者绑定结果期望的参数数量：
我试图找到绑定结果arity
#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() 的结果......我们真正应该的几乎私有的“_Bind”类不需要像 libstdc++ 的用户那样做。
所以我的问题是： 我们如何在不分解 std::bind() 的结果的情况下确定绑定结果的数量？ 以及 我们如何实现尽可能支持有界参数的 function_traits 的完整实现？