《《C++面向?qū)ο蟪绦蛟O(shè)計》教案》由會員分享，可在線閱讀，更多相關(guān)《《C++面向?qū)ο蟪绦蛟O(shè)計》教案（25頁珍藏版）》請在裝配圖網(wǎng)上搜索。
1、第3章類和對象
3.2構(gòu)造函數(shù)與析構(gòu)函數(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的指針，這個指針稱為自引用指針。每當(dāng)通
過一個對象調(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ù)成員只能通過構(gòu)造函數(shù)的初始化列表來獲得初始值。
4、 const成員函數(shù)
const成員函數(shù)的說明格式如下:類型說明符函數(shù)名(參數(shù)表)const;
如：intGetYear()const{returnyear;}
const成員函數(shù)不能更新對象的數(shù)據(jù)成員，也不能調(diào)用對象的普通成員函數(shù)。
const是函數(shù)類型的一個組成部分,因此在函數(shù)的實現(xiàn)部分也要帶關(guān)鍵字
5、引用類型的數(shù)據(jù)成員
引用類型的數(shù)據(jù)成員也只能通過構(gòu)造函數(shù)的初始化列表來進(jìn)行初始化。
例
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派生類的構(gòu)造函數(shù)與析構(gòu)函數(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、派生類的構(gòu)造函數(shù)省略了基類的初始化列表，則將調(diào)用基類的缺省構(gòu)造函
數(shù)。
5、如果基類定義了帶有參數(shù)的構(gòu)造函數(shù)時，派生類就應(yīng)當(dāng)定義構(gòu)造函數(shù)，以便顯式
地調(diào)用基類的構(gòu)造函數(shù)。
6、如果派生類定義了與基類同名的新數(shù)據(jù)成員或成員函數(shù)，則此派生類的成員就覆
蓋了基類的同名成員，直接使用成員名只能訪問到派生類的成員。
7、在同名覆蓋的情況下，可以使用基類名+作用域分辨符來訪問基類的同名成員。
8、如果派生類和基類的某個成員函數(shù)重名，但參數(shù)表不同，仍然屬于覆蓋，不屬于
重載。
9、對派生類的對象，構(gòu)造函數(shù)的執(zhí)行過程是：先調(diào)用基類的構(gòu)造函數(shù)(按它們被繼
承時聲明的順序)，再調(diào)用內(nèi)嵌對象成員
18、的構(gòu)造函數(shù)(按內(nèi)嵌對象聲明的順序)，最后執(zhí)
行自己的構(gòu)造函數(shù)體中的內(nèi)容。
10、析構(gòu)函數(shù)的調(diào)用次序正好和構(gòu)造函數(shù)的調(diào)用次序相反。
例：學(xué)生類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) 建立一個對象時,如果這個對象中含有從虛基類繼承來的成員,則虛基類的成員是
由最遠(yuǎn)派生類的構(gòu)造函數(shù)通過調(diào)用虛基類的構(gòu)造函數(shù)進(jìn)行初始化的。該派生類的其他基
類對虛基類構(gòu)造函數(shù)的調(diào)用都自動被忽略。
(3) 若同一層次中同時包含虛基類和非虛基類,應(yīng)先調(diào)用虛基類的構(gòu)造函數(shù),再調(diào)用非
虛基類的構(gòu)造函數(shù),最后調(diào)用派生類構(gòu)造函數(shù);
(4) 對于多個虛基類,構(gòu)造函數(shù)的執(zhí)行順序仍然是先左后右,自上而下;
(5) 對于非虛基類,構(gòu)造函數(shù)的執(zhí)行順序仍是先左后右,自上而下;
(6) 若虛基類由非虛基類派生而來,則仍然先調(diào)用基類構(gòu)造函數(shù),再調(diào)用派生類的構(gòu)造
函數(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;
例：分?jǐn)?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、通過構(gòu)造函數(shù)將別的類型轉(zhuǎn)換為這個類的類型
如復(fù)數(shù)Complex類的構(gòu)造函數(shù)
Complex(doubler){re=r;}
2、通過
47、轉(zhuǎn)換函數(shù)講這個類的類型轉(zhuǎn)換為別的類型
如在復(fù)數(shù)Complex類中的轉(zhuǎn)換函數(shù)
operatordouble(){returnre;}
在分?jǐn)?shù)Fraction類中的轉(zhuǎn)換函數(shù)
operatordouble(){returnstatic_cast(num)/den;}
用explicit關(guān)鍵字，可以禁止單個參數(shù)的構(gòu)造函數(shù)用于自動類型轉(zhuǎn)換，如
classStack
{explicitStack(intsize);
}
Explicit也同樣禁止用賦值來進(jìn)行帶有類型轉(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();
}
關(guān)于虛函數(shù)，有以下幾點
1、如果成員函數(shù)是通過引用或指針，而不是通過對象來調(diào)用，那么，如果沒有使用
50、
virtual，程序?qū)⒏鶕?jù)引用類型或指針類型來選擇方法；如果使用了virtual，程序?qū)⒏?
據(jù)引用或指針指向的對象的類型來選擇方法。
2、如果要在派生類中重新定義基類的方法，則將它設(shè)置為虛擬方法，否則是指為非虛擬
方法
3、 如果使用指向?qū)ο蟮囊没蛑羔榿碚{(diào)用虛擬方法，程序?qū)⑹褂脼閷ο箢愋投x的方法，
而不使用為引用類型或指針類型定義的方法，這稱為動態(tài)聯(lián)編或晚期聯(lián)編。
4、 在基類方法的聲明中使用virtual可使該方法在基類以及所有的派生類中都是虛擬的。
5、 一個未在派生類中定義的純虛函數(shù)仍舊還是一個純虛函數(shù)，該派生類仍為一個抽象類。
6、通常應(yīng)給基類提供一個虛擬析構(gòu)函數(shù)，這樣，當(dāng)派生類對象結(jié)束時，將先調(diào)用派生的
析構(gòu)函數(shù)，再調(diào)用基類的析構(gòu)函數(shù)。
7、如果派生類沒有重新定義虛擬函數(shù)，則將使用該函數(shù)的基類版本。
8、如果重新定義繼承的方法，應(yīng)確保與原來的原型完全相同。但有一個例外，就是如果
返回類型是基類指針或引用，則可改為指向派生類的指針或引用。
}
《C++面向?qū)ο蟪绦蛟O(shè)計》教案
