在编写一个供个人使用的小型模板元编程库时，我遇到了一个有趣的问题。

由于我为某些元函数重用了一些偏特化，因此我决定将它们放在一个通用模板类下，并使用标签和嵌套偏特化来提供行为差异。

问题是我得到了(对我而言)荒谬的结果。这是一个展示我正在尝试做的事情的最小示例:

#include <iostream>
#include <cxxabi.h>
#include <typeinfo>

template <typename T>
const char * type_name()
{
    return abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
}

template <typename... Args>
struct vargs {};

namespace details   
{
    template <typename K>
    struct outer
    {
        template <typename Arg>
        struct inner
        {
            using result = Arg;
        };
    };
}

struct tag {};

namespace details
{
    template <>
    template <typename Arg, typename... Args>
    struct outer<tag>::inner<vargs<Arg, Args...>>
    {
        using result = typename outer<tag>::inner<Arg>::result;
    };
}

template <typename T>
using test_t = typename details::outer<tag>::inner<T>::result;

int main()
{
    using t = test_t<vargs<char, int>>;
    std::cout << type_name<t>() << '\n';
    return 0;
}

我收到 vargs<char, int>作为使用 5.1.0 版本的 gcc 和 tag 时的输出使用 3.6.0 版本的 clang 时。我的意图是打印上面的代码 char所以我对这些结果感到很困惑。

上面的代码是合法的还是表现出未定义的行为？ 如果它是合法的，那么根据标准的预期行为是什么？

最佳答案

您的代码是正确的；类外隐式实例化类模板成员类模板部分特化旨在被标准允许，只要它们定义得足够早。

首先，让我们尝试一个最小的示例 - 顺便注意这里没有任何东西需要 C++11:

template<class T> struct A {
  template<class T2> struct B { };
};
// implicitly instantiated class template member class template partial specialization
template<> template<class T2>
  struct A<short>::B<T2*> { };
A<short>::B<int*> absip;    // uses partial specialization?

正如其他地方所指出的，MSVC 和 ICC 使用部分特化，正如预期的那样； clang 选择了部分特化，但弄乱了它的类型参数，别名 T2至short而不是 int ;而 gcc 完全忽略了部分特化。

为什么允许类外隐式实例化类模板成员类模板部分特化

简单地说，允许其他形式的类模板成员类模板定义的语言都不排除类外隐式实例化的类模板成员类模板部分特化。在 [temp.mem] 中，我们有:

1 - A template can be declared within a class or class template; such a template is called a member template. A member template can be defined within or outside its class definition or class template definition. [...]

类模板部分特化是模板声明 ([temp.class.spec]/1)。在同一段中，还有一个类外非特化类模板成员类模板部分特化的例子([temp.class.spec]/5):

template<class T> struct A {
  struct C {
    template<class T2> struct B { };
  };
};
// partial specialization of A<T>::C::B<T2>
template<class T> template<class T2>
  struct A<T>::C::B<T2*> { };
A<short>::C::B<int*> absip; // uses partial specialization

这里没有任何东西表明封闭范围不能是封闭类模板的隐式特化。

类似的还有类内类模板成员类模板部分特化和类外隐式实例化类模板成员类模板全特化的例子([temp.class.spec.mfunc]>2):

template<class T> struct A {
  template<class T2> struct B {}; // #1
  template<class T2> struct B<T2*> {}; // #2
};
template<> template<class T2> struct A<short>::B {}; // #3
A<char>::B<int*> abcip; // uses #2
A<short>::B<int*> absip; // uses #3
A<char>::B<int> abci; // uses #1

(clang (截至 3.7.0-svn235195) 得到第二个示例错误；它为 absip 选择 #2 而不是 #3。)

虽然这里没有明确提到类外隐式实例化类模板成员类模板部分特化，但也不排除它；它不在这里的原因是它与所提出的特定点无关，即哪个主模板或部分模板特化被认为是特定特化的。

根据[temp.class.spec]:

6 - [...] when the primary template name is used, any previously-declared partial specializations of the primary template are also considered.

在上面的最小示例中，A<short>::B<T2*>是主模板的部分特化 A<short>::B所以应该考虑。

为什么不允许这样做

在其他讨论中，我们看到提到隐式实例化(封闭类模板)可能导致发生主模板特化定义的隐式实例化，从而导致格式错误的程序 NDR，即 UB； [templ.expl.spec]:

6 - If a template, a member template or a member of a class template is explicitly specialized then that specialization shall be declared before the first use of that specialization that would cause an implicit instantiation to take place, in every translation unit in which such a use occurs; no diagnostic is required. [...]

但是，这里的类模板成员类模板在实例化之前是没有用到的。

其他人的想法

在 DR1755 (active) ，给出的例子是:

template<typename A> struct X { template<typename B> struct Y; };
template struct X<int>;
template<typename A> template<typename B> struct X<A>::Y<B*> { int n; };
int k = X<int>::Y<int*>().n;

仅从实例化封闭类的第二行存在的角度来看，这被认为是有问题的。提交者(Richard Smith)或 CWG 没有建议即使没有第二行也可能无效。

在 n4090 ，给出的例子是:

template<class T> struct A {
  template<class U> struct B {int i; }; // #0
  template<> struct B<float**> {int i2; }; // #1
  // ...
};
// ...
template<> template<class U> // #6
struct A<char>::B<U*>{ int m; };
// ...
int a2 = A<char>::B<float**>{}.m; // Use #6 Not #1

这里提出的问题是类内类模板成员类模板完全特化和类外类模板实例化成员类模板部分特化之间的优先级；没有建议 #6根本不会考虑。

关于c++ - gcc 和 clang 上奇怪的嵌套类部分特化结果，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/31393530/