1

没有长时间的延迟，这里的代码我不知道它为什么会这样做：

#include <iostream>

class A {
private:
  void print() { std::cout << "A.print() called" << std::endl; };
public:
  template<typename Foo>
  class B; //NOTE: no friend!
public:
  A();
  B<double>*  bd;
  B<int>*     bi;
}; 

template<typename Foo>
class A::B{
  A* callback;
public:
  B(A* a):callback(a){};
  void print() { callback->print(); }; // Why is this working ???
};

A::A():bd(new B<double>(this)),bi(new B<int>(this)){}

int main(int argc, char **argv)
{
  A a;
//   a.print(); // error: ‘void A::print()’ is private
  a.bd->print();
  a.bi->print();

  A::B<char> c(&a);
  c.print();

  A::B<double> d = *a.bd;
  d.print();

  return 0;
}

好吧，它创建了这个输出：

A.print() called
A.print() called
A.print() called
A.print() called

但为什么？

背景

当我遇到一个与 s 相关的问题时，我最初开始了我的兔子洞之旅friend。因此，我阅读了朋友声明而不是转发声明（以及此处和此处提到的答案）。因此，在尝试设置一个简单的示例（您在上面看到的结果）时，我发现我实际上似乎根本不需要friend。

问题

所以这是一个底线问题：为什么一个实例A::B可以访问A的私有函数A::print()？（尽管我确实意识到我可能会误解我的孩子是什么——孩子而不是基础与派生）

4

2 回答 2

4

因为嵌套类是封闭类的成员

标准 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
        }
    };
}
于 2013-02-07T19:09:21.647 回答
2

嵌套类（或内部类）可以访问它所嵌套的类的私有内容。它在某种意义上已经是那个班级的朋友了。这类似于任何A对象可以访问任何其他A对象的私有信息的方式。

您friend用于在您想要访问其私有的类之外定义的类。这是一个简单的例子：

struct B;

class A
{
  int x;
  friend struct B;
};

struct B
{
  void someFunc() {
    A a;
    a.x = 5;
  }
};

int main(int argc, const char* argv[])
{
  B b;
  b.someFunc();
  return 0;
}

不交B朋友A，就无法A访​​问会员x。

于 2013-02-07T19:06:55.077 回答