我一直在试着弄清楚如何让一个类有一个很好的干净的公共接口来执行回调机制的注册.回调可以是C 11 lambdas,std :: function< void(Type1,Type2)>,std :: function< void(Type2)>,std :: function< void()>,或std的结果::绑定().
这个接口的关键是该类的用户只需要知道一个公共接口,它接受用户可能抛出的几乎任何functor / callback机制.
简化的类显示了仿函数和接口的注册
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”…或者绑定结果所期望的参数数量的计数：
我试图找到绑定结果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,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,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()结果的情况下确定绑定结果的arity？
和
我们如何实现尽可能多地支持有界参数的function_traits的完整实现？
解决方法
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 == ?????);
因此,我们实际可以实现的唯一接口是我们提供实际参数计数的接口,并询问是否可以使用该数量的参数调用x.
template<typename F>
struct functor_traits {
template<int A> static const int has_arity = ?????;
};
…但是如果可以使用一个Foo类型的参数或两个类型为Bar的参数调用它呢？似乎只知道x的(可能的)arity是没有用的 – 它并没有真正告诉你如何调用它.要知道如何调用x,我们需要知道或多或少知道我们要传递给它的类型！
所以,在这一点上,STL至少以一种方式来拯救我们：std :: result_of. (但see here对于基于safer的基于decltype的替代结果;我在这里使用它只是为了方便.)
// 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构建类似的traits类,然后使用所有这三个特征的结果来构建x的行为的完整图片 – 至少是x的行为的一部分与您的特定图书馆相关.
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。
