嵌套类C ++中的友谊

Question

我试图理解嵌套类中友谊的概念，但我没有正确理解这个概念。 我已经编写了一个示例程序来理解它，但该程序无法运行

#include<iostream>

using namespace std;


class outerClass
{
    private:
        int a;
    public:
        class innerClass;
        bool print(innerClass);
};

class innerClass
{
    friend class outerClass;
    private:
        int b;

    public:
        innerClass() =default;

};

bool outerClass::print(outerClass::innerClass obj)
{
    cout<<"Value of b in inner class is:"<<obj.b;
}

int main()
{
    outerClass in;
    outerClass::innerClass obj;
    obj.b=5;
    in.print(obj);
}

我收到以下错误：

try.cpp: In member function ‘bool outerClass::print(outerClass::innerClass)’:
try.cpp:26:6: error: ‘obj’ has incomplete type
try.cpp:11:15: error: forward declaration of ‘class outerClass::innerClass’
try.cpp: In function ‘int main()’:
try.cpp:34:28: error: aggregate ‘outerClass::innerClass obj’ has incomplete type and cannot be defined

当我阅读互联网上的文章时，我了解了以下几点，如果它们是正确的，请对它们进行评论：

• 默认情况下，innerClass可以访问outerClass的所有成员。
• 要使outerClass访问innnerClass的私有成员，我们需要将outerClass作为innerClass的友元类。

请帮助指出代码中的错误，以及我理解的点是否正确。

Answer 1

行class innerClass; outerClass是对您从未定义的class的前向声明 。

因此outerClass::innerClass是一个不完整的类型 。

以innerClass开头的单独innerClass定义

class innerClass
{

是一种完全不同class的向前声明的类。

你的friend class outerClass;没什么问题friend class outerClass; 定义的innerClass语句。

Answer 2

如果要定义innerClass之外outerClass ，这里是如何做到这一点：

class outerClass
{
    class innerClass; // forward declaration
};

class outerClass::innerClass // definition
{
};

其余的obj.b=5 ，除了obj.b=5 。 允许类outerClass访问innerClass::b ，而main()函数不允许。

演示

---

默认情况下，innerClass可以访问outerClass的所有成员。

对。 从标准[class.access.nest] ：

嵌套类是成员，因此具有与任何其他成员相同的访问权限。

---

要使outerClass访问innnerClass的私有成员，我们需要将outerClass作为innerClass的友元类。

对。 从标准[class.access.nest] ：

封闭类的成员对嵌套类的成员没有特殊访问权限;

Answer 3

我认为你对nested class和friend class感到困惑
您可以使用不使用nested class friend class
你可以使用不使用friend class nested class friend class

这是一些例子：

class A {};
class B {};

这里A类知道B类，但B不能知道A类。 所以你需要告诉A类B类是否存在。
这件事，被称为前进宣言
所以：

class B;       // forward declaration
class A {};    // A knows the B
class B {};    // B knows the A