知識點

一、C++入門與基本資料型別

1.C++中，一個函式必須在函式宣告後才能使用（被呼叫）。

2.C++函式宣告總是由函式原型構成。

3.引數宣告時，要指出其型別。

4.函式定義中的引數稱為形式引數，簡稱形參。

5.呼叫函式時實際傳遞的值稱為實際引數，簡稱實參。

6.在大多數計算機上，short int 表示2個位元組長。short 只能修飾int，short int 可以省略為short。

7.long 只能修飾 int 和 double 。修飾為 long int（可以省略為long）時，一般表示4個位元組，修飾 long double 時，一般表示10個位元組。

8.unsigned 和 signed 只能修飾 char 和 int。一般情況下，預設的 char 和 int 為signed。實型數 float 和 double 總是有符號的，不能用 unsigned 修飾。

9.用 typeof(資料型別) 可以確定某資料型別的位元組長度。

10.命名變數名的規則：
（1）不能是C++關鍵字。
（2）第一個字元必須是字母或下劃線。
（3）不要超過31個字元。
（4）中間不能有空格。
（5）不能包含“ . ; , " ’ + - ” 之類的特殊符號。變數名中除了能使用26個英文大小寫字母和數字外，只能使用下劃線“ _ ”。
（6）變數名不要與C++中的庫函式名、類名和物件名相同。

11.八進位制以0開頭，十六進位制以0x開頭。

12.十進位制數有正負之分，八進位制和十六進位制數只能表示無符號整數。

13.指數形式：E或e的前面必須要有數字，且E後面的指數必須為整數。

14.字元是用單引號括起來的一個字元。’ \ddd ’ 表示1 ~ 3位八進位制數， ’ \xhh ’ 表示1 ~ 2位十六進位制數。
例："\x07operating\tsystem\n" 中有18個字元。

15.C++中，字串總是以’\0’結束。

16.“0” 與 ‘0’ 是不同的。

17.printf("%-5.3s",“Hello”);負號表示左對齊，5表示格式寬度，3表示擷取字串中3個字元。

二、表示式和語法

1.操作符優先順序：算術運算子>關係運算子>邏輯運算子>賦值運算子

2./ 對於整型數是取整，對於浮點數是通常意義的除法。

3.% 只能對整型數進行操作，意義為取餘。

4.算術型別轉換總是朝表達資料能力更強的方向，並且轉換總是逐個運算子進行的。

5.資料運算過程中自動進行的型別轉換稱為隱式型別轉換。

6.強制轉換又稱顯示轉換，其語法是在一個數值或變數前加上帶括號的型別名。也可以型別名後跟帶括號的數值或表示式。如果型別名是帶型別修飾的，則要給型別名加括號。

7.條件運算子（條件表示式）？（條件為真時的表示式）：（條件為假時的表示式）。條件運算子可以巢狀。

8.if ( !n ) 等價於 if ( n == 0 )和if ( n ) 等價於 if ( n != 0 )

9.do-while迴圈中，while（繼續條件）後面的分號不要忘記。

10.for語句的三個表示式都可省略，且表示式1，2，3都可以為任何表示式。

11.switch後面括號中的表示式只能是整型、字元型或列舉型別表示式。case後面的常量表示式型別必須與其匹配。

12.因為case語句起語句標號的作用，所以case與default並不改變控制流程。case常與break語句聯用，以保證多路分支的正確實現。最後一個分支可以省略break語句。
各個case（包括default）的出現次序可以任意。在每個case分支都帶有break的情況下，case次序不影響執行結果。

13.default語句是可選的。當default不出現時，則當表示式的值與所有常量表示式的值都不相等時，越過switch語句。

14.switch語句可以巢狀。

15.continue語句和break語句的區別是：continue語句只結束本次迴圈，而不是終止整個迴圈的執行；而break語句則是終止整個迴圈，不再進行條件判斷。

三、函式

1.C++不允許函式定義巢狀，即在函式定義中再定義一個函式是非法。

2.一個程式將作業系統分配給其執行的記憶體塊分為4個區域：程式碼區、全域性資料區、堆區、棧區。

3.函式結束時，靜態區域性變數不會消失，每次該函式呼叫時，也不會為其重新分配空間。它始終駐留在全域性資料區，直到程式執行結束。靜態區域性變數的初始化與全域性變數類似，如果不為其顯式初始化，則C++自動為其初始化為0。

4.行內函數也稱內嵌函式，主要解決程式的執行效率。

5.過載函式至少在引數個數、引數型別或引數順序上有所不同。

6.typedef定義的型別只能使之相同於一個已存在的型別，而不能建立新的型別，所以不能用typedef定義的型別名來區分過載函式宣告中的引數。

7.預設引數在函式宣告中提供，當又有宣告又有定義時，定義中不允許預設引數。如果函式只有定義，則預設引數才可出現在函式定義中。

8.預設值可以是全域性變數、全域性常量，甚至是一個函式。但預設值不可以是區域性變數，因為預設引數的函式呼叫是在編譯時確定的，而區域性變數的位置與值在編譯時均無法確定。

9.行內函數是為了提高程式設計效率而實現的，它克服了用#define巨集定義說帶來的弊病。

10.goto和switch語句不應使控制從一個宣告的作用域跳到該宣告的作用域內，因為這種跳轉越過了變數的宣告語句，使變數不能被初始化。

11.全域性變數、靜態全域性變數、靜態區域性變數都具有靜態生命期。具有檔案作用域的變數具有靜態生命期。靜態生命期的變數，若無顯示初始化，則自動初始化為0。

12.在函式內部宣告的變數或是塊中宣告的變數具有區域性生命期。具有區域性作用域的變數若為區域性變數，則具有區域性生命期，若為靜態區域性變數，則有靜態生命期。具有區域性生命期的變數駐在記憶體的棧區。具有區域性生命期的變數若未初始化，則內容不可知。

14.三類編譯預處理指令：#include，#define，#if。
#include包含指令：讓前處理器把一個原始檔嵌入到當前檔案中該點處。
#define巨集定義指令：建立常量，定義帶引數的巨集，還有一個有效的使用是在條件編譯指令中。

15.條件編譯指令有：#if，#else，#elif，#endif，#ifdef，#ifndef，#undef。
條件編譯的一個有效使用時協調多個標頭檔案。使用#undef可以取消符號定義，這樣可以根據需要開啟和關閉符號。

四、陣列與指標

1.初始化陣列的值的個數不能多於陣列元素個數，初始化陣列的值也不能通過跳過逗號的方式來省略。

2.初始化值的個數可少於陣列元素個數。當初始化值的個數少於陣列元素個數時，前面的按序初始化相應值，後面的初始化為0。

3.對於字串的初始化，要注意陣列實際分配的空間大小事字串個數加上末尾的’\0’結束符。

4.陣列的大小為n，而字串的長度為n-1。

5.在定義時，也可以只對部分元素賦初始值而省略第一維的大小，但應分行賦初始值。
函式呼叫時，陣列引數的實參為整型變數的地址；函式原型中，陣列引數的形參為整型陣列的首地址。

6.有一種從陣列尾部跳到其頭部的技巧是“加1求模”。

7.用&操作可以獲取變數的地址，指標變數用於存放地址。

8.放在可執行語句中的指標之前，稱為間接引用操作符，而其放在指標定義中時，稱指標定義符。

9.非指標變數是不能用間接引用操作符的，因為只能作用於地址。
間接引用既可以用於右值，也可以用於左值。
指標變數初始化的值是該指標型別的地址值。
指標在使用前，要進行初始化。指標忘賦值比整形變數忘了賦值要危險的多。
指標iPtr++不是後移一位，而是後移了一個單位。
只有加法和減法可用於指標運算。

10.a[i] 等價於 * (a+i) 等價於 iPtr[i] 等價於 * (iPtr+i)
&a[i] 等價於 a+i 等價於 iPtr+i 等價於 &iPtr[i]

11.陣列名本身是一指標，它的型別是指向陣列元素的指標。

12.陣列名是指標常量，區別於指標變數。所以給陣列名賦值是錯誤的。

13.常量指標（指向常量的指標）：在指標定義語句的型別前加const，表示指向的物件是常量。定義指向常量的指標只限制指標的間接訪問操作，而不能規定指標指向的值本身的操作規定性。const int * pi = &a；不能通過*pi來修改a的值，但可以把pi指向另外一個變數。

14.指標常量：在指標定義語句的指標名前加const，表示指標本身是常量。在定義指標常量時必須初始化。char * const pc = “asdf”；可以通過 * pc來修改其內容，但不能改變指標值即指向另外一個變數。

15.常量指標常量（指向常量的指標常量）：const int * const cpc = &b；其中cpc和 * cpc都是常量，不能作為左值進行操作。*

16.指標陣列：一個陣列中每個元素都是一個指標。char * proname[] = { “Fortran”, “C”, “C++” }；

17.指標陣列與二維陣列是有區別的。字元指標陣列的記憶體表示，指標所指向的字串是不規則長度的。二維陣列每一列的大小必須是一樣的。
指標陣列名是指向指標的指標（即二級指標）。

18.傳遞陣列給函式就是傳遞指標給函式。傳遞指標陣列給函式就是傳遞二級指標給函式。

五、類、建構函式、靜態成員與友元

1.C++特點：抽象、封裝、繼承、多型。

2.::叫作用域區分符，指明一個函式屬於哪個類或一個資料屬於哪個類。::可以不跟類名，表示全域性資料或全域性函式（即非成員函式）。

3.不能對類的資料成員進行初始化。

4.由於類名是成員函式名的一部分，所以一個類的成員函式與另一個類的成員函式即使同名，也不能認為是過載。

5.成員函式必須用物件來呼叫。

6.一個類物件所佔據的記憶體空間由它的資料成員所佔據的空間總和說決定。類的成員函式不佔據物件的記憶體空間。

7.類的作用域是指類定義和相應的成員函式定義範圍。

8.如果一個非型別名隱藏了型別名，則型別名通過加字首可用。如果一個型別名隱藏了一個非型別名，則用一般作用域規則即可。

9.C++規定，一個名字不能同時指兩種型別。非型別名（變數名、常量名、函式名、物件名或列舉成員）不能重名。

10.C++規定與類同名的成員函式是建構函式，在該類的物件建立時，自動被呼叫。

11.建構函式沒有返回型別，函式體中也不允許返回值，但可以有無值返回語句“return；”。

12.一個類定義中，類的資料成員可能為另一個類的物件。

13.如果一個類物件是另一個類的資料成員，則在那個類的建立所呼叫的建構函式中，對該成員（物件）自動呼叫其建構函式。

14.解構函式沒有返回型別，沒有引數，沒有過載。只是在類物件生命期結束的時候，由系統自動呼叫。

15.解構函式以呼叫建構函式相反的順序被呼叫。

16.無參的建構函式被稱為預設建構函式。

17.C++規定，每個類必須有一個建構函式，沒有建構函式，就不能建立任何物件。

18.若未提供一個類的建構函式（一個都未提供），則C++提供一個預設的建構函式，該預設建構函式是個無參建構函式，它負責建立物件，而不做任何初始化工作。

19.只要一個類定義了一個建構函式（不一定是無參建構函式），C++就不再提供預設的建構函式。即如果為類定義了一個帶引數的建構函式，還想要無參建構函式，則需要自己定義。

20.靜態物件和靜態變數一樣，檔案作用域的靜態物件在主函式開始執行前全部構造完畢。塊作用域中的靜態物件，則在首次進入到定義該靜態物件的函式時，進行構造。

21.全域性變數、靜態資料、常量存放在全域性資料區，所有類成員函式和非成員函式程式碼存放在程式碼區，為執行函式而分配的區域性變數、函式引數、返回資料、返回地址等存放在棧區，餘下的空間都被作為堆區。

22.從堆上分配物件陣列，只能呼叫預設的建構函式，不能呼叫其它任何建構函式。如果該類沒有預設建構函式，則不能分配物件陣列。

23.如果你的類需要解構函式來析構資源，則它也需要一個拷貝建構函式。
可以直接呼叫建構函式產生無名物件。無名物件可以作為實參傳遞給函式，可以拿來拷貝構造一個新物件，也可以初始化一個引用的宣告。

24.轉換建構函式是定義含一個引數的建構函式。

25.運算子new分配堆記憶體，如果成功，則返回該記憶體的空間，如果失敗，則返回NULL。所以每次使用運算子new動態分配記憶體時，都應測試new的返回指標值，以防分配失敗。pName = new char[ strlen(pN) + 1 ]；if ( pName != 0 ) strcpy( pName, pN )；

26.宣告為static的類成員便能在類範圍中共存，稱之為靜態成員。

27.靜態資料成員在類宣告外分配空間和初始化。

28.公共靜態資料成員可被類的外部訪問，保護或私有靜態資料成員只可被類的內部訪問。

29.靜態成員函式定義是類的內部實現，屬於類定義的一部分。它的定義位置與一般成員函式一樣。

30.一個靜態成員函式不與任何物件相聯絡，故不能對非靜態成員進行預設訪問。

31.靜態成員函式與非靜態成員函式的根本區別：靜態成員函式沒有this指標，而非靜態成員函式有一個指向當前物件的指標this。

32.在類裡申明一個普通函式，標上關鍵字friend，就成了該類的友元，可以訪問該類的一切成員。

33.友元宣告的位置可在類的任何部位，既可以在public區，也可以在protected區，意義完全一樣。友元函式定義則在類的外部，一般與類的成員函式定義放在一起。

34.一個類的成員函式可以是另一個類的友元。

35.整個類可以是另一個類的友元，該友元稱為友類。友類的每個成員函式都可以訪問另一個類中的保護或私有資料成員。

36.靜態成員的static一詞與靜態儲存類的static是兩個概念，一個論及類，一個論及記憶體空間的位置以及作用域限定。所以要區分靜態物件和靜態成員。

六、多重繼承與運算子過載

1.虛擬繼承的虛擬和虛擬函式的虛擬沒有任何關係。

2.多繼承的構造順序：一，任何虛擬基類的建構函式按照它們被繼承的順序構造。二，任何非虛擬基類的建構函式按照它們被繼承的順序構造。三，任何成員物件的建構函式按照它們宣告的順序呼叫。四，類自己的建構函式。

3.在繼承關係中，基類的private成員不但對應用程式隱藏，甚至對派生類也隱藏。而基類的保護成員則只對應用程式隱藏，而對派生類則毫不隱瞞。

4.一個私有的或保護的派生類不是子類，因為非公共的派生類不能做基類能做的所有的事。

5.保護繼承與私有繼承類似，繼承之後的類相對於基類來說是獨立的。保護繼承的類物件，在公開場合同樣不能使用基類的成員。

6.當一個類是兩個或多個基類的派生類時，必須在派生類名和冒號之後，列出所有基類的類名，基類間用逗號隔開。

7.派生類的建構函式必須啟用所有基類的建構函式，並把相應的引數傳遞給它們。

8.在無繼承的類中，protected和private控制符是沒有差別的。在繼承中，基類的private對所有的外界都遮蔽（包括自己的派生類），基類的protected控制符對應用程式是遮蔽的，但對其派生類是可訪問的。

9.運算子是函式，除了運算順序和優先順序不能更改外，引數和返回型別是可以重新說明的，即可以過載。

10.C++規定了“ . 、:: 、. * 、-> 、？: ”這五個運算子不能過載，也不能創造新運算子。

11.operator++()是單目運算子，它含有一個引數。++d <=> d.operator++()； d++ <=> d.operator++(0)

12.C++規定： =，（），[ ]，-> 這四種運算子必須為成員形式。

13.使用前增量，對物件（運算元）進行增量修改，然後再返回該物件。所以前增量運算子操作時，引數與返回的是同一物件。

14.使用後增量，必須在增量之前返回原有的物件值。為此，要建立一個臨時物件，存放原有的物件，以便運算元（物件）進行增量修改時，儲存最初的值。

15.轉換運算子：operator 型別名（）；它沒有返回型別，因為型別名就代表了它的返回型別，故返回型別顯得多餘。

習題

一、單項選擇題

1．在每個C++程式中都必須包含有這樣一個函式，該函式的函式名為(A)。
A. main B. MAIN C. name D. function

2.如果class類中的所有成員在定義時都沒有使用關鍵字public、private或protected，則所有成員預設定義為（ C ）。
A） public B） protected C） private D）static

3．一個類的所有物件共享的是（ D ）。
A）私有資料成員 B）公有資料成員 C）保護資料成員 D）靜態資料成員

4．動態聯編所支援的多型性稱為（ D ）。
A. 虛擬函式 B. 繼承 C. 編譯時多型性 D. 執行時多型性

5．下面有關過載函式的描述中，正確的是（ C ）。
A）過載函式必須具有不同的返回值型別 B）過載函式形參個數必須不同
C）過載函式必須具有不同的形參表 D）過載函式名可以不同

6．假定MyCIass為一個類，那麼下列的函式說明中，（ D ）為該類的解構函式。
A）void~MyClass(); B）~MyClass(int n); C）MyClass( ); D）~MyClass( );

7．下列關於C++函式的說明中，正確的是（ C ）。
A）行內函數就是定義在另一個函式體內部的函式
B）函式體的最後一條語句必須是return語句
C）呼叫一個函式之前，如果還沒有定義這個函式，必須先宣告其原型
D）編譯器會根據函式的返回值型別和參數列來區分函式的不同過載形式

8．假定MyCIass為一個類，那麼下列的函式說明中，（ C ）為該類的無參建構函式。
A）void MyClass(); B）~MyClass(int n); C）MyClass( ); D）~MyClass( );

9．下列是過載加法運算子的函式原型宣告，其中錯誤的是（ A ）。
A）MyClass operator+(double,double); B）MyClass operator+(double,MyClass);
C）MyClass operator+(MyClass,double); D）MyClass operator+(MyClass,MyClass);

10．下列對類的建構函式和解構函式描述正確的是（A）。
A)建構函式可以過載，解構函式不能過載 B)建構函式不能過載，解構函式可以過載
C)建構函式可以過載，解構函式可以過載 D)建構函式不能過載，解構函式不能過載

11．在函式定義前加上關鍵字“inline”，表示該函式被定義為（ B ）。
A）過載函式 B）行內函數 C）成員函式 D）普通函式

12．下列有關類與物件的說法中，( C ) 是不正確的。
A) 物件是類的一個實列 B) 任何一個物件只能屬於一個具體的類
C) 一個類只能有一個物件 D) 類和物件的關糸和數椐型別與變數的關糸類似

13．類的解構函式的作用是( D )。
A) 作為類的一般成員函式 B) 類的初始化 C) 物件的初始化 D) 物件的刪除

14．一個類的友元函式或友元類可以訪問該類的( D )。
A) 私有成員 B) 保護成員 C) 公有成員 D) 所有成員

15．下列關於成員函式特徵的描述中，( D ) 是錯誤的。
A) 成員函式一定是行內函數 B) 成員函式可以過載
C) 成員函式可以設定引數的預設值 D) 成員函式可以不設定引數的預設值

16．下列函式中，( C ) 不是類的成員函式。
A) 建構函式 B) 解構函式 C) 友元函式 D) 拷貝建構函式

17．下列的描述中，( B ) 是錯誤的。
A) 公有繼承時基類中的public成員在派生類中仍是public的
B) 公有繼承時基類中的private成員在派生類中是private的
C) 公有繼承時基類中的protected成員在派生類中仍是protected的
D) 私有繼承時基類中的public成員在派生類中仍是private的

class A
{ 
int i, j;
public:
A(int m, int n): i(m), j(n) { }
int Geti() { return i;}
};
class B: public A
{ int k;
public:
B(int m, int n, int u): A(m, n), k(u) {}
void Make( ) { k = i * j; }
};
int main()
{ B b(1, 2, 3);
return 0;
}

則上述定義中，( A ) 是非法的表示式.
A) k=ij; B) int k; C) return i; D) void Make( )

19．假定CTest為一個類，並且有一無預設值的有參建構函式和一無參建構函式，則執行“CTest objTest;”語句時將自動呼叫該類的（ B ）。
A) 有參建構函式 B) 無參建構函式 C) 拷貝建構函式 D) 賦值過載函式

20、物件導向程式設計思想的主要特徵中不包括（ D ）。
A. 封裝性 B. 多型性 C. 繼承性 D. 功能分解，逐步求精

21、考慮下面的函式原型宣告：void testDefaulParam(int a,int b=7,char z=’’);
下面函式呼叫中，不合法的是（ C ）。
A. testDefaulParam(5); B. testDefaulParam(5,8);
C. testDefaulParam(5,’#’); D. testDefaulParam(0,0,’*’);

22、下列語句中，將函式int sum(int x, int y)正確過載的是（ C ）。
A. float sum(int x, int y); B. int sum(int a, int b);
C. float sum(float x, float y); D. double sum(int y, int x);

23、下列表示引用的方法中，（ A ）是正確的。
已知：int a=1000;
A. int &x=a; B. char &y; C. int &z=1000; D. float &t=&a;

24、已知X類，則當程式執行到語句：X array[3];時，呼叫了（ D ）次建構函式。
A. 0 B. 1 C. 2 D. 3

25、下面關於友元的描述中，錯誤的是（ D ）。
A. 友元函式可以訪問該類的私有資料成員
B. 一個類的友元類中的成員函式都是這個類的友元函式
C. 友元可以提高程式的執行效率
D. 類與類之間的友元關係可以繼承

26、有關解構函式的說法，不正確的是（ B ）。
A．解構函式有且僅有一個
B．解構函式和建構函式一樣可以有形參
C．解構函式的功能是在系統釋放物件之前作一些記憶體清理工作
D．解構函式無任何函式型別

27、可以在類外用p.a的形式訪問派生類物件p的基類成員a，其中a是（ D ）。
A．私有繼承的公用成員 B．公用繼承的私有成員
C．公用繼承的保護成員 D．公用繼承的公用成員

28、在公有繼承的情況下，基類非私有成員在派生類中的訪問許可權（B ）
（A） 受限制 （B）保持不變 （C）受保護 （D）不受保護

29.作用域運算子“：：”的功能是（B）
A. 標識作用域的級別的
B. 指出作用域的範圍的
C. 給定作用域的大小的
D. 標識成員是屬於哪個類的

30.關於const關鍵字說法錯誤的是（D）
A. const關鍵字可以修飾物件和成員函式
B. const物件不能被修改
C. const成員函式不能修改類資料成員
D. const可以用於說明類

31.下列描述錯誤的是（A）
A. 在建立物件前，靜態成員不存在
B. 靜態成員是類的成員
C. 靜態成員不能是虛擬函式
D. 靜態成員函式不能直接訪問非靜態成員

二、填空題

1．過載運算子“+”的函式名為operator+。

2．在C++中，如果類的名稱是CTest，則此類的建構函式名稱為CTest（）。

3．在類的物件被建立時，建構函式 函式會被自動呼叫。

4．對於派生類的建構函式，在定義物件時建構函式的執行順序為：先執行 基類 的建構函式，再執行呼叫子物件類的建構函式，最後執行派生類的建構函式體中的內容。

5．類的具體表現是通過建立 物件 來操作的。

6．假定AB為一個類，則執行“AB a[10]；”語句時，系統自動呼叫該類的建構函式的次數為 10 。

7、在C++中，三種繼承方式的說明符號為 private 、 public 和 protected，如果不加說明，則預設的繼承方式為 private 。

8、若要把void fun( )定義為類A的友元函式，則應在類A的定義中加入語句friend void fun(A &a)。

9、運算子過載要求保持其原來的運算元個數、 優先順序 、 結合性 。

10、列出C++中兩種使用者自定義的資料型別： 結構體 、 類 。

11、建構函式的作用是 在建立物件時為物件分配儲存空間和初始化物件的資料成員。

12、C++類的組成包括資料成員和成員函式，友元不是該類的成員函式。
友員函式是用關鍵字friend修飾的非成員函式。

三、讀程式寫結果

1．若有以下程式:

class A
{ 
	int a;
	public:
	A(int aa = 0 )
	{ 
		a = aa;
	 }
	~A( ) 
	{
		cout << "Destructor A! " << a << endl; 
	}
};

class B: public A
{
	int b;
	public:
		B(int aa = 0, int bb = 0): A(aa) 
		{ 
			b = bb; 
		}
		~B()
		{ 
			cout << "Destructor B! " << b << endl;
		 }
};
int main()
{ 
	B x(5), y(6,7);
	return 0;
}

上面程式的輸出結果為：
Destructor B! 7
Destructor A! 6
Destructor B! 0
Destructor A! 5

2．若有以下程式:

#include <iostream.h>
class Point
{ 
	int x, y;
	public:
		Point()
		{ 
			x = 0; y = 0; 
		}
		void SetPoint(int x1, int y1) 
		{ 
			x = x1;
			y = y1; 
		}
		void DisPoint() 
		{ 
			cout << “x=” << x <<"," << “y=” << y << endl; 
		}
};
int main()
{ 
	Point P1;
	P1.SetPoint(5, 12);
	P1.DisPoint();
	return 0;
}

上面程式的輸出結果為：
x=5, y=12

3．若有以下程式:

#include <iostream.h>
class A
{ 
int a;
public:A(int aa = 0 )
	{ 
		a = aa;	
		cout << "A(): " << a << endl;
	} 
};
class B: public A
{ 
	int b;
	public:
		B(int aa = 0, int bb = 0): A(aa)
		{ 
			b = bb;
			cout << "B(): " << b << endl;
		}
};
int main()
{ 
	B x(5), y(6,7);
	return 0;
}

輸出結果為:
A( ): 5
B( ): 0
A( ): 6
B( ): 7

class Date
{ public:
Date(int,int,int);
Date(int,int);
Date(int);
Date();
void display();
private:
int month, day, year;
};
Date::Date(int m,int d,int y):month(m),day(d),year(y) { }
Date::Date(int m,int d):month(m),day(d) {year=2009;}
Date::Date(int m):month(m){day=1; year=2010; }
Date::Date( ) {month=1; day=1; year=2010; }
void Date::display(){ cout<<month<<"/"<<day<<"/"<<year<<endl; }
int main( )
{ Date d1(12,31,2009);
Date d2(12,31);
Date d3(1);
Date d4;
d1.display();
d2.display();
d3.display();
d4.display();
return 0;
}

輸出結果為:

12/31/2009
12/31/2009
1/1/2010
1/1/2010

四、程式填空

1．請完成下面的程式
#include // 預處理命令
using namespace std; // 使用標準名稱空間std
class Test
{ private:
int a; // 資料成員
public:
Test(int x = 0){ (1) } // 建構函式
void Show( ){ cout << “a:” << a << endl; } // 顯示資料成員之值
};
int main( ) // 主函式main(void)
{ Test obj(168); // 定義物件
(2) // 顯示資料成員之值
return 0;
}

2．請完成下面的程式
#include // 預處理命令
using namespace std; // 使用標準名稱空間std
class Complex
{private:
double realPart; // 實部
double imagePart; // 虛部
public:
Complex(double real = 0, double image = 0) // 建構函式
{ realPart=real;
imagePart=image;
}

double GetRealPart( ) { return realPart; } // 返回實部
double GetImagePart( ){ return imagePart; } // 返回虛部
Complex operator+( Complex &a) // 過載加法運算子+
{ return Complex( (3) ); // 返回和
}};

int main( ) // 主函式main(void)
{ Complex a(1, 2), b(2, 6), c; // 定義複數物件
(4) // 複數加法運算
cout << “a=” << a.GetRealPart() << “+” << a.GetImagePart() << “i” << endl; // 顯示a
cout << “b=” << b.GetRealPart() << “+” << b.GetImagePart() << “i” << endl; // 顯示b
cout << “c=” << c.GetRealPart() << “+” << c.GetImagePart() << “i” << endl; // 顯示c
return 0; // 返回值0, 返回作業系統
}

參考答案：(1) a=x ; (2) obj.Show( );
(3) realPart + a.realPart, imagePart + a.imagePart (4) c=a+b;

五、程式設計題

1、構造一個rectangle的矩形類，包含資料成員，左下角點的座標（x1,y1）與右上角點的座標（x2,y2）；包含成員函式getarea( )計算矩形的面積。完成類，並在主函式定義一個矩形物件，並計算輸出該矩形物件的面積(10分)
#include
#include
using namespace std;
class rectangle //(2分)
{
private:
int x1,y1,x2,y2; // (2分)
public:
rectangle(int xx1,int yy1,int xx2,int yy2) //(1分)
{
x1=xx1;y1=yy1;x2=xx2;y2=yy2;
}
int getarea() //(2分)
{
return abs((x2-x1)*(y1-y2));
}
};

void main()
{
rectangle rect1(3,7,8,5); (2分)
cout<<rect1.getarea()<<endl; (1分)
}

2、定義一boat與car兩個類，二者都有weight屬性，定義二者的一個友元函式totalweight()，計算二者的重量和。(10分)
#include // 預處理命令
using namespace std; // 使用標準名稱空間std
class car;（1分）
class boat{
private:
int weight; //(1分)
public:
boat(int w):weight(w){ } //(1分)
friend int totalweight(boat b1,car c1); //(2分)
};
class car{ /(1分)
private:
int weight; (1分)
public:
car(int w):weight(w){};
friend int totalweight(boat b1,car c1); (1分)
};
int totalweight(boat b1,car c1) //(1分)
{
return b1.weight+c1.weight;
}
void main()
{
car c1(1000);
boat b1(2000);
cout<<totalweight(b1,c1)<<endl;(1分)
}
3、設計一個汽車類vehicle，包含的資料成員有車輪個數wheels和車重weight。小車類car是它的派生類，其中包含載人數passenger_load。每個類都有相關資料的輸出方法。在主程式中定義一個car類物件，對其車輪個數、車重、載人數進行設定並顯示。(10分)

#include // 預處理命令
using namespace std; // 使用標準名稱空間std
class vehicle // 定義汽車類 (3分)
{
protected:
int wheels; // 車輪數
float weight; // 重量
public:
vehicle(int wheels,float weight);
int get_wheels();
float get_weight();
float wheel_load();
void show();
};
class car:public vehicle // 定義小車類 (3分)
{
int passenger_load; // 載人數
public:
car(int wheels,float weight,int passengers=4);
int get_passengers();
void show();
};
vehicle::vehicle(int wheels1,float weight1) //(1分)
{
wheels=wheels1;
weight=weight1;
}
int vehicle::get_wheels()
{
return wheels;
}
float vehicle::get_weight()
{
return weight;
}
void vehicle::show() (1分)
{
cout << “車輪:” << wheels << “個” << endl;
cout << “重量:” << weight << “公斤” << endl;
}
car::car(int wheels, float weight, int passengers) :vehicle(wheels, weight)
{
passenger_load=passengers;
}
int car::get_passengers ()
{
return passenger_load;
}
void car::show()
{
cout <<" 車型:小車" << endl;
vehicle::show();
cout << “載人:” << passenger_load << “人” << endl;
cout << endl;
}
void main ()
{
car car1(4,2000,5); (1分)
cout << “輸出結果” << endl;
car1. show (); (1分)
}
4．設計一個類DateInfo，要求其滿足下述要求：
（1）要求有一個無參的建構函式，其初始的年、月、日分別為：2010，6，8。
（2）要求有一個帶引數的建構函式，其引數分別對應年、月、日。
（3）要求用一個成員函式實現日期的設定。
（4）要求用一個成員函式實現輸出日期。
要求用一個成員函式實現日期的獲取。
#include
using namespace std;
class DateInfo
{ private: int year, month, day;
public: DateInfo(): year(2010), month(6), day(8){ }
DateInfo(int y, int m, int d): year(y), month(m), day(d){ }
void Set(int y, int m, int d)
{ year = y;
month = m;
day = d;
} void Show() { cout << year << “年” << month << “月” << day << “日” << endl; }
};
int main()
{ DateInfo d1, d2(1988, 8, 18);
d1.Show();
d2.Show();
d2.Set(1999, 9, 19);
d2.Show();
return 0;
}

5．設計一個類Rect，要求如下：
（1）該類中的私有資料成員length，width存放它的長和寬,並且設定它們的預設值是0。
（2）通過成員函式設定其長和寬，並確保長和寬都在(0，50)範圍之內。
（3）實現求周長函式GetPerimeter()。
#include
using namespace std;
class Rect
{ private:
double length, width;
public:
Rect(double l = 0, double w = 0): length(l), width(w){ }
void Set(double l, double w)
{ if (length <= 0 || length >= 50 || width <= 0 || width >= 50 )
cout<<資料不在指定範圍(0,50)!"; // 丟擲異常
length = l;
width = w;
} double GetPerimeter() { return 2 * (length + width); }
};
int main( )
{ Rect obj(1, 8);
cout << “周長:” << obj.GetPerimeter() << endl;
return 0;
}

(提高題，擴充套件)6、編寫程式，定義抽象基類Shape(形狀)，由它派生出2個派生類：Circle(圓形) 和Rectangle(矩形)，用函式Show( )分別顯示各種圖形的相關資訊，最後還要顯示所有圖形的總面積。
要求：
（1）從Shape類派生圓類(Circle)、矩形類（Rectangle），圓類新增資料成員半徑（radius），矩形類新增資料成員邊長（length）、寬(width)，圓類和矩形類都有建構函式，顯示資料成員值的函式和求面積發函式。
（2）寫出main( )函式，計算半徑為5.5的圓和邊長為9.9的正方形的面積和。
#include // 預處理命令
using namespace std; // 使用標準名稱空間std
const double PI = 3.1415926; // 定義常量PI
class Shape
{public:
Shape() { } // 建構函式
virtual ~Shape() { } // 解構函式
virtual Show() = 0; // 顯示面積
static double totalArea; // 總面積
static void ShowTotalArea() { cout << “總面積:” << totalArea << endl; }
};
class Circle: public Shape
{private:
double radius; // 半徑
public:
Circle(double r): radius® { totalArea += PI * r * r; } // 建構函式
~Circle() { } // 解構函式
virtual Show() { cout << “圓面積:” << PI * radius * radius << endl; }; // 顯示面積
};
class Rectangle: public Shape
{private:
double length; // 長
double width; // 寬
public:
Rectangle(double l, double w): length(l), width(w){ totalArea += l * w; } // 建構函式
~Rectangle() { } // 解構函式
virtual Show() { cout << “矩形面積:” << length * width << endl; }; // 顯示面積
};
double Shape::totalArea = 0; // 初始化totalArea
int main(void)
{ Circle c(1); // 定義圓物件
c.Show(); // 顯示面積
Rectangle r(1, 2); // 定義矩形物件
r.Show(); // 顯示面積
Shape::ShowTotalArea(); // 顯示總面積
return 0; // 返回值0, 返回作業系統
}