Question

我打算有一个具有内部类和类似名称的方法的类。 example1.cpp的代码编译没有问题，即使我有一个内部类和一个同名的方法B。如果我用小写字母将example2.cpp重命名为Position，则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;
}

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

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

2 个答案: