第15章 友元、异常和其他

1.友元类

      友元类的所有方法都可以访问原始类的私有成员和保护成员。友元声明可以位于公有、私有或保护部分，其所在的位置无关紧要。下面的例子是一个电视机Tv类和它的友元类Remote类。由于后者提到了前者，所以编译器必须了解Tv类后，才能处理Remote类，为此，最简单的方法是首先定义Tv类。另一种方法是，可以使用前向声明(forward declaration)，这将在后面介绍。

// tv.h -- Tv and Remote classes #ifndef TV_H_ #define TV_H_ class Tv { public: friend class Remote; // Remote can access Tv private parts enum {Off, On}; enum {MinVal,MaxVal = 20}; enum {Antenna, Cable}; enum {TV, VCR}; Tv(int s = Off, int mc = 100) : state(s), volume(5), maxchannel(mc), channel(2), mode(Cable), input(TV) {} void onoff() {state = (state == On)? Off : On;} bool ison() const {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)? VCR : TV;} void settings() const; // display all settings private: int state; // on or off int volume; // assumed to be digitized int maxchannel; // maximum number of channels int channel; // current channel setting int mode; // broadcast or cable int input; // TV or VCR }; class Remote { private: int mode; // controls TV or VCR public: Remote(int m = Tv::TV) : mode(m) {} bool volup(Tv & t) { return t.volup();} bool voldown(Tv & t) { return t.voldown();} void onoff(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

// tv.cpp -- methods for the Tv class (Remote methods are inline) #include <iostream> #include "tv.h" bool Tv::volup() { if (volume < MaxVal) { volume++; return true; } else return false; } bool Tv::voldown() { if (volume > MinVal) { volume--; return true; } else return false; } void Tv::chanup() { if (channel < maxchannel) channel++; else channel = 1; } void Tv::chandown() { if (channel > 1) channel--; else channel = maxchannel; } void Tv::settings() const { using std::cout; using std::endl; cout << "TV is " << (state == Off? "Off" : "On") << endl; if (state == On) { cout << "Volume setting = " << volume << endl; cout << "Channel setting = " << channel << endl; cout << "Mode = " << (mode == Antenna? "antenna" : "cable") << endl; cout << "Input = " << (input == TV? "TV" : "VCR") << endl; } }

//use_tv.cpp -- using the Tv and Remote classes #include <iostream> #include "tv.h" int main() { using std::cout; Tv s27; cout << "Initial settings for 27/" TV:/n"; s27.settings(); s27.onoff(); s27.chanup(); cout << "/nAdjusted settings for 27/" TV:/n"; s27.settings(); Remote grey; grey.set_chan(s27, 10); grey.volup(s27); grey.volup(s27); cout << "/n27/" settings after using remote:/n"; s27.settings(); Tv s32(Tv::On); s32.set_mode(); grey.set_chan(s32,28); cout << "/n32/" settings:/n"; s32.settings(); return 0; }

2.友元成员函数

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091023/1.jpg

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091026/2.jpg

// tvfm.h -- Tv and Remote classes using a friend member #ifndef TVFM_H_ #define TVFM_H_ class Tv; // forward declaration class Remote { public: enum State{Off, On}; enum {MinVal,MaxVal = 20}; enum {Antenna, Cable}; enum {TV, VCR}; private: int mode; public: Remote(int m = TV) : mode(m) {} bool volup(Tv & t); // prototype only bool voldown(Tv & t); void onoff(Tv & t) ; void chanup(Tv & t) ; void chandown(Tv & t) ; void set_mode(Tv & t) ; void set_input(Tv & t); void set_chan(Tv & t, int c); }; class Tv { public: friend void Remote::set_chan(Tv & t, int c); enum State{Off, On}; enum {MinVal,MaxVal = 20}; enum {Antenna, Cable}; enum {TV, VCR}; Tv(int s = Off, int mc = 100) : state(s), volume(5), maxchannel(mc), channel(2), mode(Cable), input(TV) {} void onoff() {state = (state == On)? Off : On;} bool ison() const {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)? VCR : TV;} void settings() const; private: int state; int volume; int maxchannel; int channel; int mode; int input; }; // Remote methods as inline functions inline bool Remote::volup(Tv & t) { return t.volup();} inline bool Remote::voldown(Tv & t) { return t.voldown();} inline void Remote::onoff(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

3.互为友元类

 https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091026/3.jpg

4.函数同时为两个类的友元

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091026/4.jpg

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091026/5.jpg

5.嵌套类

      嵌套类的作用域：

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091026/6.jpg

      模板中的嵌套例子：

// queuetp.h -- queue template with a nested class #ifndef QUEUETP_H_ #define QUEUETP_H_ template <class Item> class QueueTP { private: enum {Q_SIZE = 10}; // Node is a nested class definition class Node { public: Item item; Node * next; Node(const Item & i):item(i), next(0){ } }; Node * front; // pointer to front of Queue Node * rear; // pointer to rear of Queue int items; // current number of items in Queue const int qsize; // maximum number of items in Queue 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); // add item to end bool dequeue(Item &item); // remove item from front }; // QueueTP methods 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) // while queue is not yet empty { temp = front; // save address of front item front = front->next;// reset pointer to next item delete temp; // delete former front } } // Add item to queue template <class Item> bool QueueTP<Item>::enqueue(const Item & item) { if (isfull()) return false; Node * add = new Node(item); // create node if (add == NULL) return false; // quit if none available items++; if (front == 0) // if queue is empty, front = add; // place item at front else rear->next = add; // else place at rear rear = add; // have rear point to new node return true; } // Place front item into item variable and remove from queue template <class Item> bool QueueTP<Item>::dequeue(Item & item) { if (front == 0) return false; item = front->item; // set item to first item in queue items--; Node * temp = front; // save location of first item front = front->next; // reset front to next item delete temp; // delete former first item if (items == 0) rear = 0; return true; } #endif

// nested.cpp -- using a queue that has a nested class #include <iostream> #include <string> #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; }

6.类型转换操作符

dynamic_cast 操作符：dynamic_cast<type-name>(expression)

     如果指向的对象(*pt)的类型为Type或者是从Type直接或间接派生而来的类型，则表达式dynamic_cast<Type *>(pt)将指针pt转换为Type类型的指针；否则，结果为0，即空指针。该操作符的用途是，使得能够在类层次结构中进行向上转换，而不允许其他转换。

 

const_cast操作符： const_cast<type-name>(expression)

用于执行只有一种用途的类型转换，即改变值为const或volatile。也就是说，除了const或volatile特征（有或无）可以不同外，type-name和expression的类型必须相同。如果Low是High的可访问基类：

High bar; const High *pbar = &bar; … High * pb = const_cast<High *> (pbar); // valid const Low * pl= const_cast<const Low *> (pbar); // invalid

提供该操作符的原因是，有时候可能需要这样一个值，它在大多数时候是常量，而有时又是可以修改的。这样，可以将这个值声明为const，在需要修改它的时候，使用const_cast，这也可以通过通用类型转换来实现，但用const_cast更安全。const_cast不是万能的，它可以修改指向一个值的指针，但修改const值的结果是不确定的。333

 

static_cast操作符：static_cast<type-name>(expression)

 https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091026/7.jpg

 

reinterpret_cast操作符： reinterpret_cast<type-name>(expression)

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091026/8.jpg