標籤:c++ c++編程思想 c語言 習題 原書代碼
一.相關知識
使用其他人已經建立並調試過的類:
關鍵是使用類而不是更改已存在的代碼。這一章將介紹兩種完成這件事的方法。第一種方法是很直接的:簡單地建立一個包含已存在的類對象的新類,這稱為組合,因為這個新類是由已存在類的對象組合的。
第二種方法更巧妙,建立一個新類作為一個已存在類的類型,採取這個已存在類的形式,對它增加代碼,但不修改它。這個有趣的活動被稱為繼承,其中大量的工作由編譯器完成。繼承是物件導向程式設計的基石,並且還有另外的含義,將在下一章中探討。
對於組合和繼承(感覺上,它們都是由已存在的類型產生新類型的方法),它們在文法上和行為上是類似的。這一章中,讀者將學習這些代碼重用機制。
二.相關代碼
1.
<span style="font-size:18px;"><strong>/*USEFUL.cpp*/#ifndef USEFUL_H_#define USEFUL_H_class X{int i;enum{ factor = 11 };public:X(){i = 0;}void set(int I){i = I;}int read() const{return i;}int permute(){return i = i * factor;}};#endif</strong></span>
2.
<span style="font-size:18px;"><strong>/*COMPOSE.h*///在這個類中,數值成員是私人的,所以對於將類型 X 的一個對象作為公用對象嵌入到一個新//類內部,是絕對安全的。#include "useful.h"class Y{int i;public:X x;Y(){i = 0;}void f(int I){i = I;}int g() const{return i;}};int main(){Y y;y.f(47);y.x.set(37);return 0;}</strong></span>
3.
<span style="font-size:18px;"><strong>/*對於新類的public介面函數,包含對內嵌物件的使用,但不必模仿這個內嵌物件的介面。*//*COMPOSE2.h*///這裡,permute()函數的執行調用了X的介面,而X的其他成員函數也在Y的成員函數中被調用。#include "useful.h"class Y{int i;X x;public:Y(){i = 0;}void f(int I){i = I;x.set(I);}int g() const{return i * x.read();}void permute(){x.permute();}};int main(){Y y;y.f(47);y.permute();return 0;}</strong></span>
4.
<span style="font-size:18px;"><strong>/*INHERIT.cpp*/#include "useful.h"#include <iostream.h>class Y : public X{int i;public:Y(){i = 0;}int change()//在change()中,基類permute()函數被調用,衍生類別對所有的public基類函數都有直接的訪問權{i = permute();return i;}void set(int I)//在衍生類別中的set()函數重定義了基類中的set()函數//這就是,如果對於類型 Y 的對象調用函數read()和permute(),得到的是這些函數的基類版本//(可以在main()中看到表現)。但如果對於對象 Y 調用set(),得到的是重定義的版本。這意//味著,如果我們不喜歡在繼承中得到某個函數的基類版本,可以改變它(還能夠增加全新的函//數,例如 change())。{i = I;X::set(I);}};int main(){cout << "sizeof(X) = " << sizeof(X) << endl;cout << "sizeof(Y) = " << sizeof(Y) << endl;Y D;D.change();D.read();D.permute();D.set(12);return 0;}</strong></span>
5.
<span style="font-size:18px;"><strong>/*COMBINED.cpp*/#include <iostream.h>class A{int i;public:A(int I){i = I;}~A(){}void f() const{}};class B{int i;public:B(int I){i = I;}~B(){}void f() const {}};class C : public B{A a;//C 繼承 B 並且有一個成員對象(這是類 A的對象)public:C(int I):B(I), a(I){}//建構函式的初始設定式表中調用了基類建構函式和成員物件建構函數。~C(){}void f() const //函數C::f()重定義了它所繼承的B::f(),並且還調用基類版本,它還調用了a.f(){a.f();B::f();}};int main(){C c(47);}</strong></span>
6.
<span style="font-size:18px;"><strong>/*ORDER.cpp*//*可以看出,構造在類層次的最根處開始,而在每一層,首先調用基類建構函式,然後調用成員物件建構函數。調用解構函式則嚴格按照建構函式相反的次序—這是很重要的,因為要考慮潛在的相關性。*/#include <fstream.h>ofstream out("order.out");#define CLASS(ID) class ID{public: ID(int){ out << #ID " constructor\n";} ~ID(){ out << #ID " destructor\n";}};CLASS(base1);CLASS(member1);CLASS(member2);CLASS(member3);CLASS(member4);class derived1 : public base1{member1 m1;member2 m2;public:derived1(int) : m2(1), m1(2), base1(3){out << "derived1 constructor\n";}~derived1(){out << "derived1 destructor\n";}};class derived2 : public derived1{member3 m3;member4 m4;public:derived2() : m3(1), derived1(2), m4(3){out << "derived2 constructor\n";}~derived2(){out << "derived2 destructor\n";}};int main(){derived2 d2;return 0;}</strong></span>
7.
<span style="font-size:18px;"><strong>/*名字隱藏如果在基類中有一個函數名被重載幾次,在衍生類別中重定義這個函數名會掩蓋所有基類版本,這也就是說,它們在衍生類別中變得不再可用。*//*HIDE.cpp*//*因為 bart 重定義了 d o h ( ),這些基類版本中沒有一個是對於 bart 對象可調用的。這時,編譯器試圖變換參數成為一個 milhouse 對象,並報告出錯,因為它不能找到這樣的變換。*/#include <iostream.h>class homer{public:int doh(int) const{return 1;}char doh(char) const{return 'd';}float doh(float) const{return 1.0;}};class bart : public homer{public:class milhouse{};void doh(milhouse) const {}};int main(){bart b; //!b.doh(1);//!b.doh('x');//!b.doh(1.0);}</strong></span>
8.
<span style="font-size:18px;"><strong>/*由編譯器建立而不是繼承的函數*//*NINHERIT.cpp*/#include <fstream.h>ofstream out("ninherit.out");class root{public:root(){out << "root()\n";}root(root&){out << "root(root&)\n";}root(int){out << "root(int)\n";}root& operator=(const root&){out << "root::operator=()\n";return *this;}class other{};operator other() const//operator other() 完成自動類型變換,從 root 對象到被嵌入的類 other 的對象{out << "root::operator other()\n";return other();}~root(){out << "~root()\n";}};class derived : public root {};//類 derived 直接從root 繼承,並沒有建立函數(觀察編譯器如何反應)//在 derived 中, operator=( ) 也被綜合為新函數,使用成員函數賦值,因為這個函數在新類中不顯式地寫出void f(root::other){}//函數 f() 取一個 other 對象以測試這個自動類型變換函數int main(){derived d1;derived d2 = d1;//!derived d3(1);d1 = d2;f(d1);return 0;}</strong></span>
9.
<span style="font-size:18px;"><strong>/*組合通常在希望新類內部有已存在類效能時使用,而不希望已存在類作為它的介面。這就是說,嵌入一個計劃用於實現新類效能的對象,而新類的使用者看到的是新定義的介面而不是來自老類的介面。為此,在新類的內部嵌入已存在類的 private 對象。有時,允許類使用者直接存取新類的組合是有意義的,這就讓成員對象是 public。成員函數隱藏它們自己的實現,所以,當使用者知道我們正在裝配一組零件並且使得介面對他們來說更容易理解時,這樣會安全的*//*CAR.cpp*///稍加思考就會看到,用車輛對象組合小汽車是無意義的—小汽車不能包含車輛,它本身//就是一種車輛。這種is-a關係用繼承表達,而 has-a 關係用組合表達。#include <iostream.h>class engine{public:void start() const {}void rev() const {}void stop() const {}};class wheel{public:void inflate(int psi) const {}};class window{public: void rollup() const {}void rolldown() const {}};class door{public:window Window;void open() const {}void close() const {}};class car{public:engine Engine;wheel Wheel[4];door left, right;};int main(){car Car;Car.left.Window.rollup();Car.Wheel[0].inflate(72);return 0;}</strong></span>
10.
<span style="font-size:18px;"><strong>/*子類型設定*//*FNAME1.cpp*/#include <fstream.h>#include <strstrea.h>#include "E:\VC++\7_31_2\allege.h"class fname1{ifstream File;enum{ bsize = 100 };char buf[bsize];ostrstream Name;int nameset;public:fname1() : Name(buf, bsize), nameset(0) {}fname1(const char* filename) : File(filename), Name(buf, bsize){allegefile(File);Name << filename << ends;nameset = 1;}const char* name() const{return buf;}void name(const char* newname){if(nameset){return;}Name << newname << ends;nameset = 1;}operator ifstream&() {return File;}};int main(){fname1 file("fname1.cpp");cout << file.name() << endl;//Error:rdbuf() not a member//!cout << file.rdbuf() << endl;//因為自動類型轉換隻發生在函數調用中,而不在成員選擇期間return 0;}</strong></span>
11.
<span style="font-size:18px;"><strong>/*子類型設定*//*FNAME2.cpp*/#include <fstream.h>#include <strstrea.h>#include "E:\VC++\7_31_2\allege.h"class fname2 : public ifstream{enum{ bsize = 100 };char buf[bsize];ostrstream Name;int nameset;public:fname2() : Name(buf, bsize), nameset(0) {}fname2(const char* filename) : ifstream(filename), Name(buf, bsize){Name << filename << ends;nameset = 1;}const char* name() const{return buf;}void name(const char* newname){if(nameset){return;}Name << newname << ends;nameset = 1;}};int main(){fname2 file("fname2.cpp");allegefile(file);cout << "name: " << file.name() << endl;const bsize = 100;char buf[bsize];file.getline(buf, bsize);file.seekg(-200, ios::end);cout << file.rdbuf() << endl;return 0;}</strong></span>
12.
<span style="font-size:18px;"><strong>/*繼承也就是取一個已存在的類,並製作它的一個專門的版本*//*INHSTAK.cpp*/#include "E:\VC++\8_4_3\stackl1.h"#include "E:\VC++\8_4_1\strings.h"#include <fstream.h>#include "E:\VC++\7_31_2\allege.h"class Stringlist : public stack{public:void push(String* str){stack::push(str);}String* peek() const{return (String*)stack::peek();}String* pop(){return (String*)stack::pop();}};int main(){ifstream file("text.cpp");allegefile(file);const bufsize = 100;char buf[bufsize];Stringlist textlines;while(file.getline(buf, bufsize)){textlines.push(String::make(buf));}String* s;while((s = textlines.pop()) != 0){cout << *s << endl;}return 0;}</strong></span>
13.
<span style="font-size:18px;"><strong>/*對私人繼承成員公有化當私人繼承時,基類的所有 public成員都變成了 private。如果希望它們中的任何一個是可視的,只要用衍生類別的public選項聲明它們的名字即可。*//*PRIVING.cpp*/#include <iostream.h>class base1{public:char f() const{return 'a';}int g() const{return 2;}float h() const{return 3.0;}};class derived : base1{public:base1::f;base1::h;};int main(){derived d;d.f();d.h();//!d.g();return 0;}</strong></span>
14.
<span style="font-size:18px;"><strong>/*資料成員最好是private,因為我們應該保留改變內部實現的權利。然後我們才能通過保護成員函數控制對該類的繼承者的訪問。*//*PROTECT.cpp*//*被保護的繼承繼承時,基類預設為 private,這意味著所有 public成員函數對於新類的使用者是 private的。通常我們都會讓繼承 public,從而使得基類的介面也是衍生類別的介面。然而在繼承期間,也可以使用protected關鍵字。被保護的派生意味著對其他類來“照此實現”,但對衍生類別和友元是“is-a”。它是不常用的,它的存在只是為了語言的完整性。*/#include <fstream.h>class base{int i;protected:int read() const{return i;}void set(int I){i = I;}public:base(int I = 0) : i(I) {}int value(int m) const{return m * i;}};class derived : public base{int j;public: derived(int J = 0) : j(J) {}void change(int x){set(x);}};int main(){return 0;}</strong></span>
15.
<span style="font-size:18px;"><strong>/*向上映射*//*WIND.cpp*//*在tune()中,這些代碼對instrument和從instrument派生來的任何類型都有效,這種將 wind的對象、引用或指標轉變成instrument對象、引用或指標的活動稱為向上映射。*/#include <iostream.h>enum note { middleC, Csharp, Cflat };class instrument{public:void play(note) const {}};class wind : public instrument {};void tune(instrument& i){i.play(middleC);}int main(){wind flute;tune(flute);//wind w;//instrument* ip = &w;//instrument& ir = w;//編譯器只能把ip作為一個instrument指標處理。這就是說,它不知道 ip實際上指向wind的對象。 //所以,當調用play()成員函數時,如果使用 //ip->play(middleC) ; //編譯器只知道它正在對於一個instrument指標調用play(),並調用instrument∷play()的基本版本, //而不是它應該做的調用wind∷play()。這樣將會得到不正確的結果。return 0;}</strong></span>
16.
<span style="font-size:18px;"><strong>/*stringlist對象僅作為string包容器,不需向上映射,所以更合適的方法可能是組合*//*INHSTAK2.cpp*/#include "E:\VC++\8_4_3\stackl1.h"#include "E:\VC++\8_4_1\strings.h"#include <fstream.h>#include "E:\VC++\7_31_2\allege.h"class Stringlist{stack Stack;public:void push(String* str){Stack.push(str);}String* peek() const{return (String*)Stack.peek();}String* pop(){return (String*)Stack.pop();}};int main(){ifstream file("text.cpp");allegefile(file);const bufsize = 100;char buf[bufsize];Stringlist textlines;while(file.getline(buf, bufsize)){textlines.push(String::make(buf));}String* s;while((s = textlines.pop()) != 0){cout << *s << endl;}return 0;}</strong></span>
三.習題+解答
1. 修改CAR.CPP,使得它也從被稱為 vehicle的類繼承,在 vehicle中放置合適的成員函數(也就是說,補充一些成員函數)。對vehicle增加一個非預設的建構函式,在car的建構函式內部必須調用它。
#include <iostream.h>class engine{public:void start() const {}void rev() const {}void stop() const {}};class wheel{public:void inflate(int psi) const {}};class window{public: void rollup() const {}void rolldown() const {}};class door{public:window Window;void open() const {}void close() const {}};class vehicle{public:vehicle(){}void g(){}void f(){}};class car : vehicle{public:engine Engine;wheel Wheel[4];door left, right;car(){vehicle();}};int main(){car Car;Car.left.Window.rollup();Car.Wheel[0].inflate(72);return 0;}
2. 建立兩個類, A和B,帶有能宣布自己的預設建構函式。從 A繼承出一個新類,稱為 C,並且在C中建立B的一個成員對象,而不對C建立建構函式。建立類C 的一個對象,觀察結果。
#include <iostream.h>class A{int i;public:A(int I = 0){i = I;cout << "A::A(int I)" << endl;}};class B{int j;public:B(int J = 0){j = J;cout << "B::B(int J)" << endl;}};class C : public A{public:B b;};int main(){C c;return 0;
調用結果:
3. 使用繼承,專門化在第 1 2章( PSTASH.H & PSTASH. CPP)中的pstash類,使得它接受和返回String針。修改PSTEST. CPP並測試它。改變這個類使得pstash是一個成員對象。
/*PSTASH.h*/#include "E:\VC++\8_4_1\strings.h"#ifndef PSTASH_H_#define PSTASH_H_class pstash{int quantity;int next;void** storage;//storage是一個 void指標數組void inflate(int increase);public:pstash(){quantity = 0;storage = 0;next = 0;}~pstash(){delete storage;}int add(void* element);void* operator[](int index) const;int count() const{return next;}};class Stringlist : public pstash{public:int add(String* element){return pstash::add(element);}String* operator[](int index) const{return (String*)pstash::operator[](index);}int count() const{return pstash::count();}};#endif
/*PSTASH.cpp*/#include "pstash.h"#include <iostream.h>#include <string.h>int pstash::add(void* element){const InflateSize = 10;if(next >= quantity){inflate(InflateSize);}storage[next+1] = element;return (next-1);//index number}void* pstash::operator[](int index) const{if(index >= next || index < 0){return 0;}return storage[index];}void pstash::inflate(int increase){const psz = sizeof(void*);void** st = new void*[quantity + increase];memset(st, 0, (quantity + increase) * psz);memcpy(st, storage, quantity * psz);quantity += increase;delete storage;storage = st;}
/*PSTEST.cpp*/#include "pstash.h"#include <fstream.h>#include "E:\VC++\7_31_2\allege.h"int main(){ifstream file("pstest.cpp");allegefile(file);const bufsize = 80;char buf[bufsize];Stringlist textlines;while(file.getline(buf, bufsize)){textlines.add(String::make(buf));}return 0;}
4. 使用private和protected繼承從基類建立兩個新類。然後嘗試向上映射這個衍生類別的對象成為基類。解釋所發生的事情。
#include <iostream.h>enum note { middleC, Csharp, Cflat };class A{public:void play(note) const {}};class B : private A {};class C : protected A {};void tune(A& i){i.play(middleC);}int main(){B flute1;//!tune(flute1);//error C2243: 'type cast' : conversion from 'class B *' to 'class A &' exists, but is inaccessibleC flute2;//!tune(flute2);//error C2243: 'type cast' : conversion from 'class C *' to 'class A &' exists, but is inaccessiblereturn 0;}
以上代碼僅供參考,如有錯誤請大家指出,謝謝大家~
著作權聲明:本文為博主原創文章,未經博主允許不得轉載。
《C++編程思想》 第十三章 繼承和組合 (原書代碼+習題+解答)