什么时候应该使用好友类？

Question

可能的重复：
什么时候应该在 C++ 中使用“friend”？

什么时候应该 由于缺乏有关友元类的文档，这是一个绊脚石。大多数书籍只是简单地解释它，例如C++：完整参考的摘录：

Friend 类很少被使用。支持它们以允许处理某些特殊情况。

坦率地说，我从未在经验丰富的 C++ 程序员编写的任何优秀代码中见过友元类。所以，这是我的问题清单。

1. 继承类是否与基类具有相同的朋友？例如，如果我将类 foo 声明为基类的友元，则类 der（从基类派生）也会将 foo 作为友元吗？

2. 什么特殊情况应该使用友元类？

3. 我正在制作一个 winapi 包装器，我想让 WinHandle 类成为 Widget 类的友元（以访问一些受保护的成员）。推荐吗？或者我应该使用传统的 Get/Set 函数来访问它们？

Answer 1

Friend 用于授予选择性访问，就像受保护的访问说明符一样。也很难想出使用 protected 真正有用的正确用例。

一般来说，友元类在存在故意强耦合的设计中非常有用：您需要在两个类之间具有特殊关系。更具体地说，一个类需要访问另一个类的内部结构，并且您不希望使用公共访问说明符向每个人授予访问权限。

经验法则：如果公共太弱而私有太强，则需要某种形式的选定访问权限：受保护或 >friend（Java 中的包访问说明符具有相同的作用）。

示例设计

例如，我曾经编写了一个简单的秒表类，我希望隐藏本机秒表分辨率，但又让用户使用单个方法查询经过的时间并将单位指定为某种变量（例如，根据用户偏好进行选择）。我想要的是 elapsedTimeInSeconds()、elapsedTimeInMinutes() 等方法，而不是像 elapsedTime(Unit::seconds) 这样的方法>。为了实现这两个目标，我无法将本机分辨率设为公开或私有，因此我提出了以下设计。

实现概述

class StopWatch;

// Enumeration-style class.  Copy constructor and assignment operator lets
// client grab copies of the prototype instances returned by static methods.
class Unit
{
friend class StopWatch;
    double myFactor;
    Unit ( double factor ) : myFactor(factor) {}
    static const Unit native () { return Unit(1.0); }
public:
        // native resolution happens to be 1 millisecond for this implementation.
    static const Unit millisecond () { return native(); }

        // compute everything else mostly independently of the native resolution.
    static const Unit second () { return Unit(1000.0 / millisecond().myFactor); }
    static const Unit minute () { return Unit(60.0 / second().myFactor); }
};

class StopWatch
{
    NativeTimeType myStart;
    // compute delta using `NativeNow()` and cast to
    // double representing multiple of native units.
    double elapsed () const;
public:
    StopWatch () : myStart(NativeNow()) {}
    void reset () { myStart = NativeNow(); }
    double elapsed ( const Unit& unit ) const { return elapsed()*unit.myFactor; }
};

正如您所看到的，此设计实现了两个目标：

1. 本机分辨率永远不会暴露
2. 可以存储所需的时间单位等。

讨论

我真的很喜欢这个设计，因为原始实现存储了本机时间单位的倍数并执行除法来计算经过的时间。在有人抱怨除法太慢之后，我更改了 Unit 类来缓存被除数，使 elapsed() 方法（稍微）更快。

一般来说，应该力求强内聚、弱耦合。这就是为什么friend这么少用的原因，建议减少类之间的耦合。然而，在某些情况下，强耦合可以提供更好的封装。在这些情况下，您可能需要一个朋友。

Answer 2

继承类与基类有相同的朋友吗？例如，如果我将 foo 类声明为基类的友元，则 der 类（从基类派生）也会将 foo 作为友元吗？

friend 的规则 关键字是：
友谊属性不会继承。
因此，基类的朋友不会是派生类的朋友。

---

应该使用友元类的特殊情况是什么？

坦率地说，（恕我直言）使用友元类主要是为了实现一些相当易于使用的事情。如果一个软件的设计考虑到了所有的要求，那么实际上就不需要friend类了。值得注意的是，完美的设计几乎不存在，即使存在，也很难实现。

需要友元类的示例：
有时可能需要测试人员类（不是发布软件的一部分）访问类的内部以检查和记录某些特定结果/诊断。在这种情况下使用友元类是有意义的，以方便使用并防止设计开销。

---

我正在制作一个 winapi 包装器，其中我想让 WinHandle 类 成为 class Widget 的友元（以访问一些受保护的成员）。推荐吗？或者我应该使用传统的 Get/Set 函数来访问它们？

我会坚持使用传统的setter/getter。我宁愿避免使用 friend ，因为我可以通过通常的 OOP 构造来工作。也许，我对使用 friend 相当偏执，因为如果我的类将来更改/扩展，我会认为 friend 的非继承属性会给我带来问题。

---

编辑：
来自 @Martin 的评论以及来自 @André Caron 的精彩回答，提供了关于使用friendship 的全新视角，我以前没有遇到过&因此在上面的答案中没有考虑到。我将保留这个答案，因为它帮助我学习了新的观点和观点。希望它能帮助有类似观点的人们学习。

Answer 3

friend 通常说明您通常会使用一个类，但您必须使用多个类，因为它们具有不同的生命周期或实例计数等。 友谊关系不能转移、继承或传递。

Get/Set 非常糟糕，尽管比它可能的要好。 friend 允许您将伤害限制在一个类别。通常你会建立一个加好友的中间班级。

class MyHandleIntermediary;
class MyHandle {
    friend class MyHandleIntermediary;
private:
    HANDLE GetHandle() const;
};
class MyWidget;
class MyHandleIntermediary {
    friend class MyWidget;
    static HANDLE GetHandle(const MyWidget& ref) {
        return ref.GetHandle();
    }
};
class MyWidget {
    // Can only access GetHandle() and public
};

这允许您在每个成员级别上更改友谊的可访问性，并确保额外的可访问性记录在一个位置。

Answer 4

我应用“友元类”的情况之一是一个类由其他（对象）类组合或引用，并且组合对象需要访问主类的内部。

enum MyDBTableButtonBarButtonKind {
  GoFirst,
  GoPrior,
  GoNext,
  GoLast
}

class MyDBTableButtonBarButtonWidget;

class MyDBTableButtonBarWidget {

  friend class MyDBTableButtonBarButtonWidget;

// friend access method:
protected:
  void GoFirst();
  void GoPrior();
  void GoNext();
  void GoLast();

  void DoAction(MyDBTableButtonBarButtonKind Kind);
};

class MyDBTableButtonBarButtonWidget {

private:

  MyDBTableButtonBarWidget* Toolbar;

public:

  MyDBTableButtonBarButtonWidget(MyDBTableButtonBarWidget* AButtonBar) {
    this ButtonBar = AButtonBar;
  }

  MyDBTableButtonBarButtonKind Kind; 
public:
  virtual void Click() { Buttonbar->DoAction(this Kind); }; 
};

void MyDBTableButtonBarWidget::DoAction(MyDBTableButtonBarButtonKind Kind)
{
  switch (Kind)
  {
     case MyDBTableButtonBarButtonKind::GoFirst:
       this.GoFirst();
     break;

     case MyDBTableButtonBarButtonKind::GoLast:
       this.GoLast();
     break;
  }
}

在这个例子中，有一个小部件控件，它是一个由按钮组成的栏，按钮栏引用了一个数据库表，并且有几个用于特定操作的按钮，
就像选择表的第一条记录，编辑，移动到下一条记录。

为此，每个按钮类都具有对 private 和 private 的好友访问权限。给定控件的受保护方法。正如本文之前的回答，通常友元类充当单个类，分解为几个较小的类。

这不是一个完整的例子，它只是一个总体想法。