您何时应该使用＆＃x27;朋友＆＃x27;在c＆＃x2b;＆＃x2b;？

Question

我一直在阅读 c ++ faq ，对 朋友 声明。我个人从未使用过它，但是我有兴趣探索该语言。

使用 friend 的好例子是什么？

---

阅读FAQ更长的时间，我喜欢＆lt;＆lt; ＆gt;＆gt;＆gt; 操作员重载和添加这些类的朋友的想法。但是，我不确定这不会打破封装。这些例外何时可以保持在OOP的严格范围内？

Answer 1

首先（IMO）不要听那些说 friend 的人没有用。这很有用。在许多情况下，您将拥有具有数据或功能的对象，这些对象不打算公开可用。大型代码库尤其如此，许多作者可能只能表面上熟悉不同领域。

还有朋友指定符的替代方案，但通常它们很麻烦（CPP级混凝土类/蒙版Typedefs）或没有万无一失的（注释或功能名称公约）。

回答；

friend 指定符允许指定的类访问“ Friend”语句的类中的受保护数据或功能的访问。例如，在以下代码中，任何人都可以要求孩子姓名，但只有母亲和孩子才能更改名称。

您可以通过考虑更复杂的类（例如窗口）来进一步以这个简单的示例。很可能有一个窗口具有许多功能/数据元素，不应公开访问，而是相关类（例如WindowManager）所需的。

class Child
{
//Mother class members can access the private parts of class Child.
friend class Mother;

public:

  string name( void );

protected:

  void setName( string newName );
};

Answer 2

在工作中，我们使用朋友大量测试代码。这意味着我们可以为主要应用程序代码提供适当的封装和信息隐藏。但是，我们也可以使用单独的测试代码，该代码使用朋友检查内部状态和数据进行测试。

可以说我不会将朋友关键字作为您设计的重要组成部分。

Answer 3

friend 关键字具有许多很好的用途。这是我立即可见的两种用途：

朋友定义

朋友定义允许在类cope中定义一个函数，但是该函数不会定义为成员函数，而是封闭名称空间的免费函数，并且不会正常可见，除了依赖参数的查找。这使其对于运营商的重载特别有用：

namespace utils {
    class f {
    private:
        typedef int int_type;
        int_type value;

    public:
        // let's assume it doesn't only need .value, but some
        // internal stuff.
        friend f operator+(f const& a, f const& b) {
            // name resolution finds names in class-scope. 
            // int_type is visible here.
            return f(a.value + b.value);
        }

        int getValue() const { return value; }
    };
}

int main() {
    utils::f a, b;
    std::cout << (a + b).getValue(); // valid
}

私人CRTP基类

有时会发现策略需要访问派生类的需要：

// possible policy used for flexible-class.
template<typename Derived>
struct Policy {
    void doSomething() {
        // casting this to Derived* requires us to see that we are a 
        // base-class of Derived.
        some_type const& t = static_cast<Derived*>(this)->getSomething();
    }
};

// note, derived privately
template<template<typename> class SomePolicy>
struct FlexibleClass : private SomePolicy<FlexibleClass> {
    // we derive privately, so the base-class wouldn't notice that, 
    // (even though it's the base itself!), so we need a friend declaration
    // to make the base a friend of us.
    friend class SomePolicy<FlexibleClass>;

    void doStuff() {
         // calls doSomething of the policy
         this->doSomething();
    }

    // will return useful information
    some_type getSomething();
};

您会在 this 答案。 CRTP基础施放了该指针，以便能够使用Data-Member-Pointers访问派生类的数据场。

Answer 4

@rooo ：封装在这里没有打破，因为课程本身本身决定谁可以访问其私人成员。只有当您的操作员＆lt;＆lt; 会宣布“我是class foo >的朋友”时，只有在班级外部引起的封装才会被打破。

朋友代替 public 的使用，而不是使用 private ！

实际上，c ++常见问题已经回答了这一点。

Answer 5

规范的例子是超载运算符＆lt;＆lt;。另一个常见的用途是允许辅助或管理员类访问您的内部。

这是我听说过C ++朋友的几个准则。最后一个特别令人难忘。

• 您的朋友不是您孩子的朋友。
• 您孩子的朋友不是您的朋友。
• 只有朋友可以触摸您的私人零件。

Answer 6

编辑：阅读常见问题解答更长的时间，我喜欢＆lt;＆lt; ＆gt;＆gt;操作员超负荷并添加为这些类的朋友，但是我不确定这不会破坏封装

如何破坏封装？

当您允许无限制访问数据成员时，您会断开封装。考虑以下类：

class c1 {
public:
  int x;
};

class c2 {
public:
  int foo();
private:
  int x;
};

class c3 {
  friend int foo();
private:
  int x;
};

c1 是明显未封装的。任何人都可以在其中读取和修改 x 。我们无法执行任何类型的访问控制。

C2 显然已封装。无法公开访问 X 。您所能做的就是调用 foo 函数，该功能在类上执行一些有意义的操作。

C3 ？那封装不太封装吗？它是否允许对 x 的无限制访问？它允许未知功能访问吗？

否。它允许精确一个功能访问类的私人成员。就像 C2 一样。就像 C2 一样，具有访问权限的一个函数不是“某些随机，未知函数”，而是“类定义中列出的函数”。就像 c2 一样，我们可以看到，只需查看类定义，a 完整谁访问了。

那么，这少封装到底如何呢？相同数量的代码可以访问班级的私人成员。 拥有访问权限的每个人都在类定义中列出。

朋友不会断开封装。这使一些Java人程序员感到不舒服，因为当他们说“ OOP”时，他们实际上是 “ Java”。当他们说“封装”时，他们并不是说“私人成员必须受到任意访问的保护”，而是“ Java类，其中唯一能够访问私人成员的功能是班级成员”，即使这是完全胡说八道< em>出于多种原因。

首先，如前所述，它太限制了。没有理由不应该允许朋友方法这样做。

其次，它不是限制性足够的。考虑第四节：

class c4 {
public:
  int getx();
  void setx(int x);
private:
  int x;
};

根据上述Java的心态，这是完美封装的。
但是，它绝对允许任何人阅读和修改x 。这甚至有意义？ （提示：不是）

底线：
封装是关于能够控制哪些功能可以访问私人成员。它不是 准确地说是这些函数的定义所在的位置。

Answer 7

安德鲁（Andrew）示例的另一个常见版本是可怕的代码耦合，

parent.addChild(child);
child.setParent(parent);

而不必担心是否始终在一起完成两行，并且以一致的顺序完成，您可以将方法私有化并具有朋友函数来执行一致性：

class Parent;

class Object {
private:
    void setParent(Parent&);

    friend void addChild(Parent& parent, Object& child);
};

class Parent : public Object {
private:
     void addChild(Object& child);

     friend void addChild(Parent& parent, Object& child);
};

void addChild(Parent& parent, Object& child) {
    if( &parent == &child ){ 
        wetPants(); 
    }
    parent.addChild(child);
    child.setParent(parent);
}

换句话说，您可以保持公共接口保持较小的，强制执行不变的，这些不变性在朋友函数中跨越类和对象。

Answer 8

您可以使用私人/保护/公共权利控制会员的访问权限和功能吗？
因此，假设这三个级别中的每个级别的每一个都很清楚，那么我们应该很明显我们缺少某些东西……

例如，将成员/函数声明为保护是相当通用的。您说的是，此功能是每个人（当然是继承的孩子）。但是例外呢？每个安全系统都可以让您拥有某种类型的“白色列表”，对吗

？感觉是有道理的，

我认为这是不需要的，因为我认为这与全球变量的讨论相似。他们...但是实际上，您会看到最终成为（几乎）最优雅的方式的情况...我认为这与朋友是同一情况。

除了让您不使用设置函数的情况下访问成员变量外，它并没有真正的好处

，这并不是查看它的方法。
这个想法是控制谁可以访问什么，具有或不设置函数与之无关。

Answer 9

我找到了使用朋友访问的方便的地方：私人功能的UNITSEST。

Answer 10

C ++的创建者说，这并不是任何封装原则，我会引用他：

“朋友”是否违反封装？
不，它没有。 “朋友”是授予访问权限的明确机制，就像会员资格一样。您无法（在标准符合程序中）在不修改其来源的情况下授予自己访问类。

很清楚...

Answer 11

当您构建一个容器时，朋友会派上方便，并且想为该课程实现迭代器。

Answer 12

我们曾在我以前在我们使用朋友来体面影响的公司工作的公司出现一个有趣的问题。我在框架部门工作，我们在自定义操作系统上创建了一个基本的发动机级系统。在内部，我们有一个课堂结构：

         Game
        /    \
 TwoPlayer  SinglePlayer

所有这些课程都是框架的一部分，并由我们的团队维护。该公司制作的游戏是建立在此框架之上的，该框架源于其中一个儿童游戏。问题在于，游戏与单个玩家和Twoplayer需要访问的各种事物具有界面，但我们不希望在框架类别之外展示。解决方案是将这些接口私有化，并允许Twoplayer和单人游戏通过友谊访问它们。

坦白说，这整个问题本可以通过更好地实施我们的系统来解决，但我们被锁定在我们所拥有的。

Answer 13

简短的答案是：使用 friend 实际上改进封装。提高可读性和可用性（运营商＆lt;＆lt;＆gt;＆gt;是规范的例子）也是一个很好的理由。

至于改进封装的示例，专门设计用于与其他类（想到的测试课程）合作的课程是良好的候选人。

Answer 14

在C ++“朋友”中，关键字可用于操作员的过载和制作桥梁。

1.）运算符重载中的朋友关键字：
操作员重载的示例是：假设我们有一个具有两个float变量的类“点”
“ x”（用于x坐标）和“ y”（用于y坐标）。现在，我们必须超载“＆lt;＆lt;“ （提取操作员），这样，如果我们调用“ cout＆lt＆lt;＆lt; pointobj” ，则它将打印x和y坐标（其中pointOBJ是类点的对象）。为此，我们有两个选择：

   1.Overload "operator <<()" function in "ostream" class.
   2.Overload "operator<<()" function in "Point" class.

Now First option is not good because if we need to overload again this operator for some different class then we have to again make change in "ostream" class.

That's why second is best option. Now compiler can call
"operator <<()" function:

   1.Using ostream object cout.As: cout.operator<<(Pointobj) (form ostream class).
   2.Call without an object.As: operator<<(cout, Pointobj) (from Point class).

BeaCause我们已经在积分类中实施了重载。因此，要在没有对象的情况下调用此函数，我们必须添加“朋友” 关键字，因为我们可以在没有对象的情况下调用朋友函数。
现在函数声明将为：
“朋友ostream＆amp; ocerator＆lt;＆lt;（ostream＆amp; cout，point＆amp; pointobj）;“

2.）Friend制作桥梁的关键字：
假设我们必须发挥一个函数，在该功能中，我们必须访问两个或多个类的私人成员（通常称为“桥”）。
如何做到这一点：
要访问班级的私人成员，应该是该课程的成员。现在，要访问其他班级的私人成员，每个班级应将该功能声明为朋友函数。例如 ：
假设有两个A和B类B。函数“ funcbridge（）” 想要访问两个类的私人成员。然后两个类都应声明“ funcbridge（）” as：
朋友return_type funcbridge（a＆amp; a_obj，b＆amp; b_obj）;

我认为这将有助于了解朋友关键字。

Answer 15

作为

朋友声明出现在班级主体中，并授予了私人和受保护的 的函数或其他类别的成员。

因此，正如提醒的那样，某些答案中存在技术错误，这些答案说 friend 只能访问受保护成员。

Answer 16

另一个用途： friend （+虚拟继承）可用于避免从类派生（aka：“使class class ofer class noverable vivable”）=＆gt; 1 ， 2

来自 2 ：

 class Fred;

 class FredBase {
 private:
   friend class Fred;
   FredBase() { }
 };

 class Fred : private virtual FredBase {
 public:
   ...
 }; 

Answer 17

为了多次进行TDD，我在C ++中使用了“朋友”关键字。

朋友可以知道我的一切吗？

---

更新：我从 bjarne stroustroup site 。

“朋友”是授予访问的明确机制，就像会员资格一样。

Answer 18

您必须非常谨慎地使用 friend 关键字的何时/地点，并且像您一样，我很少使用它。以下是有关使用 friend 和替代方案的一些注释。

假设您要比较两个对象，以查看它们是否相等。您可以：

• 使用访问者方法进行比较（检查每个IVAR并确定平等）。
• 或者，您可以通过公开来直接访问所有成员。

第一个选项的问题在于，这可能是很多访问者，这比直接变量访问速度（稍微）慢，难以读取和麻烦。第二种方法的问题是您完全打破了封装。

很好的是，如果我们可以定义一个外部功能，该功能仍然可以访问班级的私人成员。我们可以使用 friend 关键字来完成此操作：

class Beer {
public:
    friend bool equal(Beer a, Beer b);
private:
    // ...
};

方法均等（啤酒，啤酒）现在可以直接访问 a 和 b /code>的私人成员（可以是 char *brand ， float percental ochol 等。这是一个相当理想的例子，您会尽快应用 friend /代码>到Overloaded ==操作员，我们要注意的是

：

• friend 不是类的成员功能
• 。具有特殊访问班级私人成员的普通功能
• 不会用朋友替换所有登记器和突变器（您最好将所有内容 public ！）
• 友谊不是互惠的
• 友谊
• 友谊不是继承的
• ，或者，作为 c ++ faq解释：“仅仅因为我授予您友谊的访问权限并不能自动授予您的孩子访问我，因此不会自动授予您的朋友访问我，并且不会自动授予我访问您。

” 朋友以其他方式更难做到这一点。作为另一个示例，由于 mat2x2 ， mat3x3 ， mat4x4 friends >， vec2 ， vec3 ， vec4 等。变得更容易成为朋友，而不必在各地使用访问者。正如指出的那样，当应用于＆lt;＆lt; 时， friend 通常是有用的 == 运算符，但也可以用于这样的事情：

class Birds {
public:
    friend Birds operator +(Birds, Birds);
private:
    int numberInFlock;
};


Birds operator +(Birds b1, Birds b2) {
    Birds temp;
    temp.numberInFlock = b1.numberInFlock + b2.numberInFlock;
    return temp;
}

正如我所说，我根本不使用 friend ，但时不时地是正是您需要的。希望这有帮助！

Answer 19

似乎我迟到了14年。但是来了。

TLDR TLDR

朋友类在那里，以便您可以将封装扩展到包含您数据结构的一组类。

TLDR

通常由多个类组成。与传统类（由您的编程语言支持）类似，您的数据结构是一个广义类，它在该数据上还具有数据和不变性，这些数据跨越了多个类的对象。封装可以保护那些不变的人免受外部数据的意外修改，以便数据结构的操作（“成员函数”）正常工作。朋友类将封装从类扩展到您的广义类。

太长的

A 类是与不变的一起指定数据类型值的子集，称为有效状态。对象是类的有效状态。类的A 成员函数将给定对象从有效状态移至另一个。

至关重要的是，对象数据不会从类成员函数外部进行修改，因为这可能会破坏类不变（即将对象移至无效状态）。 封装禁止从班级外部访问对象数据。这是编程语言的重要安全功能，因为它很难使班级不变。

一类通常是实现数据结构的自然选择，因为数据结构的属性（例如性能）取决于其数据的不变性（例如红色％e2％80％93Black_tree“ rel =“ nofollow noreferrer”>红黑树不变式）。但是，有时单个类不足以描述数据结构。

A 数据结构是将数据从有效状态转移到另一个数据的任何数据，不变性和功能。这是一个班级的概括。微妙的区别在于，数据可以散布在数据类型上，而不是集中在单个数据类型上。

数据结构示例

数据结构的原型示例是 vertex ），边缘（class edge ）和图形（类 Graph ）。这些课程没有独立的意义。图类创建 vertex s and edge 由其成员函数（例如 graph.addvertex（） and and graph.addedge（avertex） ，bvertex）），并返回与它们的指针（或类似）。 vertex s and edge S同样被其拥有 Graph （例如 graph.removevertex（vertex）和和和<代码> graph.removeedge（edge））。 顶点对象的收集， edge 对象和图形对象一起编码数学图。在此示例中，目的是 vertex / edge 对象在 Graph> Graph 对象之间未共享（其他设计选择也是可能的）。

Graph 对象可以存储其所有顶点和边缘的列表，而每个 vertex 可以存储一个指向其拥有的指针 graph 。因此， Graph 对象代表整个数学图，每当需要数学图时，您都会将其传递。

不变的示例

图形数据结构不变的是 vertex 在其所有者 Graph 的列表中列出。这个不变的跨越 vertex 对象和 Graph 对象。多种类型的多种对象可以参与给定的不变。

封装示例

类似于类，数据结构受益于封装，它可以防止意外修改其数据。这是因为数据结构需要保留不变性，才能像一类一样以应许的方式运行。

在图形数据结构示例中，您会声明 vertex 是 Graph 的朋友，也使构造函数和数据成员的 vertex >私有，以便只能通过 Graph 创建顶点。特别是， vertex 将具有一个私有构造函数，它可以接受指向其拥有图的指针。该构造函数在 graph.addvertex（）中被称为，这是可能的，因为 vertex 是 graph 的朋友。 （但是请注意， Graph 不是 vertex 的朋友：无需 vertex 能够访问 Graph 的顶点列表，例如。）

术语

数据结构的定义本身就像类一样。我建议我们开始使用术语“广义类”来用于将数据从有效状态转移到另一个数据的任何数据，不变性和功能。然后，C ++类是一种特定类型的广义类。然后，不言而喻的朋友类是将封装从C ++类扩展到广义类的精确机制。

（实际上，我希望“班级”一词被替换为“广义班级”的概念，并将“本地班级”用于编程语言支持的类的特殊情况。然后，当教课程时，您将了解这两个本地阶级和这些广义班级。

Answer 20

关于运营商＆lt;＆lt;和操作员＆gt;＆gt;没有充分的理由结交这些运营商的朋友。的确，他们不应该是会员功能，但也不需要成为朋友。

最好的办法是创建公共打印（Ostream＆amp;）并读取（istream＆amp;）功能。然后，写操作员＆lt;＆lt;和操作员＆gt;＆gt;就这些功能而言。这给您带来了允许您虚拟函数的额外好处，从而提供虚拟序列化。

Answer 21

我只使用Friend-keyword来获得Unitest Wearp的功能。有人会说您不应该测试受保护的功能。但是，在添加新功能时，我会发现此非常有用的工具。

但是，我不直接在类声明中使用关键字，而是使用漂亮的模板黑客来实现这一点：

template<typename T>
class FriendIdentity {
public:
  typedef T me;
};

/**
 * A class to get access to protected stuff in unittests. Don't use
 * directly, use friendMe() instead.
 */
template<class ToFriend, typename ParentClass>
class Friender: public ParentClass
{
public:
  Friender() {}
  virtual ~Friender() {}
private:
// MSVC != GCC
#ifdef _MSC_VER
  friend ToFriend;
#else
  friend class FriendIdentity<ToFriend>::me;
#endif
};

/**
 * Gives access to protected variables/functions in unittests.
 * Usage: <code>friendMe(this, someprotectedobject).someProtectedMethod();</code>
 */
template<typename Tester, typename ParentClass>
Friender<Tester, ParentClass> & 
friendMe(Tester * me, ParentClass & instance)
{
    return (Friender<Tester, ParentClass> &)(instance);
}

这使我能够执行以下操作：

friendMe(this, someClassInstance).someProtectedFunction();

在GCC和MSVC上工作。

Answer 22

树示例是一个很好的例子：
在没有几个不同的类中实现对象
具有继承关系。

也许您也可能需要它以保护构造函数并强制
人们使用您的“朋友”工厂。

...好吧，坦率地说，您可以没有它。

Answer 23

做很多次我在C ++中使用过“朋友”的关键字。
朋友可以知道我的一切吗？

不，这只是一种一种一种方式友谊：`（

Answer 24

我使用 friend 的一个特定实例是创建 singletleton classe。 friend 关键字使我可以创建一个访问器函数，该功能比在类上使用“ getInstance（）”方法更简洁。

/////////////////////////
// Header file
class MySingleton
{
private:
    // Private c-tor for Singleton pattern
    MySingleton() {}

    friend MySingleton& GetMySingleton();
}

// Accessor function - less verbose than having a "GetInstance()"
//   static function on the class
MySingleton& GetMySingleton();


/////////////////////////
// Implementation file
MySingleton& GetMySingleton()
{
    static MySingleton theInstance;
    return theInstance;
}

Answer 25

朋友功能和课程可直接访问私人和受保护的班级成员，以避免在一般情况下破坏封装。大多数用法是关于Ostream：我们希望能够键入：

Point p;
cout << p;

但是，这可能需要访问点的私人数据，因此我们定义了超载运算

friend ostream& operator<<(ostream& output, const Point& p);

符，但是，显而易见的封装含义。首先，现在，朋友的班级或功能可以完全访问班级的所有成员，即使是与其需求无关的成员。其次，班级和朋友的实现现在被淘汰到班级内部变化可以破坏朋友的地步。

如果您将朋友视为班级的扩展，那么从逻辑上讲，这不是问题。但是，在这种情况下，为什么有必要首先将朋友带出来。

为了实现“朋友”声称要实现的同一目标，但是如果不违反封装，就可以做到这一点：

class A
{
public:
    void need_your_data(B & myBuddy)
    {
        myBuddy.take_this_name(name_);
    }
private:
    string name_;
};

class B
{
public:
    void print_buddy_name(A & myBuddy)
    {
        myBuddy.need_your_data(*this);
    }
    void take_this_name(const string & name)
    {
        cout << name;
    }
}; 

封装没有破坏，B类无法访问A中的内部实现，但结果与我们一样b宣布为A的朋友。
编译器将优化函数调用，因此这将导致与直接访问相同的说明。

我认为使用“朋友”只是一个具有可争议的好处的捷径，但成本确定。

Answer 26

在为类实现树算法时，教授给我们的框架代码将树类作为节点类的朋友。

除了让您无需使用设置功能而访问成员变量之外，它并没有真正的好处。

Answer 27

您 可以遵守最严格，最纯粹的OOP原则，并确保任何班级的数据成员甚至都具有 concectors ，以便所有对象必须是只有能够以唯一的方式对数据了解他们的数据的人是通过间接消息，即方法。

但是，即使C＃也具有内部可见性关键字，Java的默认值 package 对某些事物的级别可访问性。 C ++实际上是通过最小化可见性妥协到类中的OOP理想来实现的。进入它。

我实际上并不使用C ++，但是如果C＃有 friend s，我会代替汇编全球内部修饰符，我实际上使用了很多。它并没有真正破坏裁员，因为.NET 中的部署单位是一个组件。

但是，还有 internalsvisibleto 属性（其他设备），它的作用像跨组件 friend 机制。 Microsoft将其用于Visual 设计器组件。

Answer 28

当不同的班级（不是另一个阶层）使用另一个班级的私人或受保护的成员时，您可能会使用友谊。

朋友功能的典型用例是操作
在两个不同类别之间进行私人或受保护
两者的成员。

来自 http://www.cplusplus.com/doc/doc/tutorial/tutorial/inheritance/ 。

您可以在此示例中看到非成员方法访问类的私人成员。该方法必须在该班级中为班级的朋友声明。

// friend functions
#include <iostream>
using namespace std;

class Rectangle {
    int width, height;
  public:
    Rectangle() {}
    Rectangle (int x, int y) : width(x), height(y) {}
    int area() {return width * height;}
    friend Rectangle duplicate (const Rectangle&);
};

Rectangle duplicate (const Rectangle& param)
{
  Rectangle res;
  res.width = param.width*2;
  res.height = param.height*2;
  return res;
}

int main () {
  Rectangle foo;
  Rectangle bar (2,3);
  foo = duplicate (bar);
  cout << foo.area() << '\n';
  return 0;
}

Answer 29

可能我错过了上面答案中的一些东西，但是封装中的另一个重要概念是隐藏实施。减少对私人数据成员的访问（类的实现详细信息），可以更轻松地修改代码。如果朋友直接访问私人数据，则任何更改实现数据字段（私有数据）的任何更改，请打破访问该数据的代码。使用访问方法大多消除了这一点。我认为很重要。

Answer 30

这可能不是实际的用例情况，但可能有助于说明课程之间的朋友使用。

俱乐部会所

class ClubHouse {
public:
    friend class VIPMember; // VIP Members Have Full Access To Class
private:
    unsigned nonMembers_;
    unsigned paidMembers_;
    unsigned vipMembers;

    std::vector<Member> members_;
public:
    ClubHouse() : nonMembers_(0), paidMembers_(0), vipMembers(0) {}

    addMember( const Member& member ) { // ...code }   
    void updateMembership( unsigned memberID, Member::MembershipType type ) { // ...code }
    Amenity getAmenity( unsigned memberID ) { // ...code }

protected:
    void joinVIPEvent( unsigned memberID ) { // ...code }

}; // ClubHouse

成员班级的

class Member {
public:
    enum MemberShipType {
        NON_MEMBER_PAID_EVENT,   // Single Event Paid (At Door)
        PAID_MEMBERSHIP,         // Monthly - Yearly Subscription
        VIP_MEMBERSHIP,          // Highest Possible Membership
    }; // MemberShipType

protected:
    MemberShipType type_;
    unsigned id_;
    Amenity amenity_;
public:
    Member( unsigned id, MemberShipType type ) : id_(id), type_(type) {}
    virtual ~Member(){}
    unsigned getId() const { return id_; }
    MemberShipType getType() const { return type_; }
    virtual void getAmenityFromClubHouse() = 0       
};

class NonMember : public Member {
public:
   explicit NonMember( unsigned id ) : Member( id, MemberShipType::NON_MEMBER_PAID_EVENT ) {}   

   void getAmenityFromClubHouse() override {
       Amenity = ClubHouse::getAmenity( this->id_ );
    }
};

class PaidMember : public Member {
public:
    explicit PaidMember( unsigned id ) : Member( id, MemberShipType::PAID_MEMBERSHIP ) {}

    void getAmenityFromClubHouse() override {
       Amenity = ClubHouse::getAmenity( this->id_ );
    }
};

class VIPMember : public Member {
public:
    friend class ClubHouse;
public:
    explicit VIPMember( unsigned id ) : Member( id, MemberShipType::VIP_MEMBERSHIP ) {}

    void getAmenityFromClubHouse() override {
       Amenity = ClubHouse::getAmenity( this->id_ );
    }

    void attendVIPEvent() {
        ClubHouse::joinVIPEvent( this->id );
    }
};

便利设施

class Amenity{};

如果您在这里查看这些课程的关系，则 ；俱乐部会所拥有各种不同类型的会员资格和会员资格。成员都源自超级或基类，因为它们都共享一个常见的ID和枚举类型，外部类可以通过在基类中找到的访问功能访问其ID和类型。

但是，通过这种成员及其派生阶级的层次结构及其与Clubhouse阶级的关系，唯一具有“特殊特权”的阶级是Vipmember班级。基类和其他两个派生类无法访问Clubhouse的JoinVipeVent（）方法，但是VIP成员类具有该特权，就好像它可以完全访问该活动一样。

因此，借助Vipmember和会所，这是一条两条通道的两条通道，在其他会员类也有限。