題目類型

a.C++與C差異（1-18）

1.C和C++中struct有什么區(qū)別帆焕？

C沒有Protection行為厨幻，不能定義函數(shù)覆履，但可以有函數(shù)指針。

C++有Protection行為傀缩，默認是public（class默認private），可以定義函數(shù)农猬；

2.C++中的struct和class有什么區(qū)別赡艰？

struct可以class所有功能，本質(zhì)上是一個東西斤葱，struct成員和繼承默認是public慷垮，class成員和繼承默認是private勋又。

3.如何判斷一個程序是由c編譯程序還是由C++編譯程序編譯的？

判斷：檢測宏

#ifdef __cpluspluc

cout<<"c++";

#else

printf("c“)换帜；

#endif

4.C和C++有什么不同楔壤？

機制上：C面向過程的（但也可編寫面向?qū)ο螅籆++編寫面向?qū)ο蟮某绦虮菴容易

適用的方向：c適合要求代碼體積小的惯驼，效率高的場合蹲嚣，如嵌入式；C++更適合上層的祟牲，復(fù)雜的

C語言是結(jié)構(gòu)化編程語言隙畜，C++是面向?qū)ο缶幊陶Z言。

C++側(cè)重于對象而不是過程说贝，側(cè)重于類的設(shè)計而不是邏輯的設(shè)計议惰。

5.“引用”與指針的區(qū)別是什么？

指針通過某個指針變量指向一個對象后乡恕，對它所指向的變量間接操作言询。程序中使用指針，程序的可讀性差傲宜；而引用本身就是目標變量的別名运杭，對引用的操作就是對目標變量的操作。

6.虛函數(shù)

虛函數(shù)是可以通過接口繼承的

7.int id[sizeof(unsigned long)];這個對嗎函卒？

對

8.某文件定義靜態(tài)全局變量辆憔，他的作用域。

靜態(tài)全局變量只在源文件內(nèi)有效报嵌，避免引用出錯虱咧。類里面的靜態(tài)變量可以不用實例化。C++沒有靜態(tài)類锚国。

9.C++值的傳遞

三種：值傳遞腕巡，指針傳遞，引用傳遞

10.頻繁使用的短小函數(shù)跷叉，C語言和C++逸雹？

C用宏定義#define，C++用inline函數(shù)（一般函數(shù)浪費的是調(diào)用和返回的時間）

11.引用和指針的差別云挟？

引用須被初始化梆砸，指針不必。（C++11引用是可以改變的）

引用初始化不能被改變园欣，但指針可以改變所指對象帖世。

不存在指向空值的引用，但是存在指向空值的指針。

12.virtual與inline的含義分別是什么日矫？

virtual意味著聲明為虛函數(shù)赂弓，inline與函數(shù)定義體放在一起，使該函數(shù)稱為內(nèi)聯(lián)哪轿。inline是一種用于實現(xiàn)的關(guān)鍵字盈魁，而不是用于聲明的關(guān)鍵字。

虛函數(shù)的特點：如果希望派生類能夠重新定義基類的方法窃诉，則在基類中將該方法定義為虛方法杨耙，這樣可以啟用動態(tài)聯(lián)編。（多繼承下只產(chǎn)生一個虛基類）

動態(tài)聯(lián)編 和 靜態(tài)聯(lián)編

http://blog.csdn.net/gaoxin1076/article/details/8298279

內(nèi)聯(lián)函數(shù)的特點：使用內(nèi)聯(lián)函數(shù)的目的是為了提高函數(shù)的運行效率飘痛。

內(nèi)聯(lián)函數(shù)體的代碼不能過長珊膜，因為內(nèi)聯(lián)函數(shù)省去調(diào)用函數(shù)的時間是以代碼膨脹為代價的。

內(nèi)聯(lián)函數(shù)不能包含循環(huán)語句宣脉，因為執(zhí)行循環(huán)語句要比調(diào)用函數(shù)的開銷大车柠。

13.VC中,編譯工具Debug與Release選項是什么含義?

Debug通常稱為調(diào)試版本,包含調(diào)試信息,不做優(yōu)化，便于程序員調(diào)試進程塑猖。Release稱為發(fā)布版本竹祷，它往往是進行了各種優(yōu)化，使得程序在代碼大小和運行速度上都是最優(yōu)的萌庆，以便用戶很好地使用溶褪。Debug帶有大量的挑調(diào)試代碼和信息，運行需要相應(yīng)的庫践险，發(fā)布模式程序緊湊不含有調(diào)試代碼和信息，可以直接運行（不需要運行庫）吹菱。

14.函數(shù)assert的用法巍虫？

斷言assert是僅在debug版本起作用的宏，用于檢查“不應(yīng)該”發(fā)生的情況鳍刷。程序員可以把assert看成是一個任何系統(tǒng)狀態(tài)下都可以安全使用的無害測試手段占遥。

15.const與#define的比較，const有什么優(yōu)點输瓜？

const常量有數(shù)據(jù)類型（定義不讀內(nèi)存）瓦胎，而宏常量沒有數(shù)據(jù)類型，編譯器可以對前者進行類型安全檢查尤揣。而對后者只進行字符替換搔啊，沒有類型安全檢查，并且在字符替換可能會產(chǎn)生意料不到的錯誤（邊際效應(yīng)）

有些集成化的調(diào)試工具可以對const常量進行調(diào)試北戏，但是不能對宏常量進行調(diào)試负芋。

16.談?wù)勔煤椭羔樀膮^(qū)別：

引用被創(chuàng)建的同時必須被初始化（指針可以在任何時候初始化）

不能有NULL引用，左值引用必須與合法的存儲單元關(guān)聯(lián)（指針可以是NULL）內(nèi)存嗜愈，右值引用引用寄存器旧蛾。

一旦引用被初始化莽龟，就不能改變引用的關(guān)系（指針可以隨時改變所指的對象）

17.有了malloc/free為什么還要new/delete?

malloc/free是C/C++語言的標準函數(shù)庫，new/delete是C++ 的運算符锨天，它們都可以申請動態(tài)內(nèi)存和釋放內(nèi)存毯盈。

由于對象在創(chuàng)建的同時要自動執(zhí)行構(gòu)造函數(shù)，消亡之前要自動執(zhí)行析構(gòu)函數(shù)病袄，因為malloc/free是庫函數(shù)而不是運算符奶镶，不在編譯器的控制權(quán)之內(nèi)，不能把任務(wù)強加于malloc/free陪拘。因此需要一個能完成動態(tài)內(nèi)存分配和初始化的運算符new厂镇，以及一個能清理和釋放內(nèi)存工作的運算符delete。

new可以把內(nèi)存開在靜態(tài)區(qū)左刽，防止內(nèi)存泄漏捺信。

18.如果再申請動態(tài)內(nèi)存找不到足夠大的內(nèi)存塊，malloc和new將返回NULL指針欠痴，宣告內(nèi)存申請失敗迄靠。你是怎么處理內(nèi)存耗盡的？

判斷指針是否為NULL喇辽，是則馬上return語句終止函數(shù)

判斷指針是否為NULL掌挚，是則馬上用exit(1)終止程序運行

為new和malloc設(shè)置異常處理函數(shù)。 例如Visual C++可以用_set_new_hander函數(shù)為new設(shè)置用戶自己定義的異常處理函數(shù)菩咨，也可以讓malloc享用與new 相同的異常處理函數(shù)吠式。

#include big *p; p = new(std::nothrow) big[1000];

b.數(shù)據(jù)類型、關(guān)鍵字（19-37）

19.C++是不是類型安全的抽米？

不是特占，兩個不同類型的指針是可以強制轉(zhuǎn)換的（用reinterpret cast）

20.const符號常量（1）const char *p（2）char const *p（3）char * const p 區(qū)別

（1）p是一個指向const char 的指針，p是可以改變指向的云茸，但是p指向的值時不能改變的是目。

（2）p指向的恰好是一個指向const的char的普通指針。

（3）p是一個指針标捺，這個指針是指向char的const指針懊纳，

（1）和（2）的定義是一樣的，*左邊值不能改變亡容，*右邊指針不能改變

21.用C++寫個程序嗤疯，如何判斷一個操作系統(tǒng)是16位、32位萍倡？

定義一個指針身弊，sizeof（p），4是32位，2是16位阱佛，如果64位系統(tǒng)兼容32位的話也是4字節(jié)

22.用C++寫個程序帖汞，如何判斷一個操作系統(tǒng)是16位、32位凑术？不用sizeof（）函數(shù)

int a = ~0;

if(a>65535){ cout<<"32"bit<

else{ cout<<"16"bit<

23.void *(*(*fp1)(int))[10]; float(*(* fp2)(int,int,int))(int); int(*(*fp3)())[10]();

(1)void *(*(*fp1)(int))[10]; fp1是一個指針翩蘸，指向一個函數(shù)，這個函數(shù)的參數(shù)為int型淮逊，函數(shù)的返回值是一個指針催首，這個指針指向一個數(shù)組，這個數(shù)組有10個元素泄鹏，每個元素是一個void*型指針郎任。

(2)float(*(* fp2)(int,int,int))(int); fp2是一個指針，指向一個函數(shù)备籽，這個函數(shù)的參數(shù)為3個int型舶治，函數(shù)的返回值是一個指針，這個指針指向一個函數(shù)车猬，這個函數(shù)的參數(shù)為int型霉猛，函數(shù)的返回值是float型。

(3)int(*(*fp3)())[10]();fp3是一個指針珠闰，指向一個函數(shù)惜浅，這個函數(shù)的參數(shù)為空，函數(shù)的返回值是一個指針伏嗜，這個指針指向一個數(shù)組坛悉，這個數(shù)組有10個元素，每個元素是一個指針阅仔，指向一個函數(shù)吹散，這個參數(shù)為空，函數(shù)的返回值是int型八酒。

24.多態(tài)類中的虛函數(shù)表示Compile-Time，還是Run-Time時建立的刃唐？

虛擬函數(shù)表是在編譯期就建立了羞迷，各個虛擬函數(shù)這時被組織成了一個虛擬函數(shù)的入口地址的數(shù)組。而對象的隱藏成員--虛擬函數(shù)表指針是在運行期--也就是構(gòu)造函數(shù)被調(diào)用時進行初始化画饥，這是實現(xiàn)多態(tài)的關(guān)鍵衔瓮。（動態(tài)聯(lián)編）

25.錯誤的轉(zhuǎn)義字符'\091'八進制不能有9

26。數(shù)組名做實參抖甘，指針變量做形參热鞍，傳數(shù)組名傳過去的是數(shù)組的第一個元素地址

27.變量的指針指的是變量的地址

28.內(nèi)存的分配方式有幾種？

在四個地方分配內(nèi)存1.靜態(tài)存儲區(qū)域。2.棧上創(chuàng)建薇宠。3.堆上動態(tài)內(nèi)存分配偷办。4.代碼區(qū)

a從靜態(tài)存儲區(qū)分配。內(nèi)存在程序編譯的時候就已經(jīng)分配好澄港，這塊內(nèi)存在程序的整個運行期間都存在椒涯。例如全局變量。

b在棧上創(chuàng)建回梧。在執(zhí)行函數(shù)時废岂，函數(shù)內(nèi)部局部變量的存儲單元都可以在棧上創(chuàng)建，狱意，函數(shù)執(zhí)行結(jié)束時這些存儲單元自動被釋放湖苞。棧內(nèi)存分配運算內(nèi)置于處理器的指令集中，效率很高详囤，但是分配的內(nèi)存容量有限财骨。

c在堆上分配，亦稱動態(tài)內(nèi)存分配纬纪。程序在運行的時候用malloc或new申請任意多少的內(nèi)存蚓再，程序員自己負責(zé)在何時用free或delete釋放內(nèi)存。動態(tài)內(nèi)存的生存期由我們決定包各，使用非常靈活摘仅，但問題也多。

棧連續(xù)问畅，堆不連續(xù)（鏈表）

29.float a,b,c,問等式(a+b)+c==(b+a)+c 和 (a+b)+c==(a+c)+b能否成立娃属？

兩者都不行。在比較float或double時护姆，不能簡單地比較矾端。由于計算誤差，相等的概率很低卵皂。應(yīng)判斷兩數(shù)之差是否落在區(qū)間(-e,e)內(nèi)。這個e應(yīng)比浮點數(shù)的精度大一個數(shù)量級添祸。

30.全局變量和局部變量有什么區(qū)別？是怎么實現(xiàn)的盖奈？操作系統(tǒng)和編譯器是怎么知道的？

生命周期不同：全局變量隨主程序創(chuàng)建而創(chuàng)建禾酱，隨主程序的銷毀而銷毀滓走；

局部變量在局部函數(shù)內(nèi)衩藤，甚至局部循環(huán)體等內(nèi)部存在，退出就不存在涕癣；

內(nèi)存中分配在全局數(shù)據(jù)區(qū)

使用方式不同：通過聲明后全局變量程序的各個部分都可以用到；

局部變量只能在局部使用；

分配在棧區(qū)骚亿。

操作系統(tǒng)和編譯器通過內(nèi)存分配的位置來知道的俱笛，

全局變量分配在全局數(shù)據(jù)段并且在程序開始運行的時候被加載。

局部變量則分配在堆棧里面卸亮。

31.Heap與Stack 的差別

Heap是堆，Stack是棧（高效地節(jié)約內(nèi)存，用完就馬上釋放）功茴。

Stack的空間由操作系統(tǒng)自動分配/釋放庐冯，Heap上的空間手動分配/釋放

Stack空間有限，Heap是很大的只有存儲區(qū)

C中的malloc函數(shù)分配的內(nèi)存空間即在堆上坎穿，C++中對應(yīng)的是new操作符

程序在編譯期對變量和函數(shù) 分配內(nèi)存都在棧上進行展父，且程序運行過程中函數(shù)調(diào)用時參數(shù)的傳遞也在棧上進行。

32.explict protected

explict關(guān)鍵字用來修飾類的構(gòu)造函數(shù)玲昧，表明該構(gòu)造函數(shù)是顯式的栖茉，在某些情況下，我們要求類的使用者必須顯示調(diào)用類的構(gòu)造函數(shù)時就需要使用explicit酌呆，反之默認類型轉(zhuǎn)換可能會造成無法預(yù)期的問題衡载。

protected控制的是一個函數(shù)對一個類的成員（包括成員變量及成員方法）的訪問權(quán)限。protected成員只有該類的成員函數(shù)及其派生類的成員可以訪問隙袁。

33.重復(fù)多次fclose一個打開過一次的FILE *fp指針會有什么后果痰娱，解釋

考察點：導(dǎo)致文件描述符結(jié)構(gòu)中指針指向的內(nèi)存被重復(fù)釋放，進而導(dǎo)致一些不可預(yù)期的異常菩收。

34.為什么數(shù)組名作為參數(shù)梨睁，會改變數(shù)組的內(nèi)容，而其他類型如int卻不會改變變量的值娜饵？

數(shù)組名為參數(shù)時坡贺，傳遞的實際上是地址。而其他類型如int作為參數(shù)時箱舞，由于函數(shù)參數(shù)值實質(zhì)上是實參的一份拷貝遍坟，被調(diào)函數(shù)內(nèi)部對形參的改變并不影響實參的值。

35.你覺得如果不使用常量晴股，直接在程序中填寫數(shù)字或字符串愿伴，將會有什么麻煩？

（1）程序的可讀性（可理解性）變差电湘。程序員自己會忘記那些數(shù)字或字符串是什么意思隔节，用戶則更加不知它們從何處來、表示什么寂呛。

（2）在程序的很多地方輸入同樣的數(shù)字或字符串怎诫，難保不發(fā)生書寫錯誤。

（3）如果要修改數(shù)字或字符串贷痪，則會在很多地方改動幻妓，既麻煩又容易出錯。

36.為什么需要使用堆劫拢，使用堆空間的原因涌哲？

直到運行時才知道一個對象需要多少內(nèi)存空間胖缤；不知道對象的生存期到底有多長。

37.const關(guān)鍵字阀圾？有哪些作用？

（1）欲阻止一個變量被改變狗唉，可以使用const關(guān)鍵字初烘。在定義該const變量時，通常需要對它進行初始化分俯，因為以后就沒有機會再去改變它了肾筐；

（2）對指針來說，可以指定指針本身為const缸剪，也可以指定指針所指的數(shù)據(jù)為const吗铐，或二者同時指定為const；

（3）在一個函數(shù)聲明中杏节，const可以修飾形參唬渗，表明它是一個輸入?yún)?shù)，在函數(shù)內(nèi)部不能改變其值奋渔；（4）對于類的成員函數(shù)镊逝，若指定其為const類型，則表明其實一個常函數(shù)嫉鲸，不能修改類的成員變量撑蒜；

（5）對于類的成員函數(shù)，有時候必須指定其返回值為const類型玄渗，以使得其返回值不為“左值”座菠。

c.面型對象的特性（38-61）

38.是不是一個父類寫了一個virtual函數(shù)，如果子類覆蓋它的函數(shù)不加virtual，也能實現(xiàn)多態(tài)瞳遍？

virtual修飾符會被隱形繼承的傲须。virtual可加不可加。子類的空間里有父類的所有變量（static除外）巡莹。同一個函數(shù)只存在一個實體（inline除外）。子類覆蓋它的函數(shù)不加virtual甜紫，也能實現(xiàn)多態(tài)降宅。在子類的空間里，有父類的私有變量囚霸。私有變量不能直接訪問腰根。

39.面向?qū)ο蟮娜齻€基本特征，并簡單敘述拓型？

（1）封裝：將客觀事物抽象成類额嘿，每個類對自身的數(shù)據(jù)和方法實行protection（private瘸恼，protected，public）

（2）繼承：廣義的繼承有三種形式：實現(xiàn)繼承（指使用基類的屬性和方法而無需額外編碼的能力）册养、可視繼承（子窗體使用父窗體的外觀和實現(xiàn)代碼）东帅、接口繼承（僅使用屬性和方法，實現(xiàn)滯后到子類實現(xiàn)）球拦。

前兩種（類繼承）和后一種（對象組合=>接口繼承以及純虛函數(shù)）構(gòu)成了功能復(fù)用的兩種方式靠闭。

（3）多態(tài)：是將父對象設(shè)置成為和一個或更多的與他的子對象的特性以不同的方式運作。簡單的說坎炼，就是一句話：允許將子類類型的指針賦值給父類類型的指針愧膀。

40.重載（overload）、重寫（override谣光，有的叫覆蓋）檩淋、重定義（redefinition）的區(qū)別？

名稱名字空間區(qū)別

重載同一名字空間是指允許存在多個同名函數(shù)萄金，而這些函數(shù)的參數(shù)表不同

重定義/隱藏不同名字空間用于繼承蟀悦，派生類與基類的函數(shù)同名，屏蔽基類的函數(shù)

重寫/覆蓋不同名字空間用于繼承捡絮，子類重新定義父類虛函數(shù)的方法

41.多態(tài)的作用熬芜？

主要的是兩個：

（1）隱藏實現(xiàn)細節(jié)，使得代碼能夠模塊化福稳；擴展代碼模塊涎拉，實現(xiàn)代碼重用；

（2）接口重用：為了類在繼承和派生的時候的圆，保證使用家族中任一類的實例的某一屬性時的正確調(diào)用鼓拧。

42.當(dāng)一個類A中沒有聲明任何成員變量與成員函數(shù)，這時sizeof（A）的值時多少越妈？如果不是零季俩，請解釋一下編譯器為什么沒有讓它為零？

sizeof（A）=1

一個空類對象的大小是1byte梅掠。這是被編譯器安插進去的一個字節(jié),這樣就使得這個空類的兩個實例得以在內(nèi)存中配置獨一無二的地址酌住。

43.如果ClassA中定義并實現(xiàn)虛函數(shù)int func(void),ClassB中也實現(xiàn)該函數(shù)，那么上述變量a->func()將調(diào)用哪個類里面的函數(shù)阎抒？如果int func(void)不是虛函數(shù)酪我，情況又如何？為什么且叁？

第一問是調(diào)用B的都哭。第二問是調(diào)用A的。虛函數(shù)的一個典型應(yīng)用，虛函數(shù)只能借助于指針或者引用來達到多態(tài)的效果

44.C++里面是不是所有的動作都是main（）函數(shù)引起的欺矫？如果不是請舉例

class A{};

A a; //a的構(gòu)造函數(shù)限執(zhí)行

int main(){}

45.內(nèi)聯(lián)函數(shù)在編譯的時候是否做參數(shù)類型檢查纱新？

內(nèi)聯(lián)函數(shù)要做參數(shù)類型檢查，這是內(nèi)聯(lián)函數(shù)跟宏相比的優(yōu)勢穆趴。

46.講一講析構(gòu)函數(shù)和虛函數(shù)的用法和作用脸爱？

析構(gòu)函數(shù)是特殊的類成員函數(shù)，它沒有返回類型毡代，沒有參數(shù)阅羹，不能隨意調(diào)用，也沒有重載教寂，只有在類對象的生命期結(jié)束的時候，系統(tǒng)自動調(diào)用执庐。有釋放內(nèi)存空間的作用酪耕。（析構(gòu)函數(shù)可以是虛函數(shù)，構(gòu)造函數(shù)不行）

虛函數(shù)是C++多態(tài)的一種表現(xiàn)轨淌，使用虛函數(shù)迂烁，我們可以靈活的進行動態(tài)綁定，當(dāng)然是以一定的開銷為代價递鹉。

47.“new" in C++ is a: operator

malloc是庫函數(shù)盟步，不在編譯器的控制范圍之內(nèi)；

new是運算符躏结，從堆中申請內(nèi)存却盘；調(diào)用new時，從堆中申請內(nèi)存并為內(nèi)存調(diào)用構(gòu)造函數(shù)媳拴。

48. 對于C++中類（class）與結(jié)構(gòu)（struct）的描述正確的為：

D 結(jié)構(gòu)和類對象都可以用new創(chuàng)建

49.類內(nèi)部成員函數(shù)可以用private函數(shù)黄橘。

50.A對調(diào)用的虛函數(shù)和模板類都進行遲后編譯，調(diào)用需要時間

B virtual屈溉，派生類必須要求名字相同塞关，參數(shù)類型相同，但是返回類型可以不同

C inline內(nèi)聯(lián)函數(shù)可以是虛函數(shù)子巾。靜態(tài)成員函數(shù)不能是虛函數(shù)（因為不需要實例化就可以調(diào)用）帆赢，友元函數(shù)，構(gòu)造函數(shù)不能是虛函數(shù)线梗，析構(gòu)函數(shù)可以椰于。

51.C++中有沒有純虛構(gòu)造函數(shù)？

構(gòu)造函數(shù)不能是虛的缠导，只能有虛的析構(gòu)函數(shù)廉羔。

52.throw表達式

（1）class? exception Type{};

throw exception Type();//函數(shù)需要括號

（2）enum mathErr { overflow, underflow, zeroDivide };

throw zeroDivide;//枚舉不需要括號

53.談?wù)勀阍趺凑J識C++ 的模板的？

模板使程序員能夠快速建立具有類型安全的類庫集合和函數(shù)集合，它的實現(xiàn)憋他，方便了大規(guī)模的軟件開發(fā)孩饼。（結(jié)合stl更好）

54.在C++的一個類中聲明一個static成員變量有沒有用？

在C++類的成員變量被聲明為static（稱為靜態(tài)成員變量）竹挡，意味著它為該類的所有實例所共享镀娶，也就是說當(dāng)某個類的實例修改了該靜態(tài)成員變量，也就是說不管創(chuàng)建多少對象揪罕，static修飾的變量只占有一塊內(nèi)存梯码。其修改值為該類的其他所有實例所見；而類的靜態(tài)成員 函數(shù)也只能訪問靜態(tài)成員（變量或函數(shù)）好啰。static是加了訪問控制的全局變量轩娶，不被繼承。

55.C++中為什么要用模板類框往。

（1）可用來創(chuàng)建動態(tài)增長和減小的數(shù)據(jù)結(jié)構(gòu).

（2）它是類型無關(guān)的鳄抒，因此具有很高的可復(fù)用性。

（3）它在編譯時而不是運行時檢查數(shù)據(jù)類型椰弊，保證了類型安全

（4）它是平臺無關(guān)的许溅，可移植性

（5）可用于基本數(shù)據(jù)類型

56.函數(shù)模板與類模板有什么區(qū)別？聯(lián)系秉版？

函數(shù)模板的實例化是由編譯程序在處理函數(shù)調(diào)用時自動完成的

類模板的實例化必須由程序員在程序中顯示地指定

57.

58.談?wù)?在類中如何使用const的贤重？

有時我們希望某些常量只在類中有效。由于#define定義的宏常量是全局的清焕，不能達到目的并蝗，于是想當(dāng)然地覺得應(yīng)該用const修飾數(shù)據(jù)成員來實現(xiàn)。const數(shù)據(jù)成員的確是存在的耐朴，但其含義卻不是我們所期望的借卧。const數(shù)據(jù)成員只在某個對象生存期內(nèi)是常量，而對于整個類而言卻是可變的筛峭，因為類可以創(chuàng)建多個對象铐刘，不同的對象其const數(shù)據(jù)成員的值可以不同。不能在類聲明中初始化const數(shù)據(jù)成員影晓。

const數(shù)據(jù)成員的初始化只能在類構(gòu)造函數(shù)的初始化表中進行镰吵。

59.函數(shù)重載，靠什么來區(qū)分調(diào)用的哪個函數(shù)挂签，靠返回值判斷可以不可以疤祭？

如果同名函數(shù)的參數(shù)不同（包括類型、順序不同）饵婆，那么容易區(qū)別出它們是不同的勺馆。如果同名函數(shù)僅僅是返回值類型不同，有時可以區(qū)分，有時卻不能草穆，例如：

void func（void）灌灾；與int func（void）；

C/C++程序中悲柱，可以忽略函數(shù)的返回值锋喜，但是這種情況下，編譯器和程序員都不知道哪個func函數(shù)被調(diào)用豌鸡，所以只能靠參數(shù)而不能靠返回值類型的不同來區(qū)分重載函數(shù)嘿般。

60.所有運算符都能重載嗎？

有一些不行涯冠。這種限制是出于安全方面的考慮炉奴，可防止錯誤和混亂。

（1）不能改變C++內(nèi)部數(shù)據(jù)類型（如int蛇更，float等）的運算符盆佣。

（2）不能重載'.'，因為'.'在類中對任何成員都有意義械荷，已經(jīng)成為標準用法。

（3）不能重載目前C++運算符集合中沒有的符號虑灰，如#吨瞎，@，$等穆咐。

原因有兩點颤诀，一是難以理解，二是難以確定優(yōu)先級对湃。

（4）對已經(jīng)存在的運算符進行重載時崖叫，不能改變優(yōu)先級規(guī)則，否則將引起混亂拍柒。

61.基類的析構(gòu)函數(shù)不是虛函數(shù)心傀，會帶來什么問題？

派生類的西溝函數(shù)用不上拆讯，會造成資源的泄漏脂男。

d.程序閱讀題（62-90）

62.main函數(shù)執(zhí)行以前，還會執(zhí)行什么代碼种呐？

全局對象的構(gòu)造函數(shù)會在main函數(shù)之前執(zhí)行

63.不使用判斷宰翅，找出a和b中最大值。

((a+b)+abs(a-b))/2

64.如何打印出當(dāng)前源文件的文件名以及源文件的當(dāng)前行號爽室？

cout << __FILE__;

cout << __LINE__;

__FILE__和__LINE__是由系統(tǒng)預(yù)定義宏汁讼，這種宏并不是在某個文件中定義的，而是由編譯器定義的。（C也有）

65下面有兩種if語句判斷方式嘿架。請問哪種寫法更好瓶珊？為什么？

int n;

if(n==10)//第一種

if(10==n)//第二種

這是一個風(fēng)格問題眶明，第二種方式如果少了個=號艰毒，編譯時就會報錯，減少了出錯的可能性搜囱，可以檢測出是否少了=丑瞧。

66.寫出運行結(jié)果：

{char str[]="word";cout<

char *p=str;cout<

char i=10;cout<

void *pp=malloc(10);cout<

6:4:1:4

67.不用第三方參數(shù)的情況下，交換兩個參數(shù)的值蜀肘。

（1）異或

（2）a=a+b; b=a-b; a=a-b;

68.以下代碼如果有錯绊汹，請改正，并寫出輸出結(jié)果扮宠？

main(void)

{int nArrLength(400), i=546;//命名上有問題

for(int i=0;i<99999999999;i++);//考對變量的越界理解西乖，改為unsigned int a=~((int)0)/2,整數(shù)0取反,

cout<

cout<

69.int i=5,b=7;

cout<<(i+++b)<

不用調(diào)試，說出在gcc編譯后的結(jié)果坛增；

(i++ +b) 12

70.寫一個能作為左值的函數(shù)（方法有很多）获雕。

如：max(x,y) +=2874+55;? ? drwline(x,y)++;

int &max(int &x, int &y){

return x>y?x:y;

}

int x=55,y=77;

max(x,y)+=12+11;

cout<<"x="<

71.

class human{

public:

~human(){cout<<"human over...."<

void Disp(){cout<<"human disp...."<

};

class man:public human{

public:

~man(){cout<<"man over...."<

void Disp(){cout<<"man disp...."<

};

int main(){

human *p = new man;

p->Disp();

delete p;

return 0;

}

human disp....

human over....

72.下面的函數(shù)實現(xiàn)在一個固定的數(shù)上加上一個數(shù)，有什么錯誤收捣，改正：

int add_n(int n){

static int i=100;

i+=n;

return i;}

因為static使得i的值會保留上次的值届案。以后的i會一直更新，使得第二次調(diào)用出現(xiàn)錯誤罢艾。

去掉static即可

73.unsigned short array[]={1,2,3,4,5,6,7};

int i=3;

cout<<*(array+i)<

4

74.寫一個函數(shù)當(dāng)參數(shù)為n（n很大）時的值1-2+3-4+5-6+7....+n.

long fn(long n)

{if(n<-0){printf("error:n >must >0");exit(1);}

if(0==n%2) return(n/2)*(-1);

else return (n/2)*(-1)+n;}

75.字符指針楣颠、浮點數(shù)指針、以及函數(shù)指針這三種類型的變量哪個占用內(nèi)存最大咐蚯？為什么童漩？

指針變量也占用內(nèi)存單元，而且所有指針變量占用內(nèi)存單元的數(shù)量都是相同的春锋。就是說矫膨，不管是指向何種對象的指針變量，它們占用內(nèi)存的字節(jié)數(shù)都是一樣的看疙，并且要足夠把程序中所能用到的最大地址表示出來（通常是一個機器字長）豆拨。4

76.以下三條輸出語句輸出

char str1[] = "abc";

char str2[] = "abc";

const char str3[] = "abc";

const char str4[] = "abc";

const char* str5 = "abc";

const char* str6 = "abc";

cout<

cout<

cout<

分別輸出false，false能庆，true施禾。

str1和str2都是字符數(shù)組，每個都有其自己的存儲區(qū)搁胆，它們的值則是各存儲區(qū)首地址弥搞，不等邮绿；

str3和str4同上，只是按const語義攀例，它們所指向的數(shù)據(jù)區(qū)不能修改船逮。

str5和str6并非數(shù)組而是字符指針，并不分配存儲區(qū)粤铭，其后的“abc”以常量形式存于靜態(tài)數(shù)據(jù)區(qū)挖胃，而它們自己僅是指向該區(qū)首地址的指針，相等梆惯。

77.以下代碼有什么問題酱鸭？

（true？1：“1”）<

三元表達式“垛吗？：” 問號后面的兩個操作數(shù)必須為同一類型凹髓。

78.能夠編譯

unsigned int const size1 = 2;

char str1[size1];

unsigned int temp = 0;

cin >> temp;

unsigned int const size2 = temp;

char str2[size2];

str2定義出錯，size2非編譯器期間常量怯屉，而數(shù)組定義要求長度必須為編譯器常量蔚舀。

79.以下代碼輸出語句為0嗎？為什么锨络？

struct CLS{

int m_i;

CLS(int i):m_i(i){}

// m_i沒有初始化

CLS()

{

CLS(0);

}

};

CLS obj;

cout<

不能赌躺。在默認構(gòu)造函數(shù)內(nèi)部再調(diào)用帶參的構(gòu)造函數(shù)屬用戶行為而非編譯器行為， 亦即僅執(zhí)行函數(shù)調(diào)用羡儿，而不會執(zhí)行其后的初始化表達式寿谴。只有在生成對象時，初始化表達式才會隨相應(yīng)的構(gòu)造函數(shù)調(diào)用失受。

80.死循環(huán)

while(1){} 或 for(;1;;)

81.

int a=5,b=7,c;

c = a+++b;

a=6,b=7,c=12

82.在排序方法中，關(guān)鍵碼比較次數(shù)與記錄地初始排列無關(guān)的是（） 選擇排序

83.代碼

void func(){static int val; ...}中咏瑟，變量val的內(nèi)存地址位于：A拂到。已初始化數(shù)據(jù)段

84 入棧

85.判斷表達式，寫出a的值

int a = 4;

A.a+=(a++); B.a+=(++a); C.(a++)+=a;D.(++a)+=(a++);

a++是個右值码泞，C錯兄旬； 可改成（++a）=+a;答案：9,10,10,11

86.談?wù)勅绾问褂胷eturn語句

（1）return語句不可返回指向"棧內(nèi)存"的“指針”或者“引用”，因為該內(nèi)存在函數(shù)體結(jié)束時被自動銷毀余寥。

（2）要搞清楚返回的究竟是“值”领铐、“指針”還是“引用”。

（3）如果函數(shù)返回值是一個對象宋舷，要考慮return語句的效率绪撵。

87.（1）return String(s1+s2); 和(2)String temp(s1+s2);return temp;一樣嗎？

（1）是臨時對象的語法祝蝠，表示“創(chuàng)建一個臨時對象并返回它”音诈。

（2）將發(fā)生三件事：

首先幻碱，temp對象被創(chuàng)建，同時完成初始化细溅；

然后拷貝構(gòu)造函數(shù)把temp拷貝到保存返回值的外部存儲單元中褥傍；

最后，temp在函數(shù)結(jié)束時被銷毀（調(diào)用析構(gòu)函數(shù)）喇聊。

然而“創(chuàng)建一個臨時對象并返回它”的過程是不同的恍风，編譯器直接把臨時對象創(chuàng)建并初始化在外部存儲單元中，省去了拷貝和析構(gòu)的花費誓篱，提高了效率

88.下列程序的運行結(jié)果

const char *str="vermeer";

int main()

{const char *pstr=str;

cout<<pstr<<endl;}

vermeer

89.inline void max_out（int val1,int val2)

{ cout<<(val1>val2)?val1:val2;}

int main(){

int ix=10,jx=20;

cout<

cout<

max_out(ix,jx);}

<<優(yōu)先級大于朋贬？優(yōu)先級，所以輸出的是（val1>val2）

90.? int max(int *ia, int sz);

int max(int *,int =10);

算函數(shù)重載燕鸽？還是重復(fù)聲明兄世？

如果在兩個函數(shù)的參數(shù)表中只有缺省實參不同則第二個聲明被視為第一個的重復(fù)聲明。

e.編程練習(xí)（91-100）

91.被置1的位的個數(shù)啊研。

unsigned int One0(char log)

{

int? il

unsigned int num=0,val;

for(i=0;i<8;i++)

{val=log>>i;//移位

val &= 0x01;//與1相與

if(val) num++;}

return num;}

92.十六進制組成的字符串轉(zhuǎn)換成十進制數(shù)字并返回

bool HexToDec(char* shex,int& idec)

{

int i,mid;

int len = strlen(shex);

if(len>8) return false;

mid=0, idec=0;

for(i=0;i

{

if(shex[i]>='0' && shex[i]<='9')

mid = shex[i]-'0';

else if(shex[i]>='a'&&shex[i]<='f')

mid = shex[i]-'a'+10;

else if(shex[i]>='A'&&shex[i]<='F')

mid = shex[i]-'A'+10;

else

return false;

mid <<= ((len-i-1)<<2);//移位表示變?yōu)?的n次方倍

idec =idec+mid;

}

return true;

}

93.字符串逆序輸出

第一種：

void main()

{

char a[50];

memset(a,0,sizeof(a));

int i=0,j;

char t;

cin.geiline(a,50,'\n');

for(i=0,j=strlen(a)-1;i

{ t=a[i];a[i]=a[j];a[j]=t;}

}

第二種：

string str;

cin>>str;

str.replace;

cout<

94.編寫一個算法frequency御滩，統(tǒng)計在一個輸入字符串中各個不同字符出現(xiàn)的頻度。用適當(dāng)?shù)臏y試數(shù)據(jù)來驗證這個算法党远。

void frequency(string& s,char A[],int C[],int& k)

{

int i,j,len=s.length();

if(!len){cout<<"empty"<

else{

A[0]=s[0];C[0]=1;k=1; /*語句s[i]是串的重載操作*/

for(i=1;i

for(i=1;i

{ //檢測串中所有字符

j=0;while(j

if(j==k)

{A[k]=s[i];C[k]++;k++;}? //s[i]從未檢測過

else C[j]++; //s[i]已經(jīng)檢測過

}

}

}

95.假設(shè)以數(shù)組Q[m]存放循環(huán)隊列中的元素削解，同時以rear和length分別指示環(huán)形隊列中的隊尾位置和隊列中所含元素的個數(shù)。試給出該循環(huán)隊列的隊空條件和隊滿條件沟娱，并寫 出相應(yīng)的插入(enqueue)和刪除(dlqueue)元素的操作氛驮。

#include

template class Queue {? ? //循環(huán)隊列的類定義

public:

Queue ( int=10 );

~Queue ( ) { delete [ ] elements; }

void EnQueue ( Type & item );

Type DeQueue ( );

Type GetFront ( );

void MakeEmpty ( ) { length = 0; }? ? //置空隊列

int IsEmpty ( ) const { return length == 0; }? //判隊列空否

int IsFull ( ) const { return length == maxSize; }? //判隊列滿否

private:

int rear, length;? ? ? //隊尾指針和隊列長度

Type *elements;? ? ? //存放隊列元素的數(shù)組

int maxSize;? ? ? //隊列最大可容納元素個數(shù)

}

template

Queue:: Queue ( int sz ) : rear (maxSize-1), length (0), maxSize (sz) {

//建立一個最大具有maxSize個元素的空隊列。

elements = new Type[maxSize];? //創(chuàng)建隊列空間

assert ( elements != 0 );? ? //斷言: 動態(tài)存儲分配成功與否

}

template

void Queue :: EnQueue ( Type &item ) {

assert ( ! IsFull ( ) );? ? //判隊列是否不滿济似，滿則出錯處理

length++;? ? ? //長度加1

rear = ( rear +1) % maxSize;? //隊尾位置進1

elements[rear] = item;? ? //進隊列

}

template

Type Queue :: DeQueue ( ) {

assert ( ! IsEmpty ( ) );? ? //判斷隊列是否不空矫废，空則出錯處理

length--;? ? ? //隊列長度減1

return elements[(rear-length+maxSize) % maxSize];? //返回原隊頭元素值

}

讀取隊頭元素值函數(shù)

template

Type Queue :: GetFront ( ) {

assert ( ! IsEmpty ( ) );

return elements[(rear-length+1+maxSize) % maxSize];? //返回隊頭元素值

}

96.已知A[n]為整數(shù)數(shù)組，試寫出實現(xiàn)下列算法的遞歸算法：

(1) 求數(shù)組 A 中的最大整數(shù)砰蠢。

(2) 求 n 個整數(shù)的和蓖扑。

(3) 求 n 個整數(shù)的平均值。

#include

class RecurveArray? //數(shù)組類聲明

{

private:

int *Elements; //數(shù)組指針

int ArraySize; //數(shù)組尺寸

int CurrentSize; //當(dāng)前已有數(shù)組元素個數(shù)

public :

RecurveArray (int MaxSize =10 ) : ArraySize ( MaxSize ), Elements ( new int[MaxSize] ) { }

~RecurveArray ( )

{

delete [ ] Elements;

}

void InputArray(); //輸入數(shù)組的內(nèi)容

int MaxKey ( int n ); //求最大值

int Sum ( int n ); //求數(shù)組元素之和

float Average ( int n ); //求數(shù)組元素的平均值

};

void RecurveArray :: InputArray ( )? //輸入數(shù)組的內(nèi)容

{

cout << "Input the number of Array: \n";

for ( int i = 0; i < ArraySize; i++ )

cin >> Elements[i];

}

int RecurveArray :: MaxKey ( int n )? //遞歸求最大值

{

if ( n == 1 ) return Elements[0];

int temp = MaxKey ( n - 1 );

if ( Elements[n-1] > temp )

return Elements[n-1];

else return temp;

}

int RecurveArray :: Sum ( int n )

{

//遞歸求數(shù)組之和

if ( n == 1) return Elements[0];

else return Elements[n-1] + Sum (n-1);

}

float RecurveArray :: Average ( int n )

{

//遞歸求數(shù)組的平均值

if ( n == 1) return (float) Elements[0];

else return ( (float) Elements[n-1] + ( n - 1) * Average ( n - 1 ) ) / n;

}

int main ( int argc, char* argv [ ] )

{

int size = -1;

cout << "No. of the Elements : ";

while ( size < 1 ) cin >> size;

RecurveArray ra ( size );

ra.InputArray();

cout<< "\nThe max is: " << ra.MaxKey ( ra.MaxSize ) << endl;

cout<< "\nThe sum is: " << ra.Sum ( ra.MaxSize ) << endl;

cout<< "\nthe avr is: " << ra.Average ( ra.MaxSize ) << endl;

return 0;

}

97.已知f為單鏈表的表頭指針台舱，鏈表中存儲的都是整型數(shù)據(jù)律杠，試寫出實現(xiàn)下列運算的遞歸算法：

#include //定義在頭文件中

class List;

class ListNode? //鏈表結(jié)點類

{

friend class List;

private:

int data; //結(jié)點數(shù)據(jù)

ListNode *link; //結(jié)點指針

ListNode ( const int item ) : data(item), link(NULL) { } //構(gòu)造函數(shù)

};

class List? //鏈表類

{

private:

ListNode *first, current;

int Max ( ListNode *f );

int Num ( ListNode *f );

float Avg ( ListNode *f, int& n );

public:

List ( ) : first(NULL), current (NULL) { } //構(gòu)造函數(shù)

~List ( ) { } //析構(gòu)函數(shù)

ListNode* NewNode ( const int item ); //創(chuàng)建鏈表結(jié)點, 其值為

item void NewList ( const int retvalue ); //建立鏈表, 以輸入 retvalue 結(jié)束

void PrintList ( ); //輸出鏈表所有結(jié)點數(shù)據(jù)

int GetMax ( )

{

return Max ( first );? ? //求鏈表所有數(shù)據(jù)的最大值

}

int GetNum ( )

{

return Num ( first );? ? //求鏈表中數(shù)據(jù)個數(shù)

}

float GetAvg ( )

{

return Avg ( first );? ? //求鏈表所有數(shù)據(jù)的平均值

}

};

ListNode* List :: NewNode ( const int item )? //創(chuàng)建新鏈表結(jié)點

{

ListNode *newnode = new ListNode (item);

return newnode;

}

void List :: NewList ( const int retvalue )? //建立鏈表, 以輸入 retvalue 結(jié)束

{

first = NULL;

int value;

ListNode *q;

cout <<"Input your data:\n"; //提示

cin >>value; //輸入

while ( value != retvalue )? //輸入有效

{

q = NewNode ( value ); //建立包含 value 的新結(jié)點

if ( first == NULL ) first = current = q; //空表時, 新結(jié)點成為鏈表第一個結(jié)點

else

{

current-> link = q; //非空表時, 新結(jié)點鏈入鏈尾

current = q;

}

cin >>value; //再輸入

}

current->link = NULL; //鏈尾封閉

}

void List :: PrintList ( )? //輸出鏈表

{

cout<< "\nThe List is :\n";

ListNode *p = first;

while ( p != NULL )

{

cout <data << ' ';

p = p->link;

}

cout <<'\n';

}

int List :: Max ( ListNode *f )? //遞歸算法 : 求鏈表中的最大值

if ( f -> link == NULL ) return f -> data; //遞歸結(jié)束條件

int temp = Max ( f -> link ); //在當(dāng)前結(jié)點的后繼鏈表中求最大值

if ( f -> data > temp ) return f ->data; //如果當(dāng)前結(jié)點的值還要大, 返回當(dāng)前檢點值

else return temp; //否則返回后繼鏈表中的最大值

} int List :: Num ( ListNode *f )? //遞歸算法 : 求鏈表中結(jié)點個數(shù)

{

if ( f == NULL ) return 0; //空表, 返回 0

return 1+ Num ( f -> link ); //否則, 返回后繼鏈表結(jié)點個數(shù)加 1

}

float List :: Avg ( ListNode *f , int& n )? //遞歸算法 : 求鏈表中所有元素的平均值

{

if ( f -> link == NULL ) //鏈表中只有一個結(jié)點, 遞歸結(jié)束條件

{

n = 1;

return ( float ) (f -> data );

}

else

{

float Sum = Avg ( f -> link, n ) * n;

n++;

return ( f -> data + Sum ) / n;

}

}

#include "RecurveList.h" //定義在主文件中

int main ( int argc, char* argv[ ] )

{

List test;

int finished;

cout <<"輸入建表結(jié)束標志數(shù)據(jù) ： ";

cin >> finished; //輸入建表結(jié)束標志數(shù)據(jù)

{

test.NewList ( finished ); //建立鏈表

test.PrintList ( ); //打印鏈表

cout <<"\nThe Max is :"<

cout <<"\nThe Num is :"<

cout <<"\nThe Ave is :"<

printf ( "Hello World!\n" );

return 0;

}

}

98.字符串的替換操作replace (String &s, String &t, String &v)是指：

若t是s的子串，則用串v替換串t在串s中的所有出現(xiàn)竞惋；若t不是s的子串柜去，則串s不變。例如拆宛，若串s為“aabbabcbaabaaacbab”嗓奢，串t為“bab”，串v為“abdc”浑厚，則執(zhí)行replace操作后蔓罚，串s中的結(jié)果為“aababdccbaabaaacabdc”椿肩。試利用字符串的基本運算實現(xiàn)這個替換操作。

String & String :: Replace ( String & t, String &v)

{

if ( ( int id = Find ( t ) ) == -1 ) //沒有找到豺谈，當(dāng)前字符串不改郑象，返回

{

cout << "The (replace) operation failed." << endl;

return *this;

}

String temp( ch ); //用當(dāng)前串建立一個空的臨時字符串

ch[0] = '\0';

curLen = 0; //當(dāng)前串作為結(jié)果串，初始為空

int j, k = 0, l; //存放結(jié)果串的指針

while ( id != -1 )

{

for ( j = 0; j < id; j++) ch[k++] = temp.ch[j];

curLen += id + v.curLen; //修改結(jié)果串連接后的長度

if ( curLen <= maxLen ) l = v.curLen; //確定替換串v傳送字符數(shù)l

else

{

l = curLen - maxLen;

curLen = maxLen;

}

for ( j = 0; j < l; j++ ) ch[k++] = v.ch[j]; //連接替換串v到結(jié)果串ch后面

if ( curLen == maxLen ) break; //字符串超出范圍

for ( j = id + t.curLen; j < temp.curLen; j++ )

temp.ch[j- id - t.curLen] = temp.ch[j]; //刪改原來的字符串

temp.curLen -= ( id + t.curLen );

id = temp.Find ( t );

}

return *this;

}

99.試編寫一個求解Josephus問題的函數(shù)茬末。用整數(shù)序列1, 2, 3, ……, n表示順序圍坐在圓桌周圍的人厂榛，并采用數(shù)組表示作為求解過程中使用的數(shù)據(jù)結(jié)構(gòu)。然后使用n = 9, s = 1, m = 5丽惭，以及n = 9, s = 1, m = 0击奶，或者n = 9, s = 1, m = 10作為輸入數(shù)據(jù)，檢查你的程序的正確性和健壯性责掏。

void Josephus( int A[ ], int n, s, m )

{

int i, j, k, tmp;

if ( m == 0 )

{

cout << "m = 0是無效的參數(shù)柜砾！" << endl;

return;

}

for ( i = 0; i < n; i++ ) A[i] = i + 1; /*初始化，執(zhí)行n次*/

i = s - 1; /*報名起始位置*/

for ( k = n; k > 1; i-- ){/*逐個出局换衬，執(zhí)行n-1次*/

if ( i == k ) i = 0;

i = ( i + m - 1 ) % k; /*尋找出局位置*/

if ( i != k-1 )

{

tmp = A[i]; /*出局者交換到第k-1位置*/

for ( j = i; j < k-1; j++ ) A[j] = A[j+1];

A[k-1] = tmp;

}

}

for ( k = 0; k < n / 2; k++ ){/*全部逆置, 得到出局序列*/

tmp = A[k];

A[k] = A[n-k+1];

A[n-k+1] = tmp;

}

}

100.class String

{

public:

String(const char *str = NULL); // 普通構(gòu)造函數(shù)

String(const String &other); // 拷貝構(gòu)造函數(shù)

~ String(void); // 析構(gòu)函數(shù)

String & operate =(const String &other); // 賦值函數(shù)

private:

char *m_data; // 用于保存字符串

};

請編寫String的上述4個函數(shù)痰驱。

// String 的析構(gòu)函數(shù)

String::~String(void)

{

delete [] m_data;

// 由于m_data 是內(nèi)部數(shù)據(jù)類型，也可以寫成 delete m_data;

}

// String 的普通構(gòu)造函數(shù)

String::String(const char *str)

{

if(str==NULL)

{

m_data = new char[1]; // 若能加 NULL 判斷則更好

*m_data = ‘\0’;

}

else

{

int length = strlen(str);

m_data = new char[length+1]; // 若能加 NULL 判斷則更好

strcpy(m_data, str);

}

}

// 拷貝構(gòu)造函數(shù)

String::String(const String &other)

{

int length = strlen(other.m_data);

m_data = new char[length+1]; // 若能加 NULL 判斷則更好

strcpy(m_data, other.m_data);

}

// 賦值函數(shù)

String & String::operate =(const String &other)

{

// (1) 檢查自賦值

if(this == &other)

return *this;

// (2) 釋放原有的內(nèi)存資源

delete [] m_data;

// （3）分配新的內(nèi)存資源瞳浦，并復(fù)制內(nèi)容

int length = strlen(other.m_data);

m_data = new char[length+1]; // 若能加 NULL 判斷則更好

strcpy(m_data, other.m_data);

// （4）返回本對象的引用

return *this;

}