如何声明两个类以使 A 具有 B 的成员和 B 将 A 的成员标记为朋友？

Question

我正在尝试做 C++ Primer 5th Edition 中的练习 7.32。该练习提出以下问题：

定义您自己的Screen 和Window_mgr 版本，其中clear 是Window_mgr 的成员和Screen 的朋友。

以下是文中给出的Screen、Window_mgr 和clear 的定义。

class Screen
{
  public:
    using pos = std::string::size_type;
    Screen(pos ht, pos wd, char c) : height(ht), width(wd), contents(ht * wd, c) { }
  private:
    pos height = 0, width = 0;
    std::string contents;
};

class Window_mgr
{
  public:
    using ScreenIndex = std::vector<Screen>::size_type;
    void clear(ScreenIndex);
  private:
    std::vector<Screen> screens{Screen(24, 80 ' ')};
};

void Window_mgr::clear(ScreenIndex i)
{
  Screen &s = screens[i];
  s.contents = std::string(s.height * s.width, ' ');
}

现在这两个类，如果先定义 Screen 而不是 Window_mgr 就可以按我的预期工作。现在，练习要求我将 clear 设为 Screen 的朋友并定义 clear。要让clear成为会员，如果我理解正确的话，Window_mgr必须被定义。要定义Window_mgr，必须定义Screen。这对我来说似乎是不可能的。

文字给出了以下提示：

使成员函数成为朋友需要仔细构造我们的程序以适应声明和定义之间的相互依赖关系。在这个例子中，我们必须按如下顺序排列我们的程序：

• 首先，定义Window_mgr 类，它声明但不定义clear。 Screen 必须在clear 可以使用Screen 的成员之前声明。

• 接下来，定义类Screen，包括clear 的朋友声明。

• 最后，定义clear，现在可以引用Screen中的成员。

我尝试解决这个练习的顺序最终是这样的：

class Screen;

class Window_mgr
{
  public:
    using ScreenIndex = std::vector<Screen>::size_type;
    void clear(ScreenIndex);
  private:
    std::vector<Screen> screens{Screen(24, 80 ' ')};
};

class Screen
{
  friend Window_mgr::clear(Window_mgr::ScreenIndex);
  public:
    using pos = std::string::size_type;
    Screen(pos ht, pos wd, char c) : height(ht), width(wd), contents(ht * wd, c) { }
  private:
    pos height = 0, width = 0;
    std::string contents;
};

void Window_mgr::clear(ScreenIndex i)
{
  Screen &s = screens[i];
  s.contents = std::string(s.height * s.width, ' ');
}

这显然行不通，因为Window_mgr 中的向量需要Screen 是一个完整的类型。这似乎是一个无法解决的问题，除非作者不打算使用他们之前介绍的 Screen 和 Window_mgr 类。

有没有其他人从 C++ Primer 中解决了这个练习。如果是这样，怎么做？任何帮助如何做到这一点，或者正如我的直觉告诉我的那样，无法做到？

Answer 1

正如 [class.friend]/5 所说：

当友元声明引用重载名称或运算符时，只有参数类型指定的函数成为友元。 X 类的成员函数可以是 Y 类的朋友。

在您的具体情况下：

#include <iostream>
#include <vector>

struct Screen;

class Window_mgr
{
  public:

    Window_mgr();

    using ScreenIndex = std::vector<Screen>::size_type;
    void clear(ScreenIndex);
  private:
    std::vector<Screen> screens;
};

class Screen
{
  friend void Window_mgr::clear(ScreenIndex);
  public:
    using pos = std::string::size_type;
    Screen(pos ht, pos wd, char c) : height(ht), width(wd), contents(ht * wd, c) { }
  private:
    pos height = 0, width = 0;
    std::string contents;
};


Window_mgr::Window_mgr():
  screens{1, Screen(24, 80, ' ') }
{
}

void Window_mgr::clear(ScreenIndex i)
{
  Screen &s = screens[i];
  s.contents = std::string(s.height * s.width, ' ');
}

int main()
{
  Window_mgr w;
  w.clear(0);
}

---

请注意，无法解决该练习，因为 Window_mgr 具有 std::vector 的成员变量，其参数是不完整的类型。它适用于大多数编译器（请参阅here 为什么），但标准禁止它。

这个例子演示了如何让一个类的成员函数成为朋友：

#include <iostream>

struct A;

struct B
{ 
  void bar( A& a, int l);
};

struct A
{
  friend void B::bar(A&,int);
  A():k(0){}
  private:
  void foo(int m);
  int k;
};



void A::foo(int m)
{
  std::cout<<"A::foo() changing from "<<k<<" to "<<m<<std::endl;
  k=m;
}

void B::bar( A& a, int l)
{
  std::cout<<"B::bar() changing to "<<l<<std::endl;
  a.foo(l);
}

int main()
{
  A a;
  B b;
  b.bar(a,11);
}