我需要帮助的第一件事是解决以下歧义。但是一旦模糊不清，我仍然需要知道是否有一种更简洁，更优雅的方式来实现这8个特化。
#include <iostream>
template <typename>
using void_t = void;
template <typename T, typename U, typename = void, typename = void, typename = void>
struct Foo {
static void call() {std::cout << "Case 1\n";}
};
template <typename T, typename U>
struct Foo<T, U,
void_t<decltype(std::declval<T>().foo(int()))>,
void_t<decltype(std::declval<U>().bar(bool(), char()))>,
void_t<decltype(execute(std::declval<const T&>(), std::declval<const U&>()))>> {
static void call() {std::cout << "Case 2\n";}
};
template <typename T, typename U>
struct Foo<T, U,
void_t<decltype(std::declval<T>().foo(int()))>,
void, void> {
static void call() {std::cout << "Case 3\n";}
};
// etc... for the remaining 5 specializations.
struct Thing {
void foo(int) {}
};
struct Uber {
int bar(bool, char) {return 2;}
};
void execute (const Thing&, const Uber&) {}
int main() {
Foo<Thing, int>::call(); // Case 3
// Foo<Thing, Uber>::call(); // Ambiguous. Want this to be "Case 2" instead of "Case 3".
}
所以首先，我需要知道
Foo<Thing, Uber>::call();为什么不明确。所有3个void_t都已满足，因此案例2是否比案例3更专业？另外，我打算对3个void_t的实现或不实现的2x2x2可能性进行5个专门化。如果使用n个void_t，最优雅的方式来处理2 ^ n个这样的特化方法是什么？打个比方，在处理3个
std::enable_if_t调用的情况下#include <iostream>
#include <type_traits>
template <bool B> using bool_constant = std::integral_constant<bool, B>;
template <std::size_t N>
struct is_even : bool_constant<N % 2 == 0> {};
template <std::size_t N, std::size_t A>
struct add_to_odd : bool_constant<(N + A) % 2 == 1> {};
template <std::size_t N, std::size_t A, std::size_t B>
struct is_one_of_these : bool_constant<N == A || N == B> {};
template <std::size_t N, std::size_t A, std::size_t B, typename = void, typename = void, typename = void>
struct Foo {
static void call() {std::cout << "Case 1\n";}
};
template <std::size_t N, std::size_t A, std::size_t B>
struct Foo<N,A,B,
std::enable_if_t<is_even<N>::value>,
std::enable_if_t<!add_to_odd<N,A>::value>,
std::enable_if_t<!is_one_of_these<N,A,B>::value>> {
static void call() {std::cout << "Case 2\n";}
};
// etc... for the other combinations of the 3 enable_if conditions being true/false.
int main() {
Foo<1,2,3>::call();
Foo<8,2,3>::call();
}
我想通了
#include <iostream>
#include <type_traits>
template <bool B> using bool_constant = std::integral_constant<bool, B>;
template <std::size_t N>
struct is_even : bool_constant<N % 2 == 0> {};
template <std::size_t N, std::size_t A>
struct add_to_odd : bool_constant<(N + A) % 2 == 1> {};
template <std::size_t N, std::size_t A, std::size_t B>
struct is_one_of_these : bool_constant<N == A || N == B> {};
template <std::size_t N, std::size_t A, std::size_t B, bool, bool, bool>
struct FooHelper {
static void call() {std::cout << "Case 1\n";}
};
template <std::size_t N, std::size_t A, std::size_t B>
struct FooHelper<N, A, B, true, false, false> {
static void call() {std::cout << "Case 2\n";}
};
template <std::size_t N, std::size_t A, std::size_t B>
struct FooHelper<N, A, B, true, true, false> {
static void call() {std::cout << "Case 3\n";}
};
template <std::size_t N, std::size_t A, std::size_t B>
struct FooHelper<N, A, B, true, true, true> {
static void call() {std::cout << "Case 4\n";}
};
template <std::size_t N, std::size_t A, std::size_t B>
struct FooHelper<N, A, B, false, true, true> {
static void call() {std::cout << "Case 5\n";}
};
template <std::size_t N, std::size_t A, std::size_t B>
struct FooHelper<N, A, B, false, false, true> {
static void call() {std::cout << "Case 6\n";}
};
template <std::size_t N, std::size_t A, std::size_t B>
struct FooHelper<N, A, B, true, false, true> {
static void call() {std::cout << "Case 7\n";}
};
template <std::size_t N, std::size_t A, std::size_t B>
struct FooHelper<N, A, B, false, true, false> {
static void call() {std::cout << "Case 8\n";}
};
template <std::size_t N, std::size_t A, std::size_t B>
struct Foo : FooHelper<N, A, B, is_even<N>::value, add_to_odd<N,A>::value, is_one_of_these<N,A,B>::value> {};
int main() {
Foo<1,2,3>::call();
Foo<8,2,3>::call();
// etc...
}
使这8个模板特化更加简洁，可维护且易于阅读。但是对我来说，对n void_t的类比不是很明显(嗯，上述模糊性也没有帮助)。
最佳答案
在您的案例中，案例2和案例3都是同等专业的，您只是用不同的方式编写
如果decltype不失败，则void_t<decltype(std::declval<U>().bar(bool(), char()))>为void。
您可以添加其他标志来指定要使用的特化。或者，您可以使用转换序列排名解决歧义。
#include <iostream>
template <typename>
using void_t = void;
template <int P>
struct Rank : Rank<P - 1> {};
template <>
struct Rank<0> : std::integral_constant<int, 0> {};
// Helper functions
template <typename T>
static auto has_foo_impl(int)
-> decltype(std::declval<T>().foo(int()), std::true_type());
template <typename T>
static auto has_foo_impl(long) -> std::false_type;
template <typename T>
constexpr bool has_foo() {
return std::is_same<decltype(has_foo_impl<T>(0)), std::true_type>::value;
};
template <typename T>
static auto has_bar_impl(int)
-> decltype(std::declval<T>().bar(bool(), char()), std::true_type());
template <typename T>
static auto has_bar_impl(long) -> std::false_type;
template <typename T>
constexpr bool has_bar() {
return std::is_same<decltype(has_bar_impl<T>(0)), std::true_type>::value;
};
template <typename T, typename U>
static auto has_execute_impl(int)
-> decltype(execute(std::declval<T&>(), std::declval<U&>()),
std::true_type());
template <typename T, typename U>
static auto has_execute_impl(long) -> std::false_type;
template <typename T, typename U>
constexpr bool has_execute() {
return std::is_same<decltype(has_execute_impl<T, U>(0)),
std::true_type>::value;
};
// Call overloads
template <typename T, typename U>
static void call_impl(Rank<0>) {
std::cout << "Case 1\n";
}
template <typename T, typename U>
static auto call_impl(Rank<5>)
-> std::enable_if_t<has_foo<T>() && has_bar<U>() && has_execute<T, U>()> {
std::cout << "Case 2\n";
}
template <typename T, typename U>
static auto call_impl(Rank<4>) -> std::enable_if_t<has_foo<T>()> {
std::cout << "Case 3\n";
}
template <typename T, typename U>
struct Foo {
static void call() { call_impl<T, U>(Rank<10>()); }
};
struct Thing {
void foo(int) {}
};
struct Uber {
int bar(bool, char) { return 2; }
};
void execute(const Thing&, const Uber&) {}
int main() {
Foo<Thing, int>::call(); // Case 3
Foo<Thing, Uber>::call(); // Ambiguous. Want this to be "Case 2" instead of
// "Case 3".
}