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

我打算有一个类，它有一个内部类和一个名称相似的方法。的代码为example1.cpp即使我有一个内部类和一个同名的方法，编译也没有问题B. While example2.cpp如果我重命名将不起作用Position to position用小写字母。在这种情况下，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() {}
};

在这种情况下，标准不禁止 http://eel.is/c++draft/class#name-2引入一个其名称已被使用的类。它确实对这种情况开放：

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

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

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

在这种情况下，标准严格禁止 http://eel.is/c++draft/temp#7（除了少数例外，这些都不适用于此处）：

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

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

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

    void C() {}
};

然后访问它们：

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