关于C ++外部类访问内部类的私有：C ++外部类访问内部类的私有 – 为什么禁止


C++ Outer class access Inner class's private - why forbidden

你好，我想知道为什么我们在C++标准中allows巢式class'私人领域外的接入号接入，while it to s forbids私人领域内class' from the outer class。我的理解：example，thisP＞＜／

1
2
3
4
5
6
7
8
9
class OuterClass{
public:
    class InnerClass{
    public:
        void printOuterClass(OuterClass& outer) {cout << outer.m_dataToDisplay;};
    };
private:
    int m_dataToDisplay;
};

是的，因为我的东西，有时可以是复杂的内舱。但我想结束后的情景：is alsoP＞＜／

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Algorithm{
public:
    class AlgorithmResults{
    public:
        void readAlgorithmResult();
    private:
        void writeAlgorithmResult();
    };

    void calculate(AlgorithmResults& results, Arguments...){
       //calculate stuff
       results.writeAlgorithmResult(results);
    }
};

对我来说这让完美的结构感，尽管它是不可在C + +。noticed also that for some的，时间都是允许在Java第二example is also，但现在禁止。是is the reason is that，第一和一个可denied example is？P＞＜／

本质上，在该作用域前面声明的作用域名称内是有效的，可以直接使用(除非它们被隐藏)。范围外的代码不能直接使用范围内声明的名称。例如，大括号块后的代码不能直接使用该块内声明的变量(间接使用的一个例子是外部代码可以访问大括号块内静态变量的指针)。

对于第二个例子，只需使Algorithm成为AlgorithmResults的friend：

1
2
3
class AlgorithmResults
{
    friend class Algorithm;
相关讨论

反问题：你为什么要允许？

如果您需要一个外部类可以访问内部类的私有内部，那么您可以：

1
2
3
4
5
6
7
8
9
10
11
12
    class Foo {
    public:
            class Frob {
                    friend class Foo;
                    int privateDataMember;
            };

            Foo () {
                    Frob frob;
                    frob.privateDataMember = 3735928559;
            }
    };

C++没有UnFrice的设备，因此允许对外部类的默认私有访问将窃取您的类设计工具并产生减少的默认封装。

嵌套类可以访问外部类的私有字段，因为它是外部类的成员，与其他成员相同。

[类.访问.嵌套]/1

A nested class is a member and as such has the same access rights as any other member.

另一方面，外部类对嵌套类没有特殊的访问权限，它们只是正常的关系。

The members of an enclosing class have no special access to members of a nested class; the usual access rules ([class.access]) shall be obeyed. [?Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
    }
  };

  int g(I* p) {
    return p->y;                // error: I?::?y is private
  }
};

—?end example?]

相关讨论