我一直在试着弄清楚如何让一个类有一个很好的干净的公共接口来执行回调机制的注册。回调可以是C ++ 11 lambdas，std::function<void(Type1,Type2)>，std::function<void(Type2)>，std::function<void()>或std::bind()的结果。
这个接口的关键是该类的用户只需要知道一个公共接口，它接受用户可能抛出的几乎任何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＆lt;＆gt;的复杂性的唯一原因是打开/关闭某些方法。我们必须这样做，因为当我们想要将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”......或者绑定结果所期望的参数数量的计数：
#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;
}
虽然这个实现在使用libstdc ++的gcc中工作，但我不太确定这是否是一个可移植的解决方案，因为它试图分解std :: bind（）的结果......几乎是私有的“_Bind”类我们真的不应该像libstdc ++的用户那样做。
所以我的问题是： 如何在不分解std :: bind（）结果的情况下确定绑定结果的优点？ 和 我们如何实现尽可能支持有界参数的function_traits的完整实现？
答案 0 :(得分：2)
x，x期望的参数有多少 - 即x()，{{1 }}，或x(a)格式正确。
问题是任何数量的替代方案都可能格式正确！
在a discussion on isocpp.org of this very topic中，Nevin Liber非常正确地写道：
对于许多函数对象和函数，arity，参数类型和返回类型的概念没有单一的答案，因为这些是基于它[对象]的使用方式，而不是它是如何使用的已定义。
这是一个具体的例子。
x(a,b)因此我们实际可以实现的唯一接口是我们提供实际参数计数的接口，并询问是否可以使用该数量的参数调用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，我们需要了解或多或少知道我们尝试传递给它的类型！
所以，在这一点上，STL至少以一种方式来拯救我们：x。 （但see here代替基于safer std::result_of的替代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构建类似的特征类，然后使用这三个特征的结果来构建{{1}的完整图片行为 - 至少是...with_Type1_and_Type2与您的特定图书馆相关的行为的一部分。