C++ 中的内部类会自动成为朋友吗？

Question

如果我在 C++ 中定义了一个内部类，它会自动成为包含它的类的朋友吗？例如，这是否合法：

class Outer {
public:
    class Inner {
    public:
        void mutateOuter(Outer& o);
    };

private:
    int value;
};

void Outer::Inner::mutateOuter(Outer& o) {
    o.value ++; // Legal?  Or not?
}

我之所以问，是因为在我尝试过的某些编译器 (VS2003) 上，此代码不起作用，但我至少听说过它确实适用于某些编译器。我在 C++ 规范中找不到关于此的相关部分，如果有人能引用一些具体的内容来说明它是否合法，那就太好了。

Answer 1

在我自己提出了或多或少相同的问题here 之后，我想分享（显然）C++11 的更新答案：

引用自https://stackoverflow.com/a/14759027/1984137：

标准 $11.7.1

"嵌套类是一个成员，因此具有相同的访问权限 任何其他成员。封闭类的成员没有特殊的 访问嵌套类的成员；通常的访问规则应为 服从”

并且通常的访问规则指定：

"一个类的成员也可以访问该类的所有名称 有权限...”

标准中已给出具体示例：

class E {
    int x;
    class B { };

    class I {
        B b; // OK: E::I can access E::B
        int y;
        void f(E* p, int i) {
            p->x = i; // OK: E::I can access E::x
        }
    };
}

Answer 2

直到 C++11（即 C++98 和 C++03）

在 C++98 和 C++03 中，嵌套类不能默认访问封闭类的 private 和 protected 成员。

C++ 标准 (2003) 在 $11.8/1 [class.access.nest] 中说，

嵌套类的成员没有 对成员的特殊访问 封闭类，也不是类或 赋予友谊的功能 到封闭类；通常 访问规则（第 11 条）应 服从了。 封闭的成员 类没有特殊的访问权限 嵌套类的成员； 通常 访问规则（第 11 条）应 服从。

标准本身的示例：

class E 
{
    int x;
    class B { };
    class I 
    {
        B b; // error: E::B is private
        int y;
        void f(E* p, int i)
        {
           p->x = i; // error: E::x is private
        }
   };
   int g(I* p)
   {
       return p->y; // error: I::y is private
   }
};

C++11 起

自 C++11 起，上述限制已被删除。现在嵌套类可以访问封闭类的private 和protected 成员：

class E 
{
    int x;
    class B { };
    class I 
    {
        B b; // ok: even though E::B is private
        int y;
        void f(E* p, int i)
        {
           p->x = i; // ok: even though E::x is private
        }
   };
   int g(I* p)
   {
       return p->y; // ok: even though I::y is private
   }
};

希望对您有所帮助。

Answer 3

由于提问者似乎已经接受了其中一个答案，这只是 补充。
该标准似乎改变了关于可访问性的规范。

C++98 中的§11.8/1 状态：

嵌套类的成员没有 对成员的特殊访问 封闭类，也不是类或 赋予友谊的功能 到封闭类；通常 应遵守访问规则。

N1804（TR1 之后）中的§11.8/1 规定：

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

我认为当前的 C++ 编译器遵循更新的规范。

Answer 4

此答案与（过时的）C++03 规范有关。在此问题上接受的答案是最新的。

好吧，我现在问这个问题感觉很傻，因为我刚刚找到了规范中涵盖此问题的相关部分：§11.8/1：

嵌套类的成员对封闭类的成员没有特殊的访问权，也对与封闭类授予友谊的类或函数没有特殊的访问权限；应遵守通常的访问规则（第 11 条）。 封闭类的成员对嵌套类的成员没有特殊的访问权限；应遵守通常的访问规则（第 11 条）

（我的重点）

所以看起来没有，内部类没有特殊的访问权限。

Answer 5

我不知道确切的位置，但我确实记得阅读规范并发现一个类中的任何私有数据对所有其他类都隐藏，包括嵌套类。

基本上，嵌套类定义了一定的范围，而不是访问权限。