成员在不同名称空间中的别名声明专门化
[英]Member specialization of alias declaration in different namespaces
问题描述
I just encountered a strange difference in behavior between clang and gcc where I wanted to compile code which looks similar to the following: 
我刚刚在clang和gcc之间遇到了一个奇怪的区别，我想编译看起来类似于以下内容的代码：
namespace n1 {
template <class T1, class T2>
struct MyTemplate {
struct Inner {};
};
}
using namespace n1;
namespace n2 {
using MyClass = MyTemplate<int, int>;
}
namespace n1 {
using n2::MyClass;
template<> struct MyClass::Inner {
int member;
};
MyClass::Inner inner{0};
}
Clang happily compiles this: Clang愉快地编写了这个：
$ clang++ -std=c++11 -c -o alias_specialization.o alias_specialization.cc
but gcc throws the following error: 但是gcc会抛出以下错误：
$ g++ -std=c++11 -c -o alias_specialization.o alias_specialization.cc
alias_specialization:15:30: error: declaration of ‘struct n1::MyTemplate<int, int>::Inner’ in namespace ‘n1’ which does not enclose ‘using MyClass = struct n1::MyTemplate<int, int>’
template<> struct MyClass::Inner {
I know I can just write the full name of the original type ( MyTemplate<int, int> ) instead of MyClass in line 15. But I'm simply wondering which of the two compilers is "right". 我知道我可以在第15行写出原始类型的全名（ MyTemplate<int, int> ）而不是MyClass 。但我只是想知道两个编译器中的哪一个是“正确的”。 The exact compilers in use are: 使用的确切编译器是：
$ clang++ --version
clang version 4.0.0
$ g++ --version
g++ (GCC) 6.3.1 20170306
1 个解决方案
解决方案1
4 已采纳 2017-05-04 20:44:59
Disclaimer : 免责声明 ： GCC Clang is right (as @suluke pointed out, using the findings below). GCC Clang是对的（正如@suluke指出的那样，使用下面的发现）。
I found the following passages in the C++14 standard, but I am sure the same applies to C++11: 我在C ++ 14标准中找到了以下段落，但我确信这同样适用于C ++ 11：
Part I: Specialization & Instantiation of Templates 第一部分：模板的专业化和实例化
inline namespace (§7.3.1 cl. 8): inline namespace （第7.3.1节，第8节）：
Members of an inline namespace can be used in most respects as though they were members of the enclosing namespace.
Explicit instantiation (§ 14.7.2 cl. 3) 显式实例化（§14.7.2cl.3）
If the explicit instantiation is for a class or member class, the elaborated-type-specifier in the declaration shall include a simple-template-id.
Explicit instantiation (§ 14.7.2 cl. 6) 显式实例化（§14.7.2cl.6）
An explicit instantiation of a class, function template, or variable template specialization is placed in the namespace in which the template is defined.
namespace N {
template<class T> class Y { void mf() { } };
}
template class Y<int>; // error: class template Y not visible
// in the global namespace
using N::Y;
template class Y<int>; // error: explicit instantiation outside of the
// namespace of the template
template class N::Y<char*>; // OK: explicit instantiation in namespace N
template void N::Y<double>::mf(); // OK: explicit instantiation
// in namespace N
— end example ]
Part II: Typedef, Aliasing 第二部分：Typedef，Aliasing
What is typedef or an alias? 什么是typedef或别名？
§7.1.3 cl. §7.1.3cl。 1 states: 1州：
[...] A name declared with the typedef specifier becomes a typedef-name.
§7.1.3 cl. §7.1.3cl。 2 states: 2州：
A typedef-name can also be introduced by an alias-declaration .
Part III: Testing Your Case 第三部分：测试你的案例
Following your logic the following code should compile and produce 2 different types. 遵循您的逻辑，以下代码应编译并生成2种不同的类型。 I tested it with Clang, which is the compiler in question. 我用Clang测试了它，这是有问题的编译器。 Clang produces the same type as standard it requires. Clang生产的标准与其要求的标准相同。
#include <iostream>
namespace n1 {
template <class T1, class T2>
struct MyTemplate {
struct Inner {};
};
}
using namespace n1;
namespace n2 {
using MyClass = MyTemplate<int, int>;
}
namespace n3 {
using MyClass = MyTemplate<int, int>;
}
namespace n1 {
using n2::MyClass;
template<> struct MyClass::Inner {
int member;
};
MyClass::Inner inner{0};
}
namespace n4{
using n3::MyClass;
MyClass::Inner inner{0};
}
int main()
{
using namespace std;
cout << typeid(n1::inner).name() << endl;
cout << typeid(n4::inner).name() << endl;
return 0;
}
Compilation 汇编
c++ -std=c++14 typedef-typeid.cpp -O3 -o compiled.bin
OR 要么
c++ -std=c++11 typedef-typeid.cpp -O3 -o compiled.bin
Output in both cases 两种情况下的输出
N2n110MyTemplateIiiE5InnerE
N2n110MyTemplateIiiE5InnerE
As it turns out that in this context typedef and using are equivalent, we can use typedef instead of using . 事实证明，在这种情况下， typedef和using是等价的，我们可以使用typedef而不是using 。
§7.3.3 cl. §7.3.3cl。 1 points this out: 1分指出：
[...] If a using-declaration names a constructor (3.4.3.1), it implicitly declares a set of constructors in the class in which the using-declaration appears (12.9);
#include <iostream>
#include <typeinfo>
namespace n1 {
template <class T1, class T2>
struct MyTemplate {
struct Inner {};
};
}
using namespace n1;
namespace n2 {
typedef MyTemplate<int, int> MyClass;
}
namespace n1 {
typedef n2::MyClass MyClass;
template<> struct MyClass::Inner {
int member;
};
MyClass::Inner inner{0};
}
int main()
{
using namespace std;
cout << typeid(n1::inner).name() << endl;
return 0;
}
And GCC perfectly compiles the example, without blaming anything. GCC完美地编写了这个例子，没有任何指责。
In addition it'd be interesting to find out how the transitiveness with using declaration works with GCC. 另外，了解using声明的传递性如何与GCC一起using会很有趣。
Here is the modified example: 这是修改后的例子：
#include <iostream>
#include <typeinfo>
namespace n1 {
template <class T1, class T2>
struct MyTemplate {
struct Inner {};
};
}
using namespace n1;
namespace n2 {
using MyClass = MyTemplate<int, int>;
}
namespace n3
{
using n2::MyClass;
}
namespace n1 {
typedef n3::MyClass MyClass;
template<> struct MyClass::Inner {
int member;
};
MyClass::Inner inner{0};
}
int main()
{
using namespace std;
cout << typeid(n1::inner).name() << endl;
return 0;
}
And again both Clang and GCC happily compile it. Clang和GCC再次愉快地编译它。
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.