我在之前的迭代中已经回答了这个问题，但是 nary 版本有一个错误，并且 clang 有一个内部编译器错误，这使得很难找到这个错误。
我已经修复了这个错误。所以这里是一堆元编程，后面解决你的问题。
首先，C++2a 的 is_detected 的自制版本：
#include <utility>
#include <type_traits>
#include <iostream>
#include <tuple>
namespace details {
template<class...>using void_t=void;
template<template<class...>class Z, class=void, class...Ts>
struct can_apply:std::false_type{};
template<template<class...>class Z, class...Ts>
struct can_apply<Z, void_t<Z<Ts...>>, Ts...>:std::true_type{};
}
template<template<class...>class Z, class...Ts>
using can_apply = typename details::can_apply<Z, void, Ts...>::type;
事实上，std::result_of_t 是我们要测试的特征。
template<class Sig>
using can_call = can_apply< std::result_of_t, Sig >;
现在 can_call 是 true_type 如果你想要的表达式可以被调用。
现在我们编写一些编译时调度机制。
template<std::size_t I>
using index_t=std::integral_constant<std::size_t, I>;
template<std::size_t I>
constexpr index_t<I> index_v{};
constexpr inline index_t<0> dispatch_index() { return {}; }
template<class B0, class...Bs,
std::enable_if_t<B0::value, int> =0
>
constexpr index_t<0> dispatch_index( B0, Bs... ) { return {}; }
template<class B0, class...Bs,
std::enable_if_t<!B0::value, int> =0
>
constexpr auto dispatch_index( B0, Bs... ) {
return index_v< 1 + dispatch_index( Bs{}...) >;
}
template<class...Bs>
auto dispatch( Bs... ) {
using I = decltype(dispatch_index( Bs{}... ));
return [](auto&&...args){
return std::get<I::value>( std::make_tuple(decltype(args)(args)..., [](auto&&...){}) );
};
}
dispatch( SomeBools... ) 返回一个 lambda。 SomeBools 中的第一个是编译时真值（具有在布尔上下文中计算为 true 的 ::value）确定返回的 lambda 做什么。称之为调度索引。
它将 dispatch_index 的参数返回给下一次调用，如果是列表的最后一个，则返回一个空的 lambda。
现在我们希望能够调度一组可能性。为了简单起见（呵呵），我们将使用index_over：
template<class=void, std::size_t...Is >
auto index_over( std::index_sequence<Is...> ){
return [](auto&&f)->decltype(auto){
return decltype(f)(f)( std::integral_constant<std::size_t, Is>{}... );
};
}
template<std::size_t N>
auto index_over(std::integral_constant<std::size_t, N> ={}){
return index_over(std::make_index_sequence<N>{} );
}
这让我们无需构建新函数即可扩展参数包。
那么我们可以将auto_dispatch写成单个函数模板：
template<class...Fs>
auto auto_dispatch( Fs&&... fs ) {
auto indexer = index_over<sizeof...(fs)>();
// some compilers dislike lambdas with unexpanded parameter packs.
// this helps with that:
auto helper = [&](auto I)->decltype(auto){
return std::get<decltype(I)::value>( std::forward_as_tuple( decltype(fs)(fs)... ) );
};
// Get 0 through N-1 as compile-time constants:
return indexer
(
[helper](auto...Is){
// make tuple of functions:
auto fs_tuple = std::forward_as_tuple( helper(Is)... );
// This is what is returned from the `auto_dispatch` function
// it perfect forwards into the correct lambda passed to `auto_dispatch`
// based on which is the first one which can be invoked by
// args...
return [fs_tuple](auto&&...args) {
// dispatcher knows which one can be called
auto dispatcher = dispatch(can_call<Fs(decltype(args)...)>{}...);
// here we get the first one that can be called, or an empty lambda:
auto&& f0 = dispatcher(std::get<decltype(Is)::value>(fs_tuple)...);
// here we do the actual call:
std::forward<decltype(f0)>(f0)(decltype(args)(args)...);
};
}
);
}
带有测试代码：
auto a = [](int x){ std::cout << x << "\n"; };
auto b = [](std::string y){ std::cout << y << "\n"; };
struct Foo {};
auto c = [](Foo){ std::cout << "Foo\n"; };
int main() {
auto_dispatch(a, c)( 7 );
auto_dispatch(a, c)( Foo{} );
auto_dispatch(a, b, c)( Foo{} );
auto_dispatch(a, b, c)( "hello world" );
}
Live example
上面唯一的 N 元递归模板实例化是 dispatch_index。我可以通过一些工作（分而治之）来获得对数深度。获得恒定的深度是困难的。我会考虑的。