方法和内部类同名（错误：...与之前的声明冲突）

Question

我打算拥有一个具有内部类和名称相似的方法的类。 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;
}

Answer 1

这两个类有什么区别？为什么后一个报错，前一个报错？

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

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

在这种情况下，标准doesn't forbid 引入了一个名称已经在使用中的类。它确实对这种情况开放：

如果在声明同名变量、函数或枚举器的范围内声明类名，则 [...]

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

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

在这种情况下，标准strictly forbids it（除了少数例外，此处均不适用）：

类模板不得与同一范围内的任何其他模板、类、函数、变量、枚举、枚举器、命名空间或类型同名

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

struct S {
    struct T {
        template<typename>
        struct C {};
    };

    void C() {}
};

然后访问它们：

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

Answer 2

您的 example1 和 example2 有一个显着不同：example1 不涉及模板类，这里是 example1 的一个版本也失败了：

#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;
}