嵌套类显式特化：不同C++编译器的行为差异

Great question—this is one of those compiler-specific quirks that comes down to how different implementations handle the finer points of template specialization syntax, especially when /Za (disable Microsoft extensions) is enabled in VC++. Let's break this down step by step.

First, let's restate your code clearly for context:

template <typename> struct A { template <typename> struct B { }; };
template <> template <> struct A<int>::B<char> { static void foo(); };
void A<int>::B<char>::foo() { }
int main() { }

What's going wrong in VC++? #

The error message you see (C2906: 'void A&...') is a truncated version of what VC++ is actually struggling with: it's misparsing the qualified name A<int>::B<char> when you define foo() outside the struct. When /Za is enabled, VC++ drops its non-standard extensions, but in this case, it loses a workaround that normally helps it resolve nested template specializations correctly.

Essentially, VC++ is incorrectly interpreting A<int> as a reference type (hence the A& in the error) instead of recognizing it as the fully specialized outer template containing the specialized nested B<char> struct. This is a long-standing parsing limitation in VC++ when dealing with out-of-class definitions of members from directly specialized nested templates.

Why do Clang and GCC accept it? #

Clang and GCC strictly follow the C++14 standard here. The standard allows you to explicitly specialize a nested template (like A<int>::B<char>) without first fully specializing the outer template (A<int>). When you write void A<int>::B<char>::foo(), both compilers correctly resolve the scope: they first find the specialized A<int> (even though you didn't explicitly write its full specialization), then locate the specialized B<char> inside it, and correctly bind the foo() definition to that static member.

A workaround for VC++ with /Za #

To get this code compiling in VC++, you just need to explicitly specialize the outer A<int> template first—even if it's just a mirror of the primary template. This gives VC++ a clear scope to resolve before handling the nested B<char> specialization:

template <typename> struct A { template <typename> struct B { }; };

// Explicitly specialize A<int> first (matches the primary template)
template <> struct A<int> { template <typename> struct B { }; };

// Now specialize B<char> inside the explicitly specialized A<int>
template <> struct A<int>::B<char> { static void foo(); };

// The out-of-class definition now works correctly in VC++
void A<int>::B<char>::foo() { }

int main() { }

This small change removes the ambiguity VC++ was facing, letting it properly resolve the nested scope.

Wrap-up #

At the end of the day, this is a VC++ specific issue with how it parses nested template specializations when /Za is active. Clang and GCC adhere to the standard properly here, while VC++ needs a little extra hand-holding in the form of an explicit outer template specialization to get the syntax right.

内容的提问来源于stack exchange，提问作者Constructor