《《C++面向?qū)ο蟪绦蛟O計》教案》由會員分享，可在線閱讀，更多相關《《C++面向?qū)ο蟪绦蛟O計》教案（25頁珍藏版）》請在裝配圖網(wǎng)上搜索。

1、第3章類和對象 3.2構造函數(shù)與析構函數(shù) 例：點類Point classPoint { private: intx,y; public: Point(){}; Point(intxx,intyy){x=xx;y=yy;}Point(Point&p){x=p.x;y=p.y;}intGetX()const{returnx;}intGetY()const{returny;}voidSetXY(intxx,intyy){x=xx;y=yy;}voidShow(); }; voidPoint::Show() {cout<<"X:"<

2、 例：人類Person classPerson {protected: char*name; intage; charsex; public: Person(char*n,inta,chars); Person(){name=0;age=0;sex='';}Person(Person&p); ~Person(){delete[]name;}voidSetName(char*n); voidSetAge(inta){age=a;} voidSetSex(ints){sex=s;} char*GetName()const{returnname;} intGetAge()c

3、onst{returnage;} charGetSex()const{returnsex;} voidShow(); }; #include"person.h" #include usingnamespacestd; Person::Person(char*n,inta,chars) {name=newchar[strlen(n)+1]; strcpy(name,n); age=a; sex=s; } Person::Person(Person&p) {name=newchar[strlen(p.name)+1]; strcpy(name,p.

4、name); age=p.age; sex=p.sex; } voidPerson::SetName(char*n) {delete[]name; name=newchar[strlen(n)+1]; strcpy(name,n); } voidPerson::Show() { cout<<"Name:"<

5、來訪問對象成員時，要用“->”操作符。 3、this指針 C+坳成員函數(shù)提供了一個名字為this的指針，這個指針稱為自引用指針。每當通 過一個對象調(diào)用一個成員函數(shù)時，系統(tǒng)就自動把這個this指針指向該對象。因此使用的 數(shù)據(jù)成員就是該對象的數(shù)據(jù)成員。 3.4 向函數(shù)傳遞對象 1 、使用對象作為函數(shù)參數(shù) 2、使用對象指針作為函數(shù)參數(shù) 3、使用對象引用作為函數(shù)參數(shù) 3.5 靜態(tài)成員 1 、靜態(tài)數(shù)據(jù)成員 在一個類中,若將一個數(shù)據(jù)成員說明為static,這種成員稱為靜態(tài)數(shù)據(jù)成員。 與一般的數(shù)據(jù)成員不同,無論建立多少個類的對象,都只有一個靜態(tài)數(shù)據(jù)的拷貝。從而實 現(xiàn)了同一個類的不同

6、對象之間的數(shù)據(jù)共享。 定義靜態(tài)數(shù)據(jù)成員的格式如下: static數(shù)據(jù)類型數(shù)據(jù)成員名; 靜態(tài)數(shù)據(jù)成員在該類定義之外被初始化。訪問靜態(tài)數(shù)據(jù)成員可以通過對象或指針來 訪問，也可以通過類名::來訪問。 2、靜態(tài)成員函數(shù) 定義靜態(tài)成員函數(shù)的格式如下: static返回類型靜態(tài)成員函數(shù)名（參數(shù)表）; 與靜態(tài)數(shù)據(jù)成員類似,調(diào)用公有靜態(tài)成員函數(shù)的一般格式有如下幾種: 類名::靜態(tài)成員函數(shù)名（實參表） 對象.靜態(tài)成員函數(shù)名（實參表） 對象指針->靜態(tài)成員函數(shù)名（實參表） 例：點類Point（演示靜態(tài)成員） classPoint { private: intx,y; static

7、intcount; public: Point(intxx=0,intyy=0){x=xx;y=yy;count++;} Point(Point&p){x=p.x;y=p.y;count++;} intGetX()const{returnx;} intGetY()const{returny;} voidSetXY(intxx,intyy){x=xx;y=yy;} staticintGetCount(){returncount;} }; intPoint::count=0; intmain() { Pointa(100,200),b; cout<

8、); cout<

9、是類Z的友元。 例：點類Point(演示友元) classPoint { private: intx,y; staticintcount; public: Point(intxx=0,intyy=0){x=xx;y=yy;} intGetX()const{returnx;} intGetY()const{returny;} voidSetXY(intxx,intyy){x=xx;y=yy;} frienddoubleDist(Pointp1,Pointp2); }; frienddoubleDist(Pointp1,Pointp2); { doublex,y;

10、 x=p1.x-p2.x; y=p1.y-p2.y; returnsqrt(x*x+y*y); } intmain(){ Pointa(100,200),b(300,400); cout<<"兩點間的距離為："<

11、 Circle(Pointp,doubler):center(p) {SetRadius(r);} doubleGetRadius()const{returnradius;} voidSetRadius(doubler){radius=(r>=0?r:0);} voidSetValue(intx,inty,doubler) {center.SetXY(x,y);SetRadius(r);} doubleArea(); voidShow(); }; constdoublePI=3.14159; inlinedoubleCircle::Area() { returnPI*r

12、adius*radius; } voidCircle::Show() { cout<<"圓心為:" center.Show(); cout<<"半徑為:"<

13、 3、 const數(shù)據(jù)成員 const數(shù)據(jù)成員只能通過構造函數(shù)的初始化列表來獲得初始值。 4、 const成員函數(shù) const成員函數(shù)的說明格式如下:類型說明符函數(shù)名(參數(shù)表)const; 如：intGetYear()const{returnyear;} const成員函數(shù)不能更新對象的數(shù)據(jù)成員，也不能調(diào)用對象的普通成員函數(shù)。 const是函數(shù)類型的一個組成部分,因此在函數(shù)的實現(xiàn)部分也要帶關鍵字 5、引用類型的數(shù)據(jù)成員 引用類型的數(shù)據(jù)成員也只能通過構造函數(shù)的初始化列表來進行初始化。 例 classTest {private: inta; constintb;//不能寫

14、成constintb=10，因類的定義還沒分配空間 int&c;//不能寫成constint&c=a，因變量a還沒分配空間 public: Test(inti,intj,int&k):b(j),c(k) {a=i;} const 對象 const 。 Test():b(10),c(a){a=20;} 第4章派生類與繼承 4.2派生類的構造函數(shù)與析構函數(shù) 例：圓類Circle（繼承Point類的寫法） classCircle:publicPoint {private: double radius; // 半徑 public: Circle(){}

15、 Circle(intx,inty,doubler):Point(x,y) {SetRadius(r);} Circle(Pointp,doubler):Point(p) {SetRadius(r);} doubleGetRadius()const{returnradius;} voidSetRadius(doubler){radius=(r>=0?r:0);} voidSetValue(intx,inty,doubler) {SetXY(x,y);SetRadius(r);} doubleArea(); voidShow(); }; constdoublePI=3.14

16、159; inlinedoubleCircle::Area() {returnPI*radius*radius; } voidCircle::Show() {cout<<"圓心為:" Point::Show(); cout<<"半徑為:"<

17、派生類的構造函數(shù)省略了基類的初始化列表，則將調(diào)用基類的缺省構造函 數(shù)。 5、如果基類定義了帶有參數(shù)的構造函數(shù)時，派生類就應當定義構造函數(shù)，以便顯式 地調(diào)用基類的構造函數(shù)。 6、如果派生類定義了與基類同名的新數(shù)據(jù)成員或成員函數(shù)，則此派生類的成員就覆 蓋了基類的同名成員，直接使用成員名只能訪問到派生類的成員。 7、在同名覆蓋的情況下，可以使用基類名+作用域分辨符來訪問基類的同名成員。 8、如果派生類和基類的某個成員函數(shù)重名，但參數(shù)表不同，仍然屬于覆蓋，不屬于 重載。 9、對派生類的對象，構造函數(shù)的執(zhí)行過程是：先調(diào)用基類的構造函數(shù)(按它們被繼 承時聲明的順序)，再調(diào)用內(nèi)嵌對象成員

18、的構造函數(shù)(按內(nèi)嵌對象聲明的順序)，最后執(zhí) 行自己的構造函數(shù)體中的內(nèi)容。 10、析構函數(shù)的調(diào)用次序正好和構造函數(shù)的調(diào)用次序相反。 例：學生類Student //student.h #include"person.h" classStudent:publicPerson { protected: char*Department; intNumber; public: Student(){Department=0;Number=0;} Student(char*,int,char,char*,int); Student(Student&stu); ~Student()

19、{delete[]Department;} voidSetDep(char*); voidSetNum(intnum){Number=num;} char*GetDep()const{returnDepartment;} intGetNum()const{returnNumber;}voidShow(); }; //student.cpp #include"student.h" #include usingnamespacestd; Student::Student(char*name,intage,charsex,char*dep,intnum):Pe

20、rson(name,age,sex) {Department=newchar[strlen(dep)+1]; strcpy(Department,dep); Number=num; } Student::Student(Student&stu):Person(stu) {Department=newchar[strlen(stu.Department)+1]; strcpy(Department,stu.Department); Number=stu.Number; } voidStudent::SetDep(char*dep) {delete[]Department;

21、 Department=newchar[strlen(dep)+1]; strcpy(Department,dep); } voidStudent::Show() {Person::Show(); cout<<"Department:"<

22、blicY {public: intd; Z(inti,intj,intk):X(i),Y(j){d=k;} } 例2:X和Y都從W派生而來 classW {public: inta; W(intk){d=k;} }; classX:publicW {public: intb; X(inti,intk):W(i){b=k;} }; classY:publicW {public: intc; Y(inti,intk):W(i){c=k;} }; classZ:publicX,publicY {public: intd; Z(inti,intj,in

23、tk,intl):X(i,j),Y(i,k){d=l;} } intmain() {Zt(10,20,30,40); cout<

24、;} }; classZ:publicX,publicY {public: intd; Z(inti,intj,intk,intl):W(i),X(i,j),Y(i,k){d=l;} } intmain() {Zt(10,20,30,40); cout<

25、2) 建立一個對象時,如果這個對象中含有從虛基類繼承來的成員,則虛基類的成員是 由最遠派生類的構造函數(shù)通過調(diào)用虛基類的構造函數(shù)進行初始化的。該派生類的其他基 類對虛基類構造函數(shù)的調(diào)用都自動被忽略。 (3) 若同一層次中同時包含虛基類和非虛基類,應先調(diào)用虛基類的構造函數(shù),再調(diào)用非 虛基類的構造函數(shù),最后調(diào)用派生類構造函數(shù); (4) 對于多個虛基類,構造函數(shù)的執(zhí)行順序仍然是先左后右,自上而下; (5) 對于非虛基類,構造函數(shù)的執(zhí)行順序仍是先左后右,自上而下; (6) 若虛基類由非虛基類派生而來,則仍然先調(diào)用基類構造函數(shù),再調(diào)用派生類的構造 函數(shù)。 4.5賦值兼容規(guī)則 所謂賦值兼

26、容規(guī)則是指在需要基類對象的任何地方都可以使用公有派生類的對象來 替代。 附：線性表——順序表 classSeqList {private: int*data; intsize; intMaxSize; public: SeqList(intsz=100); ~SeqList(){delete[]data;} intLength()const{returnsize;} boolIsEmpty()const{returnsize==0;} voidInsert(constint&x,intk); voidDelete(intk); intGetData(intk)co

27、nst; intFind(constint&x)const; voidShow()const; }; SeqList::SeqList(intsz) {MaxSize=sz; data=newint[MaxSize]; size=0; voidSeqList::Insert(constint&x,intk) {if(k<1||k>size+1){cerr<<"越界出錯";exit(1);} if(size==MaxSize){cerr<<"順序表已滿";exit(1);} for(inti=size-1;i>=k-1;i--)data[i+1]=data[i]; dat

28、a[k-1]=x;size++; } voidSeqList::Delete(intk) {if(size==0){cerr<<"順序表空";exit(1);} if(k<1||k>size){cerr<<"越界出錯";exit(1);} for(inti=k;isize){cerr<<"越界出錯";exit(1);} returndata[k-1]; } intSeqList::Find(constint&x

29、)const {for(inti=0;i usingnamespacestd; classComplex {private: doublere,im; public: Complex(doubler=0,double

30、i=0){re=r;im=i;} doublereal(){returnre;} doubleimag(){returnim;} Complexoperator+(){return*this;} Complexoperator-(){returnComplex(-re,-im);} Complex&operator+=(Complex&); Complex&operator-=(Complex&); Complex&operator*=(Complex&); Complex&operator/=(Complex&); friendComplexoperator+(Comple

31、x&,Complex&); friendComplexoperator-(Complex&,Complex&); friendComplexoperator*(Complex&,Complex&); friendComplexoperator/(Complex&,Complex&); friendbooloperator==(Complex&,Complex&); friendbooloperator!=(Complex&,Complex&); friendostream&operator<<(ostream&,Complex&); friendistream&operator>

32、>(istream&,Complex&); operatordouble(){returnre;} }; //mycomplex.cpp #include"mycomplex.h" #include usingnamespacestd; Complex&Complex::operator+=(Complex&c){re+=c.re; im+=c.im; return*this; } Complex&Complex::operator-=(Complex&c){re-=c.re; im-=c.im;return*this; } Complex&Co

33、mplex::operator*=(Complex&c) {doublet=re*c.re-im*c.im; im=re*c.im+im*c.re; re=t;return*this; } Complex&Complex::operator/=(Complex&c) {doublem=c.re*c.re+c.im*c.im; doublet=(re*c.re+im*c.im)/m; im=(im*c.re-re*c.im)/m; re=t; return*this; } Complexoperator+(Complex&a,Complex&b) {returnComp

34、lex(a.re+b.re,a.im+b.im); } Complexoperator-(Complex&a,Complex&b) {returnComplex(a.re-b.re,a.im-b.im); Complexoperator*(Complex&a,Complex&b) {returnComplex(a.re*b.re-a.im*b.im,a.re*b.im+a.im*b.re); } Complexoperator/(Complex&a,Complex&b) {doublem=b.re*b.re+b.im*b.im; returnComplex((a.re*b.r

35、e+a.im*b.im)/m, (a.im*b.re-a.re*b.im)/m); booloperator==(Complex&a,Complex&b){returna.re==b.re&&a.im==b.im; booloperator!=(Complex&a,Complex&b){returna.re!=b.re||a.im!=b.im; ostream&operator<<(ostream&os,Complex&c) {os<>(istream&is,Complex&

36、c) {is>>c.re>>c.im; returnis; 例：分數(shù)類Fraction #include usingnamespacestd; classFraction { private: intnum,den; voidreduce(); public: Fraction(intn=0,intd=1); Fractionoperator+(){return*this;} Fractionoperator-(){returnFraction(-num,den);} Fraction&operator+=(Fraction&); Fra

37、ction&operator-=(Fraction&); Fraction&operator*=(Fraction&); Fraction&operator/=(Fraction&); Fraction&operator++(); Fractionoperator++(int); operatordouble(); friendFractionoperator+(Fraction&,Fraction&); friendFractionoperator-(Fraction&,Fraction&); friendFractionoperator*(Fraction&,Fractio

38、n&); friendFractionoperator/(Fraction&,Fraction&); friendbooloperator==(Fraction&,Fraction&); friendbooloperator!=(Fraction&,Fraction&); friendbooloperator<(Fraction&,Fraction&); friendbooloperator<=(Fraction&,Fraction&); friendbooloperator>(Fraction&,Fraction&); friendbooloperator>=(Fraction

39、&,Fraction&); friendostream&operator<<(ostream&,Fraction&); friendistream&operator>>(istream&,Fraction&); }; #include"fraction.h" #include usingnamespacestd; Fraction::Fraction(intn,intd) {num=n; den=d; if(den==0)den=1; reduce(); } Fraction&Fraction::operator+=(Fraction&f){ n

40、um=num*f.den+den*f.num; den=den*f.den; reduce(); return*this; } Fraction&Fraction::operator-=(Fraction&f){ num=num*f.den-den*f.num; den=den*f.den; reduce(); return*this; } Fraction&Fraction::operator*=(Fraction&f) {num=num*f.num;den=den*f.den; reduce(); return*this; } Fraction&Fracti

41、on::operator/=(Fraction&f) {num=num*f.den; den=den*f.num; reduce(); return*this; } Fraction&Fraction::operator++() {num+=den; return*this; } FractionFraction::operator++(int) {Fractiontemp=*this; num+=den; returntemp; } Fraction::operatordouble() {returnstatic_cast(num)/den

42、; } Fractionoperator+(Fraction&x,Fraction&y) { returnFraction(x.num*y.den+x.den*y.num,x.den*y.den); } Fractionoperator-(Fraction&x,Fraction&y) { returnFraction(x.num*y.den-x.den*y.num,x.den*y.den); } Fractionoperator*(Fraction&x,Fraction&y) {returnFraction(x.num*y.num,x.den*y.den); } Fr

43、actionoperator/(Fraction&x,Fraction&y) {returnFraction(x.num*y.den,x.den*y.num); } booloperator==(Fraction&x,Fraction&y) {return(x.num*y.den==x.den*y.num); } booloperator!=(Fraction&x,Fraction&y) {return!(x==y); } booloperator<(Fraction&x,Fraction&y) {return(x.num*y.den

44、ooloperator<=(Fraction&x,Fraction&y) {return!(y>x); } booloperator>(Fraction&x,Fraction&y) {return(y=(Fraction&x,Fraction&y) {return!(x>(istream&is,Fraction&f) { char

45、ch; is>>f.num>>ch>>f.den; returnis; } intgcd(intm,intn) { intk; while(n!=0) {k=m%n;m=n;n=k;} returnm; } voidFraction::reduce() { if(den<0){num=-num;den=-den;} if(den==1)return; intsgn=num<0?-1:1; intg=gcd(sgn*num,den); num/=g; den/=g; 例：在人類Person中增加重載賦值運算符 在Person.h中增加一個說明： Pers

46、on&operator=(Person&); 在Person.cpp中增加對該函數(shù)的定義 Person&Person::operator=(Person&p) {if(this==&p)return*this; delete[]name; name=newchar[strlen(p.name)+1]; strcpy(name,p.name); age=p.age; sex=p.sex; return*this;} 5.4 類型轉(zhuǎn)換 1、通過構造函數(shù)將別的類型轉(zhuǎn)換為這個類的類型 如復數(shù)Complex類的構造函數(shù) Complex(doubler){re=r;} 2、通過

47、轉(zhuǎn)換函數(shù)講這個類的類型轉(zhuǎn)換為別的類型 如在復數(shù)Complex類中的轉(zhuǎn)換函數(shù) operatordouble(){returnre;} 在分數(shù)Fraction類中的轉(zhuǎn)換函數(shù) operatordouble(){returnstatic_cast(num)/den;} 用explicit關鍵字，可以禁止單個參數(shù)的構造函數(shù)用于自動類型轉(zhuǎn)換，如 classStack {explicitStack(intsize); } Explicit也同樣禁止用賦值來進行帶有類型轉(zhuǎn)換的初始化行為 如，不可以Stacks=10; 5.5 虛函數(shù) 1 、引入派生類后的對象指針 例：

48、 classA {public: voidshow(){cout<<"A";} }; classB:publicA {public: voidshow(){cout<<"B";} }; intmain() {Aa,*pc; 8 b; pc=&a;pc->show(); pc=&b;pc->show(); } 輸出為AA 2、虛函數(shù)的定義及使用 例：引入虛函數(shù)后，上面的例子改為如下 classA {public: virtualvoidshow(){cout<<"A";} }; classB:publicA {public: voidshow(){

49、cout<<"B";} }; intmain() {Aa,*pc; 9 b; pc=&a;pc->show(); pc=&b;pc->show(); 輸出為AB 3、純虛函數(shù)和抽象類 例： classA {public: virtualvoidshow()=0; }; classB:publicA {public: voidshow(){cout<<"B";} }; intmain() {A*pc; Bb; pc=&b;pc->show(); } 關于虛函數(shù)，有以下幾點 1、如果成員函數(shù)是通過引用或指針，而不是通過對象來調(diào)用，那么，如果沒有使用

50、 virtual，程序?qū)⒏鶕?jù)引用類型或指針類型來選擇方法；如果使用了virtual，程序?qū)⒏? 據(jù)引用或指針指向的對象的類型來選擇方法。 2、如果要在派生類中重新定義基類的方法，則將它設置為虛擬方法，否則是指為非虛擬 方法 3、 如果使用指向?qū)ο蟮囊没蛑羔榿碚{(diào)用虛擬方法，程序?qū)⑹褂脼閷ο箢愋投x的方法， 而不使用為引用類型或指針類型定義的方法，這稱為動態(tài)聯(lián)編或晚期聯(lián)編。 4、 在基類方法的聲明中使用virtual可使該方法在基類以及所有的派生類中都是虛擬的。 5、 一個未在派生類中定義的純虛函數(shù)仍舊還是一個純虛函數(shù)，該派生類仍為一個抽象類。 6、通常應給基類提供一個虛擬析構函數(shù)，這樣，當派生類對象結束時，將先調(diào)用派生的 析構函數(shù)，再調(diào)用基類的析構函數(shù)。 7、如果派生類沒有重新定義虛擬函數(shù)，則將使用該函數(shù)的基類版本。 8、如果重新定義繼承的方法，應確保與原來的原型完全相同。但有一個例外，就是如果 返回類型是基類指針或引用，則可改為指向派生類的指針或引用。 }