c++ - 模板特化中的多个 void_t 调用

标签 c++ templates c++11 metaprogramming sfinae

我需要帮助的第一件事是解决下面的歧义。但是一旦歧义消失,我仍然需要知道是否有更简洁优雅的方式来实现 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 同样专业,您只是编写方式不同 void_t<decltype(std::declval<U>().bar(bool(), char()))>void如果 decltype 没有失败。

您可以添加额外的标志来指定您要使用的特化。或者,您可以通过转换顺序排名来解决歧义。

#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".
}

关于c++ - 模板特化中的多个 void_t 调用,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/36369265/

相关文章:

c++ - 如何在编译时检查函数是否在全局范围内声明

c++ - 我可以使用 std::initializer_list 而不是大括号括起来的初始化程序来初始化数组吗?

c++ - 检查类型实例是否可以流式传输

c++ - 观察数据变化的不同方式

c++ - COM 对象生命周期

templates - phpDocumentor 中的自定义模板(无法创建“phar :. ......)

c++ - 这个成员函数选择代码可以在没有 std::invoke 的情况下编写吗?

c++ - TT : Is that possible/correct 上的模板化类中 T 上的模板化方法

c++ - 我应该如何用 * 框内的大写字母打印 HI?

c++ - 隐式转换没有警告