具有相同名称的方法和内部类(错误:.. 与前面的声明冲突）

Method and inner class with the same name (error: ... conflicts with a previous declaration)

本文关键字：错误 前面 冲突 声明 方法 内部类      更新时间：2023-10-16

我打算有一个具有内部类和具有相似名称的方法的类。example1.cpp代码编译没有问题，即使我有一个内部类和一个同名的方法B.虽然如果我用小写字母将Position重命名为position，example2.cpp将无法正常工作。在这种情况下，position()方法和position类相互冲突，我收到：

error: ‘ObjType::position<false> ObjType::position() const’ conflicts with a previous declaration
inline auto position() const->class position<false>{return {*this};}
^
compilation terminated due to -Wfatal-errors.

这两个类有什么区别？为什么后一个给出错误而不是前一个？

g++ -std=c++11 exampleX.cpp -Wall -Wextra -Wfatal-errors && ./a.out

.

// example1.cpp
#include <iostream>
class A
{
public:
friend class B;
class B
{
public:
int x;
void show() {std::cout<<"x: "<<x<<std::endl;}
B(): x(6) {}
};
B B()
{
class B b;
return b;
}
};
int main()
{
A a;
a.B().show();
return 0;
}

.

// example2.cpp
#include <iostream>
#include <type_traits>
class Point
{
public:
double x,y,z;
void print() const
{
std::cout<<"x:"<<x<<", y:"<<y<<", z:"<<z<<std::endl;
}
};
class ObjType
{
template<bool> friend class Position;
Point data;
public:
template<bool ByRef>
class Position
{
typename std::conditional<ByRef,ObjType&,ObjType const&>::type ref;
public:
inline Position(typename std::conditional<ByRef, ObjType&, ObjType const&>::type ref) : ref(ref) {}
inline Position(const Point &ref): ref(ref){}
inline auto operator =(Point const& a)->Position&{ref.data.subvec(0,2)=a; return *this;}
inline auto operator =(Point&& a)->Position&{data=a; return *this;}
inline void print() const{ref.data.print();}
};
inline ObjType(const Point &data): data(data){}
inline void print() const{data.print();}
/*error > */ inline auto position() const->class Position<false>{return {*this};}
inline auto position()->class Position<true>{return {*this};}
};
int main()
{
ObjType obj({1.1,1.2,1.3});
std::cout<<"****************"<<std::endl;
std::cout<<"obj.print() :"<<std::endl;
obj.print();
std::cout<<"obj.position.print() :"<<std::endl;
obj.position().print();
std::cout<<"****************"<<std::endl;
return 0;
}

这两个类有什么区别？为什么后一个给出错误而不是前一个？

我们可以将您的示例进一步简化为以下类：

struct S {
struct C {};
void C() {}
};

在这种情况下，标准并不禁止引入名称已在使用的类。确实对这样的情况持开放态度：

如果在还声明了

同名变量、函数或枚举器的作用域中声明了类名，则 [...]

它只是规定如何引用它以及隐藏什么。
另一方面，考虑以下类：

struct S {
template<typename> struct C {};
void C() {}
};

在这种情况下，标准严格禁止它(除了少数例外，这里都不适用(：

类模板

不得与同一作用域中的任何其他模板、类、函数、变量、枚举、枚举器、命名空间或类型同名

因此，您不可能使用相同的标识符来命名类模板和其他函数。
您仍然可以将所有类型打包在一个封闭的范围内，无论如何您都不会定义具有相同名称的函数。举个例子：

struct S {
struct T {
template<typename>
struct C {};
};
void C() {}
};

然后按以下方式访问它们：

S::T::C<void> c;

您的示例 1 和示例 2 在一个显著方面有所不同：示例 1 不涉及模板类，下面是同样失败的示例 1 版本：

#include <iostream>
class A
{
template<bool> friend class B;
public:
template<bool ByRef>
class B
{
public:
int x;
void show() {std::cout<<"x: "<<x<<std::endl;}
B(): x(6) {}
};
B<true> B()
{
class B<true> b;
return b;
}
};
int main()
{
A a;
a.B().show();
return 0;
}
相关文章：