第3章類和對象

類是面向對象程序設計的核心，它實際上是由用戶定義的一種新的復雜數據類型。類是通過抽象數據類型ADT方法來實現的一種(數據)類型，它是對某一類對象的抽象，而對象是某種類的一個實例，因此類和對象是密切相關的。類是將不同類型的數據和與這些數據相關的操作封裝在一起的集合體。因此，它具有更高的抽象性。實現了信息的隱藏和封裝（Encapsulation）。

我們生活在科學技術飛速發展的現代化社會，需要了解和處理的事情太多、太復雜。為了減少必須了解處理的事情，我們是在某一程度的細節中生活的，也就是說，為了便于達到某種目的，在某種程度上必須要隱藏一些與此目的無關緊要的具體細節。例如在現實生活中人們通常把電視看成一種娛樂和獲取信息的工具來使用，不會考慮它的內部結構和工作原理，即將“制造電視機”和“使用電視機”區別開來?！爸圃祀娨暋毙枰邆潆娨曋圃旒夹g的專門人才來完成。在面向對象的計算機世界中，這種細節程度的數據隱藏就叫抽象。在OOP中也有分工明確的兩種編程。一種是標準類庫的設計，這是由搞面向對象語言系統的軟件專門人員來完成。另一種是面向對象應用程序設計，它是由從事計算機應用的各類專業人員完成?！?.1類的定義1.類的定義格式：類的定義具有如下標準化格式：

class類名

類頭{ private:

數據成員或成員函數的說明

protected:類體

數據成員或成員函數的說明

public:

數據成員或成員函數的說明};<各成員函數的實現(定義部分)>說明：(1)類的定義格式分為說明部分和實現部分。說明部分是用來描述該類中的成員，包括數據成員的說明和成員函數的說明，成員函數是用來對數據成員進行操作的，又稱為“方法”。實現部分是用來定義各種成員函數的，以描述這些成員函數是如何實現對數據成員的操作。總之，說明部分將告訴編程者這個類是“干什么”的，而實現部分是告知“怎么干”的。(2)類的說明部分由類頭和類體兩部分組成，類頭有關鍵字class和類名組成，類名是由編程者啟用的一種標識符，有些軟件開發商如Microsoft公司，用‘C’(Class)開頭的字符串作為類名，也有的用大寫字母‘T’（Type）開頭的字符串作為類名，以便與對象名、函數名區別。開始的字符串作為類名，以便與對象名、函數名區別。類頭是用來向編譯系統聲明定義了一個新的類型，而類體是對類的組織形式進行具體的描述。由訪問限制符（private、protected、public）和數據成員、成員函數組成，整個類體用一對大括號包圍起來，完整地表達對類的描述。教材p347

classDate{//tdate.hpublic://三個公有成員函數。

voidSetDate(inty=2000,

intm=1,intd=1);

int

IsLeapYear(); voidPrintDate();private:

intyear,month,day;//三個私有數據成員。};日期類Date的實現部分為：voidDate::SetDate(inty,intm,

intd){year=y;month=m;day=d; }int

Date::IsLeapYear()//判斷該年是否為閏年。{return(year%4==0&&year%100!=0)||(year%400==0);}voidDate::PrintDate()//顯示年、月、日的具體值。{cout<<year<<","<<month<<","<<day<<endl;}例如，用類定義一個關于日期的抽象數據類型ADT（AbstractDataType）。日期類取類名Date，能設置年、月、日的具體值，并能判斷該年是否為閏年，還能顯示年、月、日的具體值。日期類Date的說明部分為：(3)類由數據和函數組成，稱為類的成員，因此，類有兩種成員：數據成員和成員函數。成員函數又稱為“方法”（mathod）。本例中Date類共有6個成員，其中，三個私有數據成員，三個公有成員函數。(4)通常習慣上將類定義的說明部分或者整個定義部分（包含實現部分）放到一個頭文件中。例如，可將前面定義的類Date放到一個名為tdate.h的頭文件中。在需要引用Date類的源程序的開頭處寫上：#include"tdate.h"則tdate.h的全部內容將嵌入到這條語句的位置上。//p1101.cpp教材p348#include<iostream.h>#include"tdate.h"voidmain(){Datedate1,date2;//定義日期類Date的兩個對象date1和date2。date1.SetDate(2000,5,4);//給對象date1設置年、月、日的具體值。

date2.SetDate(2000,4,9);//給對象date2設置年、月、日的具體值。

intleap=date1.IsLeapYear();//判斷對象date1的年份是否為閏年。

cout<<"LEAP="<<leap<<endl;//輸出判斷結果。

date1.PrintDate();//顯示對象date1年、月、日的具體值。

date2.PrintDate();//顯示對象date2年、月、日的具體值。}

(5)class允許隱藏內部成員。它是依靠類定義中的三個訪問限制符public、private、protected來確定隱藏的程度，它們將類體劃分成三大部分。圖3.1形象地描繪了這三部分的區別。

class

protected:

private:

public:

圖10.1三種訪問限制符的區別

以public:開頭的程序部分稱為公有部分。

以private:開頭的程序部分稱為私有部分。以protected:開頭的程序部分稱為保護部分。

(6)類的定義只是定義了某種類的組織形式，即定義了一個新的class類型，相當于ANSIC中的結構體定義。編譯系統并不給class類型的每個數據成員分配內存空間。

2.訪問限制符public、private、protected它們將類體分為三個部分，每一部分都可以有數據成員和成員函數，也可以只有數據成員或成員函數，但不同的訪問限制符規定了該部分所具有的訪問權限。(1)Public指定的為公有部分是透明的，它的數據成員和成員函數是開放的，既可以由本類的成員函數訪問，也可有程序的其他部分直接訪問。例如允許該類的對象去直接訪問它的公有部分即編寫成“對象名.公有成員名”的形式。(2)Private指定的為私有部分象一個黑盒子，完全是隱藏的，它只能由本類的成員函數訪問，不允許程序其他部分訪問，即在成員函數體內直呼其名地寫出私有成員名，如在日期類Date的SetDate()成員函數體內，可以直接寫:year=y;month=m;day=d;”等語句。但是，不允許程序其他部分直接訪問，例如不允許該類的對象去直接訪問它的私有部分，即不允許編寫成“對象名.私有成員”的形式。例如在main()函數內，用該類的對象去直接訪問私有數據成員，即如下都是非法的：

date1.day=6;date1.month=12;date1.year=1999;

cout<<date1.day;(3)protected指定的保護部分是半透明的，它可由本類成員函數或它的派生類成員函數直接訪問，但也不允許程序其他部分直接訪問它。保護部分主要用于類的繼承，將在后面章節討論。(4)通常總是將數據成員指定為私有的以實現數據隱藏，這些數據成員是用來描述該類對象的屬性，編程者無法直接訪問它們而隱藏起來。而將成員函數指定為公有的，作為該類對象訪問私有數據成員的一個接口界面，即對象訪問私有數據成員的一條消息通路提供給外界使用。因此私有數據只能通過公有成員函數訪問，從而隱藏了處理這些數據的實現細節，使得類對數據的描述和類提供給外部世界來處理數據的界面這兩件事情互相獨立，這就給出了面向對象的重要特性，使得一個類的用戶唯一需要做的事情就是訪問類的界面。正如圖10.2所示：

Date類

public:private:year

SetDate()monthday

IsLeapYear()Protected:

Print()

圖10.2Date類的描述例程10.2(p350)用類定義一個計數器的抽象數據類型ADT(AbstractDataType)。計數器允許取值范圍為0~4294967295的正整數，可進行的操作是計數器加1、減1和讀計數器的值。其類的定義如下：

#include<iostream.h>classCounter{public:Counter()//Counter類的構造函數。 {value=0;//初始化數據成員值。cout<<"Constructorcalled!\n";//輸出顯示調用了本構造函數的信息。}

voidIncrement()//在允許取值范圍內計數器加1。 {if(value<4294967295)value++;} voidDecrement()//當計數器的數據成員值不為0時減1。 {if(value>0)value--;}unsignedReadValue()//讀計數器的值{returnvalue;}~Counter()//Counter類的析構函數。{cout<<"Destructorcalled!\n";}//只輸出調用了本析構函數的信息，其它什么也不做。

private: unsignedvalue;//Counter類的私有數據成員。};

voidmain()//Counter類的測試程序。{

Counterc1,c2;//定義了Counter類的兩個對象c1和c2。

for(inti=1;i<=6;i++){ c1.Increment();//在第1個for語句的循環體內6次向

對象c1發送增量運算的消息。

cout<<"valueofc1="<<c1.ReadValue()<<endl;//每循環一次，顯示對象c1的計數值。

c2.Increment();//同樣6次向對象c2發送增量運算的消

息。

}

cout<<"Afterloop,valueofc2="<<c2.ReadValue()<<endl;//循環完成后，顯示對象c2的計數值。

for(i=1;i<=5;i++) c2.Decrement();//在第2個for語句的循環體內5次向對象c2

發送減量運算的消息。cout<<"Finalvalueofc1="<<c1.ReadValue()<<",valueofc2="<<c2.ReadValue()<<endl;}//顯示對象c1和c2最終的計數值。

該程序的輸出結果：Constructorcalled!Constructorcalled!valueofc1=1valueofc1=2valueofc1=3valueofc1=4valueofc1=5valueofc1=6Afterloop,valueofc2=6Finalvalueofc1=6,valueofc2=1Destructorcalled!Destructorcalled!

3．數據成員：如前所述，類的定義與結構體的定義一樣，僅僅定義了類的組織形式，給出了一個新的class類型，編譯系統并不給類的每個數據成員分配具體的內存空間。數據成員既可以放在公有部分稱為公有數據成員，又可以放在私有或保護部分稱為私有或保護數據成員。它們的定義格式都是：

<類型>數據成員名；(1)數據成員只有<類型>說明，而無<存儲類>說明，所以將類的數據成員說明為auto、register和extern型都是無意義的。

(2)在類體中不允許對所定義的數據成員進行初始化。例如，下面的定義都是錯誤的：classCounter{public:...private: unsignedvalue=0;//error};classDate{public:

...private:

intyear(1999),month(9),day(16);//error};(3)數據成員的類型可以是基本數據類型(char、int、...、double等)和復雜數據類型(數組、指針、引用、...、結構變量等)，或已經定義了的類對象。當另一個類的對象作為這個類的成員時，稱為“對象成員”，這另一個類必須預先定義好。例如：(教材p352，參見p52exg.cpp)classN{public:

...};//不能采用先聲明，后定義的形式?！眂lassN;”classM{public:

...

private:Nn;//n是N類的對象};

4.成員函數(MemberFunction):類體(即緊跟類頭后一對大括號所包圍的程序部分)中不僅定義了該類的對象所具有的數據結構，還定義了對該類對象進行操作的成員函數(方法)，其定義格式如下：

<返回類型>[<類名>::]成員函數名函數頭(類型

參數1,...,類型

參數n){...

...

...}

函數體(1)所有成員函數都必須在類體內用函數原型加以聲明。而成員函數的定義(方法的實現部分)則較靈活，既可在類體外定義，也可在類體內定義。在類體外定義成員函數時，必須用類名加作用域運算符’::’來指明所定義的成員函數屬于哪個類；在類體內定義的成員函數，其函數頭可不寫

[<類名>::]。

(2)在類體內定義成員函數時，編譯系統自動地將成員函數當作內聯函數處理，其函數頭前不必寫關鍵字”inline”。例如Counter類中的Increment()、Decrement()和

ReadValue()都是內聯函數。若是類體外定義的成員函數，必須用關鍵字”inline”指明它為內聯函數。(3)在定義了類的對象后，才可以用如下格式調用(公有)成員函數：對象名.成員函數名(實參表)；例如：

Counterc1,c2;c1.Increment();

c2.Decrement();

(4)成員函數與普通函數一樣，可設置參數的默認值(缺省值Default)。

§11.2對象的定義：定義一個類就相當于創建了一個新的class類型。要使用類，還必須用已經定義的類去說明它的實例變量（對象）。在C++中，class類型一旦被定義，它的實例變量（對象）就能被創建、初始化、并定義指針變量指向它。在程序中，該類名就可以象基本數據類型‘int’；、...、‘double’等一樣使用，用來定義具體的實例變量（對象）。例如：Datedate1,date2,date[31],*pdate;Counterc1,c2,*pc;

1.對象的定義格式：在定義好稱之為“類名”的一個類以后，就可以用如下格式定義它的對象：<存儲類><類名><對象名表>；<對象名表>中可以有一個或多個對象名，若為多個對象名時用逗號分隔開。對象名可以是一般對象名（如上例中Date、Counter為類名，date1、date2為Date類的兩個一般對象名，c1、c2為Counter類的一般對象），也可以是對象數組名（如date[31]是由31個Date類的對象有序排列成date[0]、date[1]、...、date[30]等組成的集合，取對象數組名為date），還可以是指向該類對象的指針名或對該類對象的引用名。例如：Datedate1,&Rdate=date1;Counterc1,&Rc=c1;

2.指向對象的指針（簡稱“對象指針”）：(1)對象指針的定義格式：<存儲類><類名>指針名；例如：Counterc1,c2,*pc;這里所說的<存儲類>是指針變量本身的存儲類型，與ANSIC標準一樣，有extern型、static型、auto型等。而auto的說明經常缺省，extern在定義時不寫，聲明時必須寫。順便指出，例中只定義了一個對象指針pc，但pc并沒有定向，還必須通過初始化或賦值操作將已存在的對象地址賦給它。即pc=&c1;另外，在C++中對象指針可作為另一個類的成員，此時的對象指針是沒有<存儲類>說明的。

(2)只要一個類已經聲明（可以沒有定義），則指向該類的對象指針或該類對象的引用都可作為另一個類的成員。例如：

#include<iostream.h>//p52xg1.cppclassM;classN{private:

intid;public:M*pm;

N(inti){id=i;}

int

GetName(){returnid;}};classM{public:

intvalue;

M(intv){value=v;}M(){value=0;}

int

GetValue(){returnvalue;}};

voidmain(){Mm1(6),m2(8);Nn(4);n.pm=&m2;

cout<<"valueofm1="<<m1.GetValue()<<endl;

cout<<"valuepointedbymemberpmofn="<<n.pm->value<<endl;

cout<<"idofn="<<n.GetName()<<endl;}程序的輸出結果：valueofm1=6valuepointedbymemberpmofn=8idofn=43.訪問類對象成員的方法：如前所述，類有兩種成員，即數據成員和成員函數。每個對象都是類的一個實例，都具有自己的數據成員值，而該類所有對象的數據結構及其訪問權限卻是由它的類統一定義的。因此同一個類所創建的對象，其數據結構都是相同的，類中的成員函數是共享的，而不同對象的數據成員值可以是不相同的。例如，對已經定義的Counter類可用如下語句定義對象和對象指針：

Counterc1,c2,*pc;對象c1、c2都具有各自的value值，但value的數據類型(unsigned)和訪問權限(private)則由Counter類統一定義。由于它是私有數據成員，程序的其他部分不能直接訪問它，必須通過公有部分的成員函數。c1.value;//error不能直接訪問私有數據成員c1.ReadValue();//用公有成員函數訪問私有數據成員

(1)數據成員的訪問方法：如上所述，對于私有數據成員只能通過公有成員函數才能訪問它。而公有數據成員可直接訪問它，其格式為：

對象名.公有數據成員名或

對象指針名->公有數據成員名其中<對象指針名>應與對象屬于相同的class類型，且必須通過初始化或賦值操作將已存在的對象地址賦給它。當然也可以通過成員函數訪問它。Point類的定義寫成如下程序代碼，并把它存放在tpoint.h的頭文件中：

（P358）classPoint{public://四個公有成員函數。

voidSetPoint(inta,intb);//設定點的X、Y坐標值。int

ReadX(){returnx;}//讀取點的X坐標值。int

ReadY(){returny;}//讀取點的Y坐標值。voidMove(int

xOffset,

int

yOffset);//計算點移動后的X、Y坐標值。

intx,y;//兩個公有數據成員x和y。};voidPoint::SetPoint(inta,intb){x=a;y=b;}voidPoint::Move(int

xOffset,

int

yOffset){x+=xOffset;y+=yOffset;}例11.5編寫Point類的測試程序。#include<iostream.h>#include"tpoint.h"voidmain(){Pointp1,p2;//定義Point類的兩個對象p1和p2。Point&ref=p1,*ptr=&p2;//還定義了一個對對象p1的引用ref和指向對象p2的對象指針ptr。 p1.x=3;p1.y=5;

//可用對象名直接訪問公有數據成員，給p1

點設定X、Y坐標值。

p2.SetPoint(8,10);//也可用公有成員函數SetPoint()給p1點設定X、Y坐標值。

p1.Move(2,1);//調用公有成員函數Move()，移動p1點。

p2.Move(1,-2);//調用公有成員函數Move()，移動p2點。

cout<<"x1="<<ref.x<<","<<"y1="<<ref.y<<endl;//使用對象引用ref代替p1直接訪問它的公有數據成員x和y。

cout<<"x2="<<ptr->x<<","<<"y2="<<ptr->y<<endl;//使用對象指針ptr代替p2直接訪問它的公有數據成員x和y。}

該程序的輸出結果：x1=5,y1=6x2=9,y2=8(2)成員函數的訪問方法：訪問成員函數的格式：

對象名.公有成員函數名（參數表）；

或

對象指針名->公有成員函數名（參數表）；

其中<對象指針名>應與對象屬于相同的class類型，且必須通過定向操作指向了已存在的對象。(3)通過引用對象訪問成員的方法。引用對象可用來代替被引用的對象名訪問成員，其格式：

引用對象名.公有數據成員名或

引用對象名.公有成員函數名（參數表）§10.3對象的初始化：構造函數和析構函數是在類體中說明的兩種特殊的成員函數。1.構造函數:C++中“類”只定義了一組對象的類型。要使用這個類還必須用“類”說明它的對象，每個對象中的數據成員還必須賦初值，這些功能都是由構造函數完成的。(1)構造函數是一種特殊的成員函數，其定義格式和其他成員函數相同，只是它以類名作為函數名，例如Counter類的構造函數為Counter()，且不能指定返回類型和顯式的返回值，連void都不能寫，即無返回類型。若某類定義了構造函數，則每當該類的對象創建時，編譯系統為它的對象分配內存空間，并自動調用構造函數初始化所創建的對象，從而確保每個對象自動地初始化。例如：

Counterc1;編譯系統為對象c1的每個數據成員(value)分配內存空間，并調用構造函數Counter()自動地初始化對象c1的value值設置為0。(2)構造函數只完成新對象的初始化工作，不執行對象的主要任務。即在類創建新對象時，為對象分配內存空間，給數據成員賦初值。(3)幾乎每個類都定義了多個構造函數，以適應創建對象時，對象的參數具有不同個數的情況，即構造函數可重載。P360,例10.6#include<iostream.h>classComplex{public:Complex(doublereal,doubleimag);//Constructor(1)，一般構造函數。

Complex(void);//Constructor(2)，無參數構造函數。

Complex(constComplex&c); //Constructor(3)，復制構造函數

Complex(doublereal);//Constructor(4)，類型轉換構造函數。

voidprint(inti);private:doublereal,imag;};//一般構造函數，用兩個實數分別給新創建對象的

兩個數據成員賦初值。

Complex::Complex(doubler,doublei){real=r;imag=i;

cout<<"Constructor(1)called:real="<<real<<",imag="<<imag<<endl;//輸出被調用的提示信息。}//無參數構造函數，創建新對象并將它的數據成員

都設定成0。Complex::Complex(void){real=0.0;imag=0.0;cout<<"Constructor(2)called:real="<<real<<",imag="<<imag<<endl;//輸出被調用的提示信息。}/*復制構造函數，把已存在對象的每個數據成員

都對應賦值給新創建對象的數據成員，即對新

創建對象進行“位模式拷貝”。*/Complex::Complex(constComplex&c){real=c.real;imag=c.imag;

cout<<"Constructor(3)called:real="<<real<<",imag="<<imag<<endl;//輸出被調用的提示信息。}//類型轉換構造函數，把一個實數轉換成虛數部分

為零的復數。Complex::Complex(doubler){real=r;imag=0.0;

cout<<"Constructor(4)called:real="<<real<<",imag="<<imag<<endl;//輸出被調用的提示信息。}//輸出顯示復數類對象的值，形參i用來表示對

象的序號。voidComplex::print(inti){if(imag<0)

cout<<"c"<<i<<"="<<real<<imag<<"i"<<endl;else

cout<<"c"<<i<<"="<<real<<"+"<<imag<<"i"<<endl;}voidmain(){Complexc1,c2(6,8),c3(5.6,7.9),\c4=c2;

c1.print(1);//輸出顯示復數類對象c1。c2.print(2);//輸出顯示復數類對象c2。

c3.print(3);//輸出顯示復數類對象c3。c4.print(4);//輸出顯示復數類對象c4。c1=Complex(1.2,3.4);//直接調用構造函數。

c3=c2;//把復數類對象c2的每個數據成員值賦給c3。

c2=5;//調用類型轉換構造函數，把實數轉換成復數。

c1.print(1);//輸出顯示復數類對象c1。

c2.print(2);//輸出顯示復數類對象c2。c3.print(3);//輸出顯示復數類對象c3。c4.print(4);//輸出顯示復數類對象c4。}

該程序輸出結果:

Constructor(2)called:real=0,imag=0//創建c1，調用無參數構造函數。

Constructor(1)called:real=6,imag=8//創建c2，調用一般構造函數。

Constructor(1)called:real=5.6,imag=7.9//創建c3，調用一般構造函數。

Constructor(3)called:real=6,imag=8//創建c4，調用復制構造函數。c1=0+0i//執行“c1.print(1);”語句。c2=6+8i//執行“c2.print(2);”語句。

c3=5.6+7.9i//執行“c3.print(3);”語句。

c4=6+8i//執行“c4.print(4);”語句。Constructor(1):real=1.2,imag=3.4//執行“c1=Complex(1.2,3.4);”。

Constructor(4)called:real=5,imag=0//執行“c2=5;”。c1=1.2+3.4ic2=5+0ic3=6+8ic4=6+8i(4)通常在程序中不直接調用構造函數，可以在創建對象時顯式地調用構造函數。（p266）例如，

Datetoday=Date(1998,4,9);Counterc1=Counter();將today定義為類Date的對象，并調用構造函數Date(inty,intm,intday);初始化對象today的數據成員year，month，day。其格式為：

類名

對象名=構造函數名（實參表）；

由于“構造函數名”就是“類名”，所以可用更簡單的形式：

類名

對象名（實參表）；此時是在創建對象時，隱式地（自動地）調用構造函數。

2.析構函數：它是構造函數的配對物，與構造函數一樣是與類同名的成員函數，并在函數名前加上一個’~’以便與構造函數相區別。例如：count.cpp中的析構函數~Counter()。

(1)一個類只能有一個析構函數，且析構函數沒有參數和返回值，它實現與構造函數相反的功能。在刪除對象時執行一些清理任務，例如釋放對象所占用的內存空間，有些對象可能還需做其他的事情，如當撤消一個顯示窗口對象時，還需將它們從屏幕上清除掉。(2)對于用new創建的(動態)對象，只有用delete撤消時編譯系統才調用析構函數。

(3)如果編程者沒有給類定義析構函數，那么編譯系統將生成一個什么也不做的缺省析構函數。例如，Complex類的缺省析構函數為：

Complex::~Complex(){}//空函數有人會問為什么要把缺省析構函數設計成什么都不做(對編程者來說)呢？因為只有這樣對于各種存儲類的對象，才能夠按照它本來的創建和撤消管理機制運行。例如，自動對象在程序運行期間，每當遇到它的聲明時就創建它，當離開它的作用域時就自動撤消它。這將在§10.6對象的存儲類中詳細講述。

(4)編譯系統自動調用構造函數的次序和調用析構函數的次序是相反的。為了驗證這一點，給Counter類新增加一個私有數據成員intwho;用來記錄所生成對象的序號，變為：

#include<iostream.h>//countxu.cppclassCounter{public:

Counter(intid) {value=0;who=id;

cout<<"Object"<<who<<"initialized!\n";}

...~Counter() {cout<<"Object"<<who<<"destroyed!\n";}private: unsignedvalue;

intwho;};voidmain(){ Counterc1(1),c2(2);

cout<<“OK!\n”;}其輸出結果為：Object1initialized!Object2initialized!OK!Object2destroyed!Object1destroyed!3.構造函數的種類：構造函數可帶有各種類型的參數，根據參數所具有的類型可將它分為如下四種：(1)無參數的構造函數：當程序中寫有這樣的語句定義新對象時，如：voidmain(){Complexc1;...}則在Complex類中必須定義這樣一個構造函數，Complex::Complex(void){r