C++ 嵌套模板类型的部分专门化会产生；“内部错误”；在VC&x2B+；2012编译器

在下面的示例中，我有一个对象类，它定义了一个引用类。两者都接受可变性作为模板参数。在“obj”是“Const”的情况下，我不允许“Non_Const”类型的引用。该示例在VisualC++ 2012中产生了“编译器内部错误已经发生”的模糊消息。这个应该编译吗？如果没有，原因是什么，还有其他方法可以完成同样的事情吗

enum Mutability {Const, Non_Const};

template <typename T, Mutability U>
class Obj
{
public:
    template <Mutability V>
    class Ref
    {
    public:
        Ref() {}

        friend class Obj;
    };

    Obj() {}
};

template <typename T>
class Obj<T, Const>::template Ref<Non_Const>
{
private:
    Ref() {}
}; //error C1001: An internal error has occurred in the compiler

int main()
{
    Obj<int, Const>::Ref<Non_Const> test;
}

enum可变性{Const，Non_Const}；
模板
Obj类
{
公众：
模板
类参考
{
公众：
Ref（）{}
朋友级Obj；
};
Obj（）{}
};
模板
类Obj:：模板引用
{
私人：
Ref（）{}
}; //错误C1001:编译器中发生内部错误
int main（）
{
Obj:：Ref测试；
}

您试图做的是部分显式地专门化成员类模板。这只是无效的C++，基本上是试图部分地专门化成员的想法。不幸的是，VC在试图编译时崩溃了，gcc并没有给出一个有用的错误，但clang发生在：

main.cpp:21:31: error: cannot specialize a dependent template
class Obj<T, Const>::template Ref<Non_Const>
                              ^

main.cpp:21:31:错误：无法专门化依赖模板
类Obj:：模板引用
^

但是，您可以在整个过程中明确地进行专门化：

template <>
template <>
class Obj<int, Const>::Ref<Non_Const>
{
private:
    Ref() {}
};

模板
模板
类Obj：：Ref
{
私人：
Ref（）{}
};

---

然后您唯一的编译错误是

Ref（）

是

private

您试图做的是部分显式地专门化成员类模板。这只是无效的C++，基本上是试图部分地专门化成员的想法。不幸的是，VC在试图编译时崩溃了，gcc并没有给出一个有用的错误，但clang发生在：

main.cpp:21:31: error: cannot specialize a dependent template
class Obj<T, Const>::template Ref<Non_Const>
                              ^

main.cpp:21:31:错误：无法专门化依赖模板
类Obj:：模板引用
^

但是，您可以在整个过程中明确地进行专门化：

template <>
template <>
class Obj<int, Const>::Ref<Non_Const>
{
private:
    Ref() {}
};

模板
模板
类Obj：：Ref
{
私人：
Ref（）{}
};

---

然后你唯一的编译错误是

Ref（）

是

private

如果你想要做的是不允许将

V

实例化为

Ref

当

U

是

可变性：：const

时，我们可以使用一些模板技巧来实施这个概念：

（比我聪明的人可能会让这更简单）

你可以这样测试：

int main()
{
    Obj<int, Mutability::Const>::Ref<Mutability::Const> test1; //pass
    //Obj<int, Mutability::Const>::Ref<Mutability::Non_Const> test2; // fail
    Obj<int, Mutability::Non_Const>::Ref<Mutability::Const> test3; // pass
    Obj<int, Mutability::Non_Const>::Ref<Mutability::Non_Const> test4; // pass
}

intmain（）
{
Obj:：Ref test1；//通过
//Obj:：Ref test2；//失败
Obj:：Ref test3；//通过
Obj:：Ref test4；//通过
}

---

如果您想要做的是当

U

为

Mutability:：const

时，不允许将

V

实例化为

Ref

，那么我们可以使用一些模板技巧来实施这一概念：

（比我聪明的人可能会让这更简单）

你可以这样测试：

int main()
{
    Obj<int, Mutability::Const>::Ref<Mutability::Const> test1; //pass
    //Obj<int, Mutability::Const>::Ref<Mutability::Non_Const> test2; // fail
    Obj<int, Mutability::Non_Const>::Ref<Mutability::Const> test3; // pass
    Obj<int, Mutability::Non_Const>::Ref<Mutability::Non_Const> test4; // pass
}

intmain（）
{
Obj:：Ref test1；//通过
//Obj:：Ref test2；//失败
Obj:：Ref test3；//通过
Obj:：Ref test4；//通过
}

---

C1001基本上意味着编译器崩溃，因此一方面这是一个编译器错误（VS2013也有同样的功能），但它也无法使用gcc进行编译：这是非常糟糕的-不是循环的，但某种程度上是循环声明。C1001基本上意味着编译器崩溃，因此一方面这是一个编译器错误（VS2013做同样的事情），但是它也不能用gcc编译：这是非常糟糕的-不是循环的，但某种程度上是循环声明。C1001基本上意味着编译器崩溃了，所以一方面这是一个编译器错误（VS2013做同样的事情），但它也无法使用gcc编译：这是一个非常糟糕的问题——不是循环的，而是某种程度上的循环声明。