嵌套模板类的模板类模板参数特化

Question

通常，您可以针对实例化的模板类部分专门化模板类。比如

template<class T>
struct specialize_me {};

template<class T>
struct specialize_me<std::vector<T>> {
    static const int foo = 3;
};

模板类specialize_me 部分专门针对实例化的模板类std::vector<T>。当specialize_me 用std::vector<T> 实例化时，会选择此特化，适用于任何类T。

int main() {
    std::cout << specialize_me<std::vector<int>>::foo; // Compiles.
}

但是，我不知道如何针对实例化的嵌套模板类专门化模板模板类：

// Nested template class.
template<class T>
struct Either {
    template<class U>
    struct Or {};
};

template<template<class> class T>
struct specialize_me_2 {};

template<class T>
struct specialize_me_2<Either<T>::template Or> {
    static const int foo = 3;
};

在这种情况下，当我为任何类T 使用类Either<T>::template Or 实例化specialize_me_2 时，未选择特化。我的猜测是，发生这种情况是因为编译器必须确认或否认，“存在一个 T 使得 Either<T>::template Or 与 specialize_me_2 实例化的类型相同”才能选择我的专业化，而事实并非如此编程或指定这样做。

int main() {
    std::cout << specialize_me_2<Either<int>::Or>::foo; // Does not compile.  'foo' is not a member of specialize_me_2<Either<int>::Or>.
}

有没有办法专门化specialize_me_2，以便在任何T 用Either<T>::Or 实例化specialize_me_2 时选择专门化？

这个Either结构体最终会代表一个携带错误的类型，所以Either<T>表示T是错误类型，Either<T>::Or<U>表示U是成功携带的类型计算。

如果这是不可能的，我可能仍然可以使用#defines 让您根据需要为每个T 定义Either<T>，其中#define 还包括specialize_me_2 专门化特别是Either<T>::Or。事实上，我打算在程序中使用Either 结构，无论如何都要写template<class T> using FooError = Either<Foo>::Or<T>，然后写FooError<Bar>、FooError<Quux> 等等，所以使用它不会与预期的用法有很大的不同。

Answer 1

有趣的问题。

为了解决它而不会太痛苦......如果你可以在Or中添加新的using类型

template <typename T>
struct Either
 {
   template <typename>
   struct Or
    { using specialOrType = T; };
 };

然后您可以在specialize_me_2 中添加第二个模板参数，即默认为void 的类型名

template <template <typename> class C, typename = void>
struct specialize_me_2
 { static const int foo = 2; };

在specialOrType上使用SFINAE

template <typename ...>
using myVoidT = void;

template <template <typename> class C>
struct specialize_me_2<C, myVoidT<typename C<void>::specialOrType>>
 {
   using T = typename C<void>::specialOrType;

   static const int foo = 3;
 };

你获得了你的工作专长。

代替myVoidT，从C++17开始，你显然可以使用std::void_t。

注意，这种方式无法推断出原来的T类型，但可以通过specialOrType恢复。

还请注意，这要求（如 aschepler 所指出的）Or<void> 是有效的特化。如果不是这种情况，您应该选择另一种类型X，以便Or<X> 是所有Either<T> 的有效特化。例如，假设Or<int> 是每个Either<T> 的有效特化，则特化变为

template <template <typename> class C>
struct specialize_me_2<C, myVoidT<typename C<int>::specialOrType>>
 {
   using T = typename C<int>::specialOrType;

   static const int foo = 3;
 };

以下是一个完整的工作示例

#include <iostream>

template <typename ...>
using myVoidT = void;

template <typename>
struct NoEither
 { };

template <typename T>
struct Either
 {
   template <typename>
   struct Or
    { using specialOrType = T; };
 };

template <template <typename> class C, typename = void>
struct specialize_me_2
 { static const int foo = 2; };

template <template <typename> class C>
struct specialize_me_2<C, myVoidT<typename C<void>::specialOrType>>
 {
   using T = typename C<void>::specialOrType;

   static const int foo = 3;
 };

int main ()
 {
    std::cout << specialize_me_2<NoEither>::foo << std::endl;
    std::cout << specialize_me_2<Either<int>::template Or>::foo << std::endl;
 }

Answer 2

看起来 T 无法从 Either<T>::Or 推导出来，将 T 作为另一个模板参数传入似乎可以使它工作，如果这对你也有用的话..

#include <iostream>

template<class T>
struct Either {
    template<class U>
    struct Or {};
};


template<typename U,template<class> class T>
struct specialize_me_2 {};

template<class T>
struct specialize_me_2<T,Either<T>::template Or> {
    static const int foo = 3;
};


int main() {
    std::cout << specialize_me_2<int,Either<int>::Or >::foo; // Does compile
}

Demo

使用Either 中的嵌套类型成员可以使其更简洁，因此您可以使用 like，

using someEitherType = Either<int>;
...
specialize_me_2<someEitherType::type, someEitherType::Or>::foo

或者直接专门针对第一个模板参数，

template<class T>
struct specialize_me_2<Either<T>,Either<T>::template Or> {
    static const int foo = 3;
};

然后传入

specialize_me_2<someEitherType, someEitherType::Or>::foo

Demo2