C++ Primer Plus 学习笔记第十五章友元类友元成员函数其他友元关系共同的友元嵌套类

灰太狼 2022-01-19 23:57 252阅读 0赞

与友元函数类似。

代码：

tv.h

#ifndef TV_H_
    #define TV_H_
    
    class Tv
    {
      public:
    // 这就是友元类的写法
        friend class Remote;
        enum {Off, On};
        enum {MinVal, MaxVal = 20};
        enum {Antenna, Cable};
        enum {TV, DVD};
    
        Tv(int s = Off, int mc = 125) : state(s), volume(5),
            maxchannel(mc), channel(2), mode(Cable), input(TV) {}
        void onoff() {state = (state == On) ? Off : On;}
        bool ison() {return state == On;}
        bool volup();
        bool voldown();
        void chanup();
        void chandown();
        void set_mode() {mode = (mode == Antenna) ? Cable : Antenna;}
        void set_input() {input = (input == TV)? DVD : TV;}
        void settings() const;
    
      private:
        int state;
        int volume;
        int maxchannel;
        int channel;
        int mode;
        int input;
    };
    
    class Remote
    {
      private:
        int mode;
      public:
        Remote(int m = Tv::TV) : mode(m){}
        bool volup(Tv & t) {return t.volup();}
        bool voldown(Tv & t) {return t.voldown();}
        void cnoff(Tv & t) {t.onoff();}
        void chanup(Tv & t) {t.chanup();}
        void chandown(Tv & t) {t.chandown();}
    
    // 这里涉及到了友元的访问作用域 如果不是友元的话  编译器不允许直接调用对象的私有成员
        void set_chan(Tv & t, int c) {t.channel = c;}
        void set_mode(Tv & t) {t.set_mode();}
        void set_input(Tv & t) {t.set_input();} 
    };
    
    #endif

这里面那么多的函数 只有1个函数涉及到了友元，那能不能让特定的成员函数成为友元呢？ 可以：

class Tv
    {
        friend void Remote::set_chan(Tv & t, int c);
        .....
    };

光这样写还不行  要让编译器事先知道Remote是啥 但是， 又有一个问题 Remote中有涉及到了Tv类，那也要事先让编译器知道Tv类是啥; 这就蛋疼了，咋搞？

使用前向声明

class Tv;

class Remote \{....\};

class Tv\{...\};

这样排列后还是有一个问题，就是Remote中很多函数时内联函数，也就是说提前调用了Tv类的函数。那编译器依然找不到对应的函数。咋办？

Remote类中涉及调用Tv类的成员的部分 放到Tv类定义的代码段后面写。就可以了

上示例吧：

#ifndef TV_H_
    #define TV_H_
    
    // 先声明
    class Tv;
    
    class Remote
    {
      public:
        enum {Off, On};
        enum {MinVal, MaxVal = 20};
        enum {Antenna, Cable};
        enum {TV, DVD};
      private:
        int mode;
      public:
        Remote(int m = TV) : mode(m){}
        bool volup(Tv & t);
        bool voldown(Tv & t);
        void cnoff(Tv & t);
        void chanup(Tv & t);
        void chandown(Tv & t);
        void set_chan(Tv & t, int c);
        void set_mode(Tv & t);
        void set_input(Tv & t);
    };
    
    // 再详细声明
    class Tv
    {
      public:
    // 特定友元函数
        friend void Remote::set_chan(Tv & t, int c);
        enum {Off, On};
        enum {MinVal, MaxVal = 20};
        enum {Antenna, Cable};
        enum {TV, DVD};
    
        Tv(int s = Off, int mc = 125) : state(s), volume(5),
            maxchannel(mc), channel(2), mode(Cable), input(TV) {}
        void onoff() {state = (state == On) ? Off : On;}
        bool ison() {return state == On;}
        bool volup();
        bool voldown();
        void chanup();
        void chandown();
        void set_mode() {mode = (mode == Antenna) ? Cable : Antenna;}
        void set_input() {input = (input == TV)? DVD : TV;}
        void settings() const;
    
      private:
        int state;
        int volume;
        int maxchannel;
        int channel;
        int mode;
        int input;
    };
    
    // 最后定义内联函数
    inline bool Remote::volup(Tv & t) {return t.volup();}
    inline bool Remote::voldown(Tv & t) {return t.voldown();}
    inline void Remote::cnoff(Tv & t) {t.onoff();}
    inline void Remote::chanup(Tv & t) {t.chanup();}
    inline void Remote::chandown(Tv & t) {t.chandown();}
    inline void Remote::set_mode(Tv & t) {t.set_mode();}
    inline void Remote::set_input(Tv & t) {t.set_input();}
    inline void Remote::set_chan(Tv & t, int c) {t.channel = c;}
    #endif

其他友元关系：

如果Tv类成为Remote的友元。那有一点要注意  在Tv类中调用了Remote类的相关成员或成员函数  一定要写在Remote类详细声明的后面。（先来后到 不然编译器无法识别Remote是啥玩意儿，这个跟刚才那个友元成员函数是一个情况）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70][]

共同的友元

这个没啥内容 就是弄一个内联函数 然后成为两个或者多个类的友元函数就是了

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 1][]

这里有句话很关键

![20190610143157455.png][]

嵌套类

嵌套类定义格式

![20190610143653644.png][]

嵌套类的作用域：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 2][]

![20190610144217144.png][]

访问控制：

![20190610144828250.png][]

模板中的嵌套

其实就是内部类啦

形象的表示就是人的器官 也是类 但是是在人这个类的内部

上代码：

queuetp.h

#ifndef QUEUETP_H_
    #define QUEUETP_H_
    
    template<class Item>
    class QueueTP
    {
      private:
        enum {Q_SIZE = 10};
        class Node
        {
          public:
            Item item;
            Node * next;
            Node(const Item & i) : item(i), next(0) {}
        };
        Node * front;
        Node * rear;
        int items;
        const int qsize;
        QueueTP(const QueueTP & q) : qsize(0) {}
        QueueTP & operator=(const QueueTP & q) {return *this;}
      public:
        QueueTP(int qs = Q_SIZE);
        ~QueueTP();
        bool isempty() const
        {
          return items == 0;
        }
        bool isfull() const
        {
          return items == qsize;
        }
        int queuecount() const
        {
          return items;
        }
        bool enqueue(const Item & item);
        bool dequeue(Item & item);
    };
    
    template<class Item>
    QueueTP<Item>::QueueTP(int qs) : qsize(qs)
    {
      front = rear = 0;
      items = 0;
    }
    
    template<class Item>
    QueueTP<Item>::~QueueTP()
    {
      Node * temp;
      while(front != 0)
      {
        temp = front;
        front = front-> next;
        delete temp;
      }
    }
    
    template<class Item>
    bool QueueTP<Item>::enqueue(const Item & item)
    {
      if (isfull())
        return false;
      Node * add = new Node(item);
      items++;
      if (front == 0)
        front = add;
      else
        rear->next = add;
      rear = add;
      return true;
    }
    
    template<class Item>
    bool QueueTP<Item>::dequeue(Item & item)
    {
      if (front == 0)
        return false;
      item = front->item;
      items--;
      Node * temp = front;
      front = front -> next;
      delete temp;
      if (items == 0)
        rear = 0;
      return true;
    }
    
    #endif

nested.cpp

#include <iostream>
    #include "queuetp.h"
    
    int main()
    {
      using std::string;
      using std::cin;
      using std::cout;
    
      QueueTP<string> cs(5);
      string temp;
    
      while(!cs.isfull())
      {
        cout << "Please enter your name. You will be "
                "served in the order of arrival.\n"
                "name: ";
        getline(cin, temp);
        cs.enqueue(temp);
      }
      cout << "The queue is full. Processing begins!\n";
    
      while (!cs.isempty())
      {
        cs.dequeue(temp);
        cout << "Now processing " << temp << "...\n";
      }
      return 0;
    }

完结

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70]: /images/20220120/91cc1b5fc0e34bcda88e0ad05e84f175.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 1]: /images/20220120/3dfeb9eb7b5a40a1abbbb5b9bfadfc30.png
[20190610143157455.png]: /images/20220120/5dec750d2512474a9a0bb75900f6f2e4.png
[20190610143653644.png]: /images/20220120/dbcfc298c0b4436298c55d4628249da3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 2]: /images/20220120/171d619c08604865ba0a6523439edfbd.png
[20190610144217144.png]: /images/20220120/8ea71f922b544cf0b3cb108a4783a129.png
[20190610144828250.png]: /images/20220120/6b4bddaac15648aa8a31f5cc492dd3ae.png