C++ 友元类

定义友元类

tv.h

  1. #ifndef PRO1_TV_H
  2. #define PRO1_TV_H
  5. class Tv {
  6. private:
  7.     int state;
  8.     int volume;
  9.     int maxchannel;
  10.     int channel;
  11.     int mode;
  12.     int input;
  13. public:
  14.     friend class Remote;
  15.     enum {Off, On};
  16.     enum {MinVal, MaxVal = 20};
  17.     enum {Antenna, Cable};
  18.     enum {TV, VCR};
  20.     Tv(int s = Off, int mc = 100):state(s), volume(5), maxchannel(mc), channel(2), mode(Cable), input(TV){}
  21.     void onoff(){state = (state == On) ? Off : On;}
  22.     bool ison()const { return state == On; }
  23.     bool volup();
  24.     bool voldown();
  25.     void chanup();
  26.     void chandown();
  27.     void set_mode(){ mode = (mode == Antenna) ? Cable : Antenna; }
  28.     void set_input(){ input = (input == TV) ? VCR : TV; }
  29.     void setting()const;
  30. };
  32. class Remote{
  33. private:
  34.     int mode;
  35. public:
  36.     Remote(int m = Tv::TV):mode(m){}
  37.     bool volup(Tv & t){ return t.volup(); }
  38.     bool voldown(Tv & t){ return t.voldown(); }
  39.     void onoff(Tv & t) { t.onoff(); }
  40.     void chanup(Tv & t){ t.chanup(); }
  41.     void chandown(Tv & t){ t.chandown(); }
  42.     void set_chan(Tv & t, int c){ t.channel = c; }
  43.     void set_mode(Tv & t){ t.set_mode(); }
  44.     void set_input(Tv & t){ t.set_input(); }
  45. };
  48. #endif //PRO1_TV_H

友元类的使用

tv.cpp

  1. #include "tv.h"
  2. #include <iostream>
  4. using namespace std;
  6. bool Tv::volup() {
  7.     if (volume < MaxVal) {
  8.         volume++;
  9.         return true;
  10.     } else
  11.         return false;
  12. }
  14. bool Tv::voldown() {
  15.     if (volume > MinVal) {
  16.         volume--;
  17.         return true;
  18.     } else
  19.         return false;
  20. }
  22. void Tv::chanup() {
  23.     if (channel < maxchannel) {
  24.         channel++;
  25.     } else
  26.         channel = 1;
  27. }
  29. void Tv::chandown() {
  30.     if (channel > 1)
  31.         channel--;
  32.     else
  33.         channel = maxchannel;
  34. }
  36. void Tv::setting() const {
  37.     cout << "TV is " << (state == Off? "Off":"On") << endl;
  38.     if (state == On) {
  39.         cout << "Volume setting = " << volume << endl;
  40.         cout << "Channel setting = " << channel << endl;
  41.         cout << "Mode = " << (mode == Antenna ? "antenna" : "cable") << endl;
  42.         cout << "Input = " << (input == TV ? "TV" : "VCR") << endl;
  43.     }
  44. }

main.cpp

  1. #include <iostream>
  2. #include "module12_friend_class/tv.h"
  4. using namespace std;
  6. // 友元类的使用
  7. void useFriendClass(){
  8.     Tv s27;
  9.     cout << "Initial setting for 27\" TV:\n";
  10.     s27.setting();
  11.     s27.onoff();
  12.     s27.chanup();
  13.     cout << "\nAdjusted setting for 27\" TV:\n";
  14.     s27.setting();
  16.     Remote grey;
  17.     grey.set_chan(s27, 10);
  18.     grey.volup(s27);
  19.     grey.volup(s27);
  20.     cout << "\n27\" settings after using remote:\n";
  21.     s27.setting();
  23.     Tv s32(Tv::On);
  24.     s32.set_mode();
  25.     grey.set_chan(s32, 28);
  26.     cout << "\n32\" setting:\n";
  27.     s32.setting();
  28. }
  30. int main() {
  31.     useFriendClass();
  32.     return 0;
  33. }

友元成员函数

tvfm.h

  1. #ifndef PRO1_TVFM_H
  2. #define PRO1_TVFM_H
  4. class Tv;
  6. class Remote {
  7. public:
  8.     enum State{Off, On};
  9.     enum {MinVal, MacVal = 20};
  10.     enum {Antenna, Cable};
  11.     enum {TV, VCR};
  12. private:
  13.     int mode;
  14. public:
  15.     Remote(int m = TV):mode(m){}
  16.     bool volup(Tv & t);
  17.     bool voldown(Tv & t);
  18.     void onoff(Tv & t);
  19.     void chanup(Tv & t);
  20.     void chandown(Tv & t);
  21.     void set_chan(Tv & t, int c);
  22.     void set_mode(Tv & t);
  23.     void set_input(Tv & t);
  24. };
  26. class Tv{
  27. private:
  28.     int state;
  29.     int volume;
  30.     int maxchannel;
  31.     int channel;
  32.     int mode;
  33.     int input;
  34. public:
  35.     friend void Remote::set_chan(Tv &t, int c);
  36.     enum {Off, On};
  37.     enum {MinVal, MaxVal = 20};
  38.     enum {Antenna, Cable};
  39.     enum {TV, VCR};
  41.     Tv(int s = Off, int mc = 100): state(s), volume(5), maxchannel(mc), channel(2), mode(Cable), input(TV){}
  42.     void onoff(){state = (state == On) ? Off : On;}
  43.     bool ison()const { return state == On; }
  44.     bool volup();
  45.     bool voldown();
  46.     void chanup();
  47.     void chandown();
  48.     void set_mode(){ mode = (mode == Antenna) ? Cable : Antenna; }
  49.     void set_input(){ input = (input == TV) ? VCR : TV; }
  50.     void setting()const;
  51. };
  53. // Remote methods as inline functions
  54. inline bool Remote::volup(Tv &t) { return t.volup(); }
  55. inline bool Remote::voldown(Tv &t) { return t.voldown(); }
  56. inline void Remote::onoff(Tv &t) { t.onoff(); }
  57. inline void Remote::chanup(Tv &t) { t.chanup(); }
  58. inline void Remote::chandown(Tv &t) { t.chandown(); }
  59. inline void Remote::set_mode(Tv &t) { t.set_mode(); }
  60. inline void Remote::set_input(Tv &t) { t.set_input(); }
  61. inline void Remote::set_chan(Tv &t, int c) { t.channel = c; }
  63. #endif //PRO1_TVFM_H

tvfm.cpp

  1. #include "tvfm.h"