題目類(lèi)型
a.C++與C差異（1-18）
1.C和C++中struct有什么區(qū)別？
C沒(méi)有Protection行為，不能定義函數(shù)，但可以有函數(shù)指針。
C++有Protection行為，默認(rèn)是public（class默認(rèn)private），可以定義函數(shù)；
2.C++中的struct和class有什么區(qū)別？
struct可以class所有功能，本質(zhì)上是一個(gè)東西，struct成員和繼承默認(rèn)是public，class成員和繼承默認(rèn)是private。
3.如何判斷一個(gè)程序是由c編譯程序還是由C++編譯程序編譯的？
判斷：檢測(cè)宏
#ifdef __cpluspluc
cout<<"c++";
#else
printf("c“)；
#endif
4.C和C++有什么不同？
機(jī)制上：C面向過(guò)程的（但也可編寫(xiě)面向?qū)ο螅?；C++編寫(xiě)面向?qū)ο蟮某绦虮菴容易
適用的方向：c適合要求代碼體積小的，效率高的場(chǎng)合，如嵌入式；C++更適合上層的，復(fù)雜的
C語(yǔ)言是結(jié)構(gòu)化編程語(yǔ)言，C++是面向?qū)ο缶幊陶Z(yǔ)言。
C++側(cè)重于對(duì)象而不是過(guò)程，側(cè)重于類(lèi)的設(shè)計(jì)而不是邏輯的設(shè)計(jì)。
5.“引用”與指針的區(qū)別是什么？
指針通過(guò)某個(gè)指針變量指向一個(gè)對(duì)象后，對(duì)它所指向的變量間接操作。程序中使用指針，程序的可讀性差；而引用本身就是目標(biāo)變量的別名，對(duì)引用的操作就是對(duì)目標(biāo)變量的操作。
6.虛函數(shù)
虛函數(shù)是可以通過(guò)接口繼承的
7.int id[sizeof(unsigned long)];這個(gè)對(duì)嗎？
對(duì)
8.某文件定義靜態(tài)全局變量，他的作用域。
靜態(tài)全局變量只在源文件內(nèi)有效，避免引用出錯(cuò)。類(lèi)里面的靜態(tài)變量可以不用實(shí)例化。C++沒(méi)有靜態(tài)類(lèi)。
9.C++值的傳遞
三種：值傳遞，指針傳遞，引用傳遞
10.頻繁使用的短小函數(shù)，C語(yǔ)言和C++？
C用宏定義#define，C++用inline函數(shù)（一般函數(shù)浪費(fèi)的是調(diào)用和返回的時(shí)間）
11.引用和指針的差別？
引用須被初始化，指針不必。（C++11引用是可以改變的）
引用初始化不能被改變，但指針可以改變所指對(duì)象。
不存在指向空值的引用，但是存在指向空值的指針。
12.virtual與inline的含義分別是什么？
virtual意味著聲明為虛函數(shù)，inline與函數(shù)定義體放在一起，使該函數(shù)稱(chēng)為內(nèi)聯(lián)。inline是一種用于實(shí)現(xiàn)的關(guān)鍵字，而不是用于聲明的關(guān)鍵字。
虛函數(shù)的特點(diǎn)：如果希望派生類(lèi)能夠重新定義基類(lèi)的方法，則在基類(lèi)中將該方法定義為虛方法，這樣可以啟用動(dòng)態(tài)聯(lián)編。（多繼承下只產(chǎn)生一個(gè)虛基類(lèi)）
動(dòng)態(tài)聯(lián)編 和 靜態(tài)聯(lián)編
http://blog.csdn.net/gaoxin1076/article/details/8298279
內(nèi)聯(lián)函數(shù)的特點(diǎn)：使用內(nèi)聯(lián)函數(shù)的目的是為了提高函數(shù)的運(yùn)行效率。
內(nèi)聯(lián)函數(shù)體的代碼不能過(guò)長(zhǎng)，因?yàn)閮?nèi)聯(lián)函數(shù)省去調(diào)用函數(shù)的時(shí)間是以代碼膨脹為代價(jià)的。
內(nèi)聯(lián)函數(shù)不能包含循環(huán)語(yǔ)句，因?yàn)閳?zhí)行循環(huán)語(yǔ)句要比調(diào)用函數(shù)的開(kāi)銷(xiāo)大。
13.VC中,編譯工具Debug與Release選項(xiàng)是什么含義?
Debug通常稱(chēng)為調(diào)試版本,包含調(diào)試信息,不做優(yōu)化，便于程序員調(diào)試進(jìn)程。Release稱(chēng)為發(fā)布版本，它往往是進(jìn)行了各種優(yōu)化，使得程序在代碼大小和運(yùn)行速度上都是最優(yōu)的，以便用戶(hù)很好地使用。Debug帶有大量的挑調(diào)試代碼和信息，運(yùn)行需要相應(yīng)的庫(kù)，發(fā)布模式程序緊湊不含有調(diào)試代碼和信息，可以直接運(yùn)行（不需要運(yùn)行庫(kù)）。
14.函數(shù)assert的用法？
斷言assert是僅在debug版本起作用的宏，用于檢查“不應(yīng)該”發(fā)生的情況。程序員可以把a(bǔ)ssert看成是一個(gè)任何系統(tǒng)狀態(tài)下都可以安全使用的無(wú)害測(cè)試手段。
15.const與#define的比較，const有什么優(yōu)點(diǎn)？
const常量有數(shù)據(jù)類(lèi)型（定義不讀內(nèi)存），而宏常量沒(méi)有數(shù)據(jù)類(lèi)型，編譯器可以對(duì)前者進(jìn)行類(lèi)型安全檢查。而對(duì)后者只進(jìn)行字符替換，沒(méi)有類(lèi)型安全檢查，并且在字符替換可能會(huì)產(chǎn)生意料不到的錯(cuò)誤（邊際效應(yīng)）
有些集成化的調(diào)試工具可以對(duì)const常量進(jìn)行調(diào)試，但是不能對(duì)宏常量進(jìn)行調(diào)試。
16.談?wù)勔煤椭羔樀膮^(qū)別：
引用被創(chuàng)建的同時(shí)必須被初始化（指針可以在任何時(shí)候初始化）
不能有NULL引用，左值引用必須與合法的存儲(chǔ)單元關(guān)聯(lián)（指針可以是NULL）內(nèi)存，右值引用引用寄存器。
一旦引用被初始化，就不能改變引用的關(guān)系（指針可以隨時(shí)改變所指的對(duì)象）
17.有了malloc/free為什么還要new/delete?
malloc/free是C/C++語(yǔ)言的標(biāo)準(zhǔn)函數(shù)庫(kù)，new/delete是C++ 的運(yùn)算符，它們都可以申請(qǐng)動(dòng)態(tài)內(nèi)存和釋放內(nèi)存。
由于對(duì)象在創(chuàng)建的同時(shí)要自動(dòng)執(zhí)行構(gòu)造函數(shù)，消亡之前要自動(dòng)執(zhí)行析構(gòu)函數(shù)，因?yàn)閙alloc/free是庫(kù)函數(shù)而不是運(yùn)算符，不在編譯器的控制權(quán)之內(nèi)，不能把任務(wù)強(qiáng)加于malloc/free。因此需要一個(gè)能完成動(dòng)態(tài)內(nèi)存分配和初始化的運(yùn)算符new，以及一個(gè)能清理和釋放內(nèi)存工作的運(yùn)算符delete。
new可以把內(nèi)存開(kāi)在靜態(tài)區(qū)，防止內(nèi)存泄漏。
18.如果再申請(qǐng)動(dòng)態(tài)內(nèi)存找不到足夠大的內(nèi)存塊，malloc和new將返回NULL指針，宣告內(nèi)存申請(qǐng)失敗。你是怎么處理內(nèi)存耗盡的？
判斷指針是否為NULL，是則馬上return語(yǔ)句終止函數(shù)
判斷指針是否為NULL，是則馬上用exit(1)終止程序運(yùn)行
為new和malloc設(shè)置異常處理函數(shù)。 例如Visual C++可以用_set_new_hander函數(shù)為new設(shè)置用戶(hù)自己定義的異常處理函數(shù)，也可以讓malloc享用與new 相同的異常處理函數(shù)。
#include big *p; p = new(std::nothrow) big[1000];
b.數(shù)據(jù)類(lèi)型、關(guān)鍵字（19-37）
19.C++是不是類(lèi)型安全的？
不是，兩個(gè)不同類(lèi)型的指針是可以強(qiáng)制轉(zhuǎn)換的（用reinterpret cast）
20.const符號(hào)常量（1）const char *p（2）char const *p（3）char * const p 區(qū)別
（1）p是一個(gè)指向const char 的指針，p是可以改變指向的，但是p指向的值時(shí)不能改變的。
（2）p指向的恰好是一個(gè)指向const的char的普通指針。
（3）p是一個(gè)指針，這個(gè)指針是指向char的const指針，
（1）和（2）的定義是一樣的，*左邊值不能改變，*右邊指針不能改變
21.用C++寫(xiě)個(gè)程序，如何判斷一個(gè)操作系統(tǒng)是16位、32位？
定義一個(gè)指針，sizeof（p），4是32位，2是16位，如果64位系統(tǒng)兼容32位的話(huà)也是4字節(jié)
22.用C++寫(xiě)個(gè)程序，如何判斷一個(gè)操作系統(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是一個(gè)指針，指向一個(gè)函數(shù)，這個(gè)函數(shù)的參數(shù)為int型，函數(shù)的返回值是一個(gè)指針，這個(gè)指針指向一個(gè)數(shù)組，這個(gè)數(shù)組有10個(gè)元素，每個(gè)元素是一個(gè)void*型指針。
(2)float(*(* fp2)(int,int,int))(int); fp2是一個(gè)指針，指向一個(gè)函數(shù)，這個(gè)函數(shù)的參數(shù)為3個(gè)int型，函數(shù)的返回值是一個(gè)指針，這個(gè)指針指向一個(gè)函數(shù)，這個(gè)函數(shù)的參數(shù)為int型，函數(shù)的返回值是float型。
(3)int(*(*fp3)())[10]();fp3是一個(gè)指針，指向一個(gè)函數(shù)，這個(gè)函數(shù)的參數(shù)為空，函數(shù)的返回值是一個(gè)指針，這個(gè)指針指向一個(gè)數(shù)組，這個(gè)數(shù)組有10個(gè)元素，每個(gè)元素是一個(gè)指針，指向一個(gè)函數(shù)，這個(gè)參數(shù)為空，函數(shù)的返回值是int型。
24.多態(tài)類(lèi)中的虛函數(shù)表示Compile-Time，還是Run-Time時(shí)建立的？
虛擬函數(shù)表是在編譯期就建立了，各個(gè)虛擬函數(shù)這時(shí)被組織成了一個(gè)虛擬函數(shù)的入口地址的數(shù)組。而對(duì)象的隱藏成員--虛擬函數(shù)表指針是在運(yùn)行期--也就是構(gòu)造函數(shù)被調(diào)用時(shí)進(jìn)行初始化，這是實(shí)現(xiàn)多態(tài)的關(guān)鍵。（動(dòng)態(tài)聯(lián)編）
25.錯(cuò)誤的轉(zhuǎn)義字符'\091'八進(jìn)制不能有9
26。數(shù)組名做實(shí)參，指針變量做形參，傳數(shù)組名傳過(guò)去的是數(shù)組的第一個(gè)元素地址
27.變量的指針指的是變量的地址
28.內(nèi)存的分配方式有幾種？
在四個(gè)地方分配內(nèi)存1.靜態(tài)存儲(chǔ)區(qū)域。2.棧上創(chuàng)建。3.堆上動(dòng)態(tài)內(nèi)存分配。4.代碼區(qū)
a從靜態(tài)存儲(chǔ)區(qū)分配。內(nèi)存在程序編譯的時(shí)候就已經(jīng)分配好，這塊內(nèi)存在程序的整個(gè)運(yùn)行期間都存在。例如全局變量。
b在棧上創(chuàng)建。在執(zhí)行函數(shù)時(shí)，函數(shù)內(nèi)部局部變量的存儲(chǔ)單元都可以在棧上創(chuàng)建，，函數(shù)執(zhí)行結(jié)束時(shí)這些存儲(chǔ)單元自動(dòng)被釋放。棧內(nèi)存分配運(yùn)算內(nèi)置于處理器的指令集中，效率很高，但是分配的內(nèi)存容量有限。
c在堆上分配，亦稱(chēng)動(dòng)態(tài)內(nèi)存分配。程序在運(yùn)行的時(shí)候用malloc或new申請(qǐng)任意多少的內(nèi)存，程序員自己負(fù)責(zé)在何時(shí)用free或delete釋放內(nèi)存。動(dòng)態(tài)內(nèi)存的生存期由我們決定，使用非常靈活，但問(wèn)題也多。
棧連續(xù)，堆不連續(xù)（鏈表）
29.float a,b,c,問(wèn)等式(a+b)+c==(b+a)+c 和 (a+b)+c==(a+c)+b能否成立？
兩者都不行。在比較float或double時(shí)，不能簡(jiǎn)單地比較。由于計(jì)算誤差，相等的概率很低。應(yīng)判斷兩數(shù)之差是否落在區(qū)間(-e,e)內(nèi)。這個(gè)e應(yīng)比浮點(diǎn)數(shù)的精度大一個(gè)數(shù)量級(jí)。
30.全局變量和局部變量有什么區(qū)別？是怎么實(shí)現(xiàn)的？操作系統(tǒng)和編譯器是怎么知道的？
生命周期不同：全局變量隨主程序創(chuàng)建而創(chuàng)建，隨主程序的銷(xiāo)毀而銷(xiāo)毀；
局部變量在局部函數(shù)內(nèi)，甚至局部循環(huán)體等內(nèi)部存在，退出就不存在；
內(nèi)存中分配在全局?jǐn)?shù)據(jù)區(qū)
使用方式不同：通過(guò)聲明后全局變量程序的各個(gè)部分都可以用到；
局部變量只能在局部使用；
分配在棧區(qū)。
操作系統(tǒng)和編譯器通過(guò)內(nèi)存分配的位置來(lái)知道的，
全局變量分配在全局?jǐn)?shù)據(jù)段并且在程序開(kāi)始運(yùn)行的時(shí)候被加載。
局部變量則分配在堆棧里面。
31.Heap與Stack 的差別
Heap是堆，Stack是棧（高效地節(jié)約內(nèi)存，用完就馬上釋放）。
Stack的空間由操作系統(tǒng)自動(dòng)分配/釋放，Heap上的空間手動(dòng)分配/釋放
Stack空間有限，Heap是很大的只有存儲(chǔ)區(qū)
C中的malloc函數(shù)分配的內(nèi)存空間即在堆上，C++中對(duì)應(yīng)的是new操作符
程序在編譯期對(duì)變量和函數(shù) 分配內(nèi)存都在棧上進(jìn)行，且程序運(yùn)行過(guò)程中函數(shù)調(diào)用時(shí)參數(shù)的傳遞也在棧上進(jìn)行。
32.explict protected
explict關(guān)鍵字用來(lái)修飾類(lèi)的構(gòu)造函數(shù)，表明該構(gòu)造函數(shù)是顯式的，在某些情況下，我們要求類(lèi)的使用者必須顯示調(diào)用類(lèi)的構(gòu)造函數(shù)時(shí)就需要使用explicit，反之默認(rèn)類(lèi)型轉(zhuǎn)換可能會(huì)造成無(wú)法預(yù)期的問(wèn)題。
protected控制的是一個(gè)函數(shù)對(duì)一個(gè)類(lèi)的成員（包括成員變量及成員方法）的訪(fǎng)問(wèn)權(quán)限。protected成員只有該類(lèi)的成員函數(shù)及其派生類(lèi)的成員可以訪(fǎng)問(wèn)。
33.重復(fù)多次fclose一個(gè)打開(kāi)過(guò)一次的FILE *fp指針會(huì)有什么后果，解釋
考察點(diǎn)：導(dǎo)致文件描述符結(jié)構(gòu)中指針指向的內(nèi)存被重復(fù)釋放，進(jìn)而導(dǎo)致一些不可預(yù)期的異常。
34.為什么數(shù)組名作為參數(shù)，會(huì)改變數(shù)組的內(nèi)容，而其他類(lèi)型如int卻不會(huì)改變變量的值？
數(shù)組名為參數(shù)時(shí)，傳遞的實(shí)際上是地址。而其他類(lèi)型如int作為參數(shù)時(shí)，由于函數(shù)參數(shù)值實(shí)質(zhì)上是實(shí)參的一份拷貝，被調(diào)函數(shù)內(nèi)部對(duì)形參的改變并不影響實(shí)參的值。
35.你覺(jué)得如果不使用常量，直接在程序中填寫(xiě)數(shù)字或字符串，將會(huì)有什么麻煩？
（1）程序的可讀性（可理解性）變差。程序員自己會(huì)忘記那些數(shù)字或字符串是什么意思，用戶(hù)則更加不知它們從何處來(lái)、表示什么。
（2）在程序的很多地方輸入同樣的數(shù)字或字符串，難保不發(fā)生書(shū)寫(xiě)錯(cuò)誤。
（3）如果要修改數(shù)字或字符串，則會(huì)在很多地方改動(dòng)，既麻煩又容易出錯(cuò)。
36.為什么需要使用堆，使用堆空間的原因？
直到運(yùn)行時(shí)才知道一個(gè)對(duì)象需要多少內(nèi)存空間；不知道對(duì)象的生存期到底有多長(zhǎng)。
37.const關(guān)鍵字？有哪些作用？
（1）欲阻止一個(gè)變量被改變，可以使用const關(guān)鍵字。在定義該const變量時(shí)，通常需要對(duì)它進(jìn)行初始化，因?yàn)橐院缶蜎](méi)有機(jī)會(huì)再去改變它了；
（2）對(duì)指針來(lái)說(shuō)，可以指定指針本身為const，也可以指定指針?biāo)傅臄?shù)據(jù)為const，或二者同時(shí)指定為const；
（3）在一個(gè)函數(shù)聲明中，const可以修飾形參，表明它是一個(gè)輸入?yún)?shù)，在函數(shù)內(nèi)部不能改變其值；（4）對(duì)于類(lèi)的成員函數(shù)，若指定其為const類(lèi)型，則表明其實(shí)一個(gè)常函數(shù)，不能修改類(lèi)的成員變量；
（5）對(duì)于類(lèi)的成員函數(shù)，有時(shí)候必須指定其返回值為const類(lèi)型，以使得其返回值不為“左值”。
c.面型對(duì)象的特性（38-61）
38.是不是一個(gè)父類(lèi)寫(xiě)了一個(gè)virtual函數(shù)，如果子類(lèi)覆蓋它的函數(shù)不加virtual，也能實(shí)現(xiàn)多態(tài)？
virtual修飾符會(huì)被隱形繼承的。virtual可加不可加。子類(lèi)的空間里有父類(lèi)的所有變量（static除外）。同一個(gè)函數(shù)只存在一個(gè)實(shí)體（inline除外）。子類(lèi)覆蓋它的函數(shù)不加virtual，也能實(shí)現(xiàn)多態(tài)。在子類(lèi)的空間里，有父類(lèi)的私有變量。私有變量不能直接訪(fǎng)問(wèn)。
39.面向?qū)ο蟮娜齻€(gè)基本特征，并簡(jiǎn)單敘述？
（1）封裝：將客觀(guān)事物抽象成類(lèi)，每個(gè)類(lèi)對(duì)自身的數(shù)據(jù)和方法實(shí)行protection（private，protected，public）
（2）繼承：廣義的繼承有三種形式：實(shí)現(xiàn)繼承（指使用基類(lèi)的屬性和方法而無(wú)需額外編碼的能力）、可視繼承（子窗體使用父窗體的外觀(guān)和實(shí)現(xiàn)代碼）、接口繼承（僅使用屬性和方法，實(shí)現(xiàn)滯后到子類(lèi)實(shí)現(xiàn)）。
前兩種（類(lèi)繼承）和后一種（對(duì)象組合=>接口繼承以及純虛函數(shù)）構(gòu)成了功能復(fù)用的兩種方式。
（3）多態(tài)：是將父對(duì)象設(shè)置成為和一個(gè)或更多的與他的子對(duì)象的特性以不同的方式運(yùn)作。簡(jiǎn)單的說(shuō)，就是一句話(huà)：允許將子類(lèi)類(lèi)型的指針賦值給父類(lèi)類(lèi)型的指針。
40.重載（overload）、重寫(xiě)（override，有的叫覆蓋）、重定義（redefinition）的區(qū)別？
名稱(chēng)名字空間區(qū)別
重載同一名字空間是指允許存在多個(gè)同名函數(shù)，而這些函數(shù)的參數(shù)表不同
重定義/隱藏不同名字空間用于繼承，派生類(lèi)與基類(lèi)的函數(shù)同名，屏蔽基類(lèi)的函數(shù)
重寫(xiě)/覆蓋不同名字空間用于繼承，子類(lèi)重新定義父類(lèi)虛函數(shù)的方法
41.多態(tài)的作用？
主要的是兩個(gè)：
（1）隱藏實(shí)現(xiàn)細(xì)節(jié)，使得代碼能夠模塊化；擴(kuò)展代碼模塊，實(shí)現(xiàn)代碼重用；
（2）接口重用：為了類(lèi)在繼承和派生的時(shí)候，保證使用家族中任一類(lèi)的實(shí)例的某一屬性時(shí)的正確調(diào)用。
42.當(dāng)一個(gè)類(lèi)A中沒(méi)有聲明任何成員變量與成員函數(shù)，這時(shí)sizeof（A）的值時(shí)多少？如果不是零，請(qǐng)解釋一下編譯器為什么沒(méi)有讓它為零？
sizeof（A）=1
一個(gè)空類(lèi)對(duì)象的大小是1byte。這是被編譯器安插進(jìn)去的一個(gè)字節(jié),這樣就使得這個(gè)空類(lèi)的兩個(gè)實(shí)例得以在內(nèi)存中配置獨(dú)一無(wú)二的地址。
43.如果ClassA中定義并實(shí)現(xiàn)虛函數(shù)int func(void),ClassB中也實(shí)現(xiàn)該函數(shù)，那么上述變量a->func()將調(diào)用哪個(gè)類(lèi)里面的函數(shù)？如果int func(void)不是虛函數(shù)，情況又如何？為什么？
第一問(wèn)是調(diào)用B的。第二問(wèn)是調(diào)用A的。虛函數(shù)的一個(gè)典型應(yīng)用，虛函數(shù)只能借助于指針或者引用來(lái)達(dá)到多態(tài)的效果
44.C++里面是不是所有的動(dòng)作都是main（）函數(shù)引起的？如果不是請(qǐng)舉例
class A{};
A a; //a的構(gòu)造函數(shù)限執(zhí)行
int main(){}
45.內(nèi)聯(lián)函數(shù)在編譯的時(shí)候是否做參數(shù)類(lèi)型檢查？
內(nèi)聯(lián)函數(shù)要做參數(shù)類(lèi)型檢查，這是內(nèi)聯(lián)函數(shù)跟宏相比的優(yōu)勢(shì)。
46.講一講析構(gòu)函數(shù)和虛函數(shù)的用法和作用？
析構(gòu)函數(shù)是特殊的類(lèi)成員函數(shù)，它沒(méi)有返回類(lèi)型，沒(méi)有參數(shù)，不能隨意調(diào)用，也沒(méi)有重載，只有在類(lèi)對(duì)象的生命期結(jié)束的時(shí)候，系統(tǒng)自動(dòng)調(diào)用。有釋放內(nèi)存空間的作用。（析構(gòu)函數(shù)可以是虛函數(shù)，構(gòu)造函數(shù)不行）
虛函數(shù)是C++多態(tài)的一種表現(xiàn)，使用虛函數(shù)，我們可以靈活的進(jìn)行動(dòng)態(tài)綁定，當(dāng)然是以一定的開(kāi)銷(xiāo)為代價(jià)。
47.“new" in C++ is a: operator
malloc是庫(kù)函數(shù)，不在編譯器的控制范圍之內(nèi)；
new是運(yùn)算符，從堆中申請(qǐng)內(nèi)存；調(diào)用new時(shí)，從堆中申請(qǐng)內(nèi)存并為內(nèi)存調(diào)用構(gòu)造函數(shù)。
48. 對(duì)于C++中類(lèi)（class）與結(jié)構(gòu)（struct）的描述正確的為：
D 結(jié)構(gòu)和類(lèi)對(duì)象都可以用new創(chuàng)建
49.類(lèi)內(nèi)部成員函數(shù)可以用private函數(shù)。
50.A對(duì)調(diào)用的虛函數(shù)和模板類(lèi)都進(jìn)行遲后編譯，調(diào)用需要時(shí)間
B virtual，派生類(lèi)必須要求名字相同，參數(shù)類(lèi)型相同，但是返回類(lèi)型可以不同
C inline內(nèi)聯(lián)函數(shù)可以是虛函數(shù)。靜態(tài)成員函數(shù)不能是虛函數(shù)（因?yàn)椴恍枰獙?shí)例化就可以調(diào)用），友元函數(shù)，構(gòu)造函數(shù)不能是虛函數(shù)，析構(gòu)函數(shù)可以。
51.C++中有沒(méi)有純虛構(gòu)造函數(shù)？
構(gòu)造函數(shù)不能是虛的，只能有虛的析構(gòu)函數(shù)。
52.throw表達(dá)式
（1）class? exception Type{};
throw exception Type();//函數(shù)需要括號(hào)
（2）enum mathErr { overflow, underflow, zeroDivide };
throw zeroDivide;//枚舉不需要括號(hào)
53.談?wù)勀阍趺凑J(rèn)識(shí)C++ 的模板的？
模板使程序員能夠快速建立具有類(lèi)型安全的類(lèi)庫(kù)集合和函數(shù)集合，它的實(shí)現(xiàn)，方便了大規(guī)模的軟件開(kāi)發(fā)。（結(jié)合stl更好）
54.在C++的一個(gè)類(lèi)中聲明一個(gè)static成員變量有沒(méi)有用？
在C++類(lèi)的成員變量被聲明為static（稱(chēng)為靜態(tài)成員變量），意味著它為該類(lèi)的所有實(shí)例所共享，也就是說(shuō)當(dāng)某個(gè)類(lèi)的實(shí)例修改了該靜態(tài)成員變量，也就是說(shuō)不管創(chuàng)建多少對(duì)象，static修飾的變量只占有一塊內(nèi)存。其修改值為該類(lèi)的其他所有實(shí)例所見(jiàn)；而類(lèi)的靜態(tài)成員 函數(shù)也只能訪(fǎng)問(wèn)靜態(tài)成員（變量或函數(shù)）。static是加了訪(fǎng)問(wèn)控制的全局變量，不被繼承。
55.C++中為什么要用模板類(lèi)。
（1）可用來(lái)創(chuàng)建動(dòng)態(tài)增長(zhǎng)和減小的數(shù)據(jù)結(jié)構(gòu).
（2）它是類(lèi)型無(wú)關(guān)的，因此具有很高的可復(fù)用性。
（3）它在編譯時(shí)而不是運(yùn)行時(shí)檢查數(shù)據(jù)類(lèi)型，保證了類(lèi)型安全
（4）它是平臺(tái)無(wú)關(guān)的，可移植性
（5）可用于基本數(shù)據(jù)類(lèi)型
56.函數(shù)模板與類(lèi)模板有什么區(qū)別？聯(lián)系？
函數(shù)模板的實(shí)例化是由編譯程序在處理函數(shù)調(diào)用時(shí)自動(dòng)完成的
類(lèi)模板的實(shí)例化必須由程序員在程序中顯示地指定
57.
58.談?wù)?在類(lèi)中如何使用const的？
有時(shí)我們希望某些常量只在類(lèi)中有效。由于#define定義的宏常量是全局的，不能達(dá)到目的，于是想當(dāng)然地覺(jué)得應(yīng)該用const修飾數(shù)據(jù)成員來(lái)實(shí)現(xiàn)。const數(shù)據(jù)成員的確是存在的，但其含義卻不是我們所期望的。const數(shù)據(jù)成員只在某個(gè)對(duì)象生存期內(nèi)是常量，而對(duì)于整個(gè)類(lèi)而言卻是可變的，因?yàn)轭?lèi)可以創(chuàng)建多個(gè)對(duì)象，不同的對(duì)象其const數(shù)據(jù)成員的值可以不同。不能在類(lèi)聲明中初始化const數(shù)據(jù)成員。
const數(shù)據(jù)成員的初始化只能在類(lèi)構(gòu)造函數(shù)的初始化表中進(jìn)行。
59.函數(shù)重載，靠什么來(lái)區(qū)分調(diào)用的哪個(gè)函數(shù)，靠返回值判斷可以不可以？
如果同名函數(shù)的參數(shù)不同（包括類(lèi)型、順序不同），那么容易區(qū)別出它們是不同的。如果同名函數(shù)僅僅是返回值類(lèi)型不同，有時(shí)可以區(qū)分，有時(shí)卻不能，例如：
void func（void）；與int func（void）；
C/C++程序中，可以忽略函數(shù)的返回值，但是這種情況下，編譯器和程序員都不知道哪個(gè)func函數(shù)被調(diào)用，所以只能靠參數(shù)而不能靠返回值類(lèi)型的不同來(lái)區(qū)分重載函數(shù)。
60.所有運(yùn)算符都能重載嗎？
有一些不行。這種限制是出于安全方面的考慮，可防止錯(cuò)誤和混亂。
（1）不能改變C++內(nèi)部數(shù)據(jù)類(lèi)型（如int，float等）的運(yùn)算符。
（2）不能重載'.'，因?yàn)?.'在類(lèi)中對(duì)任何成員都有意義，已經(jīng)成為標(biāo)準(zhǔn)用法。
（3）不能重載目前C++運(yùn)算符集合中沒(méi)有的符號(hào)，如#，@，$等。
原因有兩點(diǎn)，一是難以理解，二是難以確定優(yōu)先級(jí)。
（4）對(duì)已經(jīng)存在的運(yùn)算符進(jìn)行重載時(shí)，不能改變優(yōu)先級(jí)規(guī)則，否則將引起混亂。
61.基類(lèi)的析構(gòu)函數(shù)不是虛函數(shù)，會(huì)帶來(lái)什么問(wèn)題？
派生類(lèi)的西溝函數(shù)用不上，會(huì)造成資源的泄漏。
d.程序閱讀題（62-90）
62.main函數(shù)執(zhí)行以前，還會(huì)執(zhí)行什么代碼？
全局對(duì)象的構(gòu)造函數(shù)會(huì)在main函數(shù)之前執(zhí)行
63.不使用判斷，找出a和b中最大值。
((a+b)+abs(a-b))/2
64.如何打印出當(dāng)前源文件的文件名以及源文件的當(dāng)前行號(hào)？
cout << __FILE__;
cout << __LINE__;
__FILE__和__LINE__是由系統(tǒng)預(yù)定義宏，這種宏并不是在某個(gè)文件中定義的，而是由編譯器定義的。（C也有）
65下面有兩種if語(yǔ)句判斷方式。請(qǐng)問(wèn)哪種寫(xiě)法更好？為什么？
int n;
if(n==10)//第一種
if(10==n)//第二種
這是一個(gè)風(fēng)格問(wèn)題，第二種方式如果少了個(gè)=號(hào)，編譯時(shí)就會(huì)報(bào)錯(cuò)，減少了出錯(cuò)的可能性，可以檢測(cè)出是否少了=。
66.寫(xiě)出運(yùn)行結(jié)果：
{char str[]="word";cout<
char *p=str;cout<
char i=10;cout<
void *pp=malloc(10);cout<
6:4:1:4
67.不用第三方參數(shù)的情況下，交換兩個(gè)參數(shù)的值。
（1）異或
（2）a=a+b; b=a-b; a=a-b;
68.以下代碼如果有錯(cuò)，請(qǐng)改正，并寫(xiě)出輸出結(jié)果？
main(void)
{int nArrLength(400), i=546;//命名上有問(wèn)題
for(int i=0;i<99999999999;i++);//考對(duì)變量的越界理解，改為unsigned int a=~((int)0)/2,整數(shù)0取反,
cout<
cout<
69.int i=5,b=7;
cout<<(i+++b)<
不用調(diào)試，說(shuō)出在gcc編譯后的結(jié)果；
(i++ +b) 12
70.寫(xiě)一個(gè)能作為左值的函數(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ù)實(shí)現(xiàn)在一個(gè)固定的數(shù)上加上一個(gè)數(shù)，有什么錯(cuò)誤，改正：
int add_n(int n){
static int i=100;
i+=n;
return i;}
因?yàn)閟tatic使得i的值會(huì)保留上次的值。以后的i會(huì)一直更新，使得第二次調(diào)用出現(xiàn)錯(cuò)誤。
去掉static即可
73.unsigned short array[]={1,2,3,4,5,6,7};
int i=3;
cout<<*(array+i)<
4
74.寫(xiě)一個(gè)函數(shù)當(dāng)參數(shù)為n（n很大）時(shí)的值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.字符指針、浮點(diǎn)數(shù)指針、以及函數(shù)指針這三種類(lèi)型的變量哪個(gè)占用內(nèi)存最大？為什么？
指針變量也占用內(nèi)存單元，而且所有指針變量占用內(nèi)存單元的數(shù)量都是相同的。就是說(shuō)，不管是指向何種對(duì)象的指針變量，它們占用內(nèi)存的字節(jié)數(shù)都是一樣的，并且要足夠把程序中所能用到的最大地址表示出來(lái)（通常是一個(gè)機(jī)器字長(zhǎng)）。4
76.以下三條輸出語(yǔ)句輸出
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ù)組，每個(gè)都有其自己的存儲(chǔ)區(qū)，它們的值則是各存儲(chǔ)區(qū)首地址，不等；
str3和str4同上，只是按const語(yǔ)義，它們所指向的數(shù)據(jù)區(qū)不能修改。
str5和str6并非數(shù)組而是字符指針，并不分配存儲(chǔ)區(qū)，其后的“abc”以常量形式存于靜態(tài)數(shù)據(jù)區(qū)，而它們自己僅是指向該區(qū)首地址的指針，相等。
77.以下代碼有什么問(wèn)題？
（true？1：“1”）<
三元表達(dá)式“？：” 問(wèn)號(hào)后面的兩個(gè)操作數(shù)必須為同一類(lèi)型。
78.能夠編譯
unsigned int const size1 = 2;
char str1[size1];
unsigned int temp = 0;
cin >> temp;
unsigned int const size2 = temp;
char str2[size2];
str2定義出錯(cuò)，size2非編譯器期間常量，而數(shù)組定義要求長(zhǎng)度必須為編譯器常量。
79.以下代碼輸出語(yǔ)句為0嗎？為什么？
struct CLS{
int m_i;
CLS(int i):m_i(i){}
// m_i沒(méi)有初始化
CLS()
{
CLS(0);
}
};
CLS obj;
cout<
不能。在默認(rèn)構(gòu)造函數(shù)內(nèi)部再調(diào)用帶參的構(gòu)造函數(shù)屬用戶(hù)行為而非編譯器行為， 亦即僅執(zhí)行函數(shù)調(diào)用，而不會(huì)執(zhí)行其后的初始化表達(dá)式。只有在生成對(duì)象時(shí)，初始化表達(dá)式才會(huì)隨相應(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ù)與記錄地初始排列無(wú)關(guān)的是（） 選擇排序
83.代碼
void func(){static int val; ...}中，變量val的內(nèi)存地址位于：A。已初始化數(shù)據(jù)段
84 入棧
85.判斷表達(dá)式，寫(xiě)出a的值
int a = 4;
A.a+=(a++); B.a+=(++a); C.(a++)+=a;D.(++a)+=(a++);
a++是個(gè)右值，C錯(cuò)； 可改成（++a）=+a;答案：9,10,10,11
86.談?wù)勅绾问褂胷eturn語(yǔ)句
（1）return語(yǔ)句不可返回指向"棧內(nèi)存"的“指針”或者“引用”，因?yàn)樵搩?nèi)存在函數(shù)體結(jié)束時(shí)被自動(dòng)銷(xiāo)毀。
（2）要搞清楚返回的究竟是“值”、“指針”還是“引用”。
（3）如果函數(shù)返回值是一個(gè)對(duì)象，要考慮return語(yǔ)句的效率。
87.（1）return String(s1+s2); 和(2)String temp(s1+s2);return temp;一樣嗎？
（1）是臨時(shí)對(duì)象的語(yǔ)法，表示“創(chuàng)建一個(gè)臨時(shí)對(duì)象并返回它”。
（2）將發(fā)生三件事：
首先，temp對(duì)象被創(chuàng)建，同時(shí)完成初始化；
然后拷貝構(gòu)造函數(shù)把temp拷貝到保存返回值的外部存儲(chǔ)單元中；
最后，temp在函數(shù)結(jié)束時(shí)被銷(xiāo)毀（調(diào)用析構(gòu)函數(shù)）。
然而“創(chuàng)建一個(gè)臨時(shí)對(duì)象并返回它”的過(guò)程是不同的，編譯器直接把臨時(shí)對(duì)象創(chuàng)建并初始化在外部存儲(chǔ)單元中，省去了拷貝和析構(gòu)的花費(fèi)，提高了效率
88.下列程序的運(yùn)行結(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)先級(jí)大于？?jī)?yōu)先級(jí)，所以輸出的是（val1>val2）
90.? int max(int *ia, int sz);
int max(int *,int =10);
算函數(shù)重載？還是重復(fù)聲明？
如果在兩個(gè)函數(shù)的參數(shù)表中只有缺省實(shí)參不同則第二個(gè)聲明被視為第一個(gè)的重復(fù)聲明。
e.編程練習(xí)（91-100）
91.被置1的位的個(gè)數(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.十六進(jìn)制組成的字符串轉(zhuǎn)換成十進(jì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.編寫(xiě)一個(gè)算法frequency，統(tǒng)計(jì)在一個(gè)輸入字符串中各個(gè)不同字符出現(xiàn)的頻度。用適當(dāng)?shù)臏y(cè)試數(shù)據(jù)來(lái)驗(yàn)證這個(gè)算法。
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; /*語(yǔ)句s[i]是串的重載操作*/
for(i=1;i
for(i=1;i
{ //檢測(cè)串中所有字符
j=0;while(j
if(j==k)
{A[k]=s[i];C[k]++;k++;}? //s[i]從未檢測(cè)過(guò)
else C[j]++; //s[i]已經(jīng)檢測(cè)過(guò)
}
}
}
95.假設(shè)以數(shù)組Q[m]存放循環(huán)隊(duì)列中的元素，同時(shí)以rear和length分別指示環(huán)形隊(duì)列中的隊(duì)尾位置和隊(duì)列中所含元素的個(gè)數(shù)。試給出該循環(huán)隊(duì)列的隊(duì)空條件和隊(duì)滿(mǎn)條件，并寫(xiě) 出相應(yīng)的插入(enqueue)和刪除(dlqueue)元素的操作。
#include
template class Queue {? ? //循環(huán)隊(duì)列的類(lèi)定義
public:
Queue ( int=10 );
~Queue ( ) { delete [ ] elements; }
void EnQueue ( Type & item );
Type DeQueue ( );
Type GetFront ( );
void MakeEmpty ( ) { length = 0; }? ? //置空隊(duì)列
int IsEmpty ( ) const { return length == 0; }? //判隊(duì)列空否
int IsFull ( ) const { return length == maxSize; }? //判隊(duì)列滿(mǎn)否
private:
int rear, length;? ? ? //隊(duì)尾指針和隊(duì)列長(zhǎng)度
Type *elements;? ? ? //存放隊(duì)列元素的數(shù)組
int maxSize;? ? ? //隊(duì)列最大可容納元素個(gè)數(shù)
}
template
Queue:: Queue ( int sz ) : rear (maxSize-1), length (0), maxSize (sz) {
//建立一個(gè)最大具有maxSize個(gè)元素的空隊(duì)列。
elements = new Type[maxSize];? //創(chuàng)建隊(duì)列空間
assert ( elements != 0 );? ? //斷言: 動(dòng)態(tài)存儲(chǔ)分配成功與否
}
template
void Queue :: EnQueue ( Type &item ) {
assert ( ! IsFull ( ) );? ? //判隊(duì)列是否不滿(mǎn)，滿(mǎn)則出錯(cuò)處理
length++;? ? ? //長(zhǎng)度加1
rear = ( rear +1) % maxSize;? //隊(duì)尾位置進(jìn)1
elements[rear] = item;? ? //進(jìn)隊(duì)列
}
template
Type Queue :: DeQueue ( ) {
assert ( ! IsEmpty ( ) );? ? //判斷隊(duì)列是否不空，空則出錯(cuò)處理
length--;? ? ? //隊(duì)列長(zhǎng)度減1
return elements[(rear-length+maxSize) % maxSize];? //返回原隊(duì)頭元素值
}
讀取隊(duì)頭元素值函數(shù)
template
Type Queue :: GetFront ( ) {
assert ( ! IsEmpty ( ) );
return elements[(rear-length+1+maxSize) % maxSize];? //返回隊(duì)頭元素值
}
96.已知A[n]為整數(shù)數(shù)組，試寫(xiě)出實(shí)現(xiàn)下列算法的遞歸算法：
(1) 求數(shù)組 A 中的最大整數(shù)。
(2) 求 n 個(gè)整數(shù)的和。
(3) 求 n 個(gè)整數(shù)的平均值。
#include
class RecurveArray? //數(shù)組類(lèi)聲明
{
private:
int *Elements; //數(shù)組指針
int ArraySize; //數(shù)組尺寸
int CurrentSize; //當(dāng)前已有數(shù)組元素個(gè)數(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為單鏈表的表頭指針，鏈表中存儲(chǔ)的都是整型數(shù)據(jù)，試寫(xiě)出實(shí)現(xiàn)下列運(yùn)算的遞歸算法：
#include //定義在頭文件中
class List;
class ListNode? //鏈表結(jié)點(diǎn)類(lèi)
{
friend class List;
private:
int data; //結(jié)點(diǎn)數(shù)據(jù)
ListNode *link; //結(jié)點(diǎn)指針
ListNode ( const int item ) : data(item), link(NULL) { } //構(gòu)造函數(shù)
};
class List? //鏈表類(lèi)
{
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é)點(diǎn), 其值為
item void NewList ( const int retvalue ); //建立鏈表, 以輸入 retvalue 結(jié)束
void PrintList ( ); //輸出鏈表所有結(jié)點(diǎn)數(shù)據(jù)
int GetMax ( )
{
return Max ( first );? ? //求鏈表所有數(shù)據(jù)的最大值
}
int GetNum ( )
{
return Num ( first );? ? //求鏈表中數(shù)據(jù)個(gè)數(shù)
}
float GetAvg ( )
{
return Avg ( first );? ? //求鏈表所有數(shù)據(jù)的平均值
}
};
ListNode* List :: NewNode ( const int item )? //創(chuàng)建新鏈表結(jié)點(diǎn)
{
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é)點(diǎn)
if ( first == NULL ) first = current = q; //空表時(shí), 新結(jié)點(diǎn)成為鏈表第一個(gè)結(jié)點(diǎn)
else
{
current-> link = q; //非空表時(shí), 新結(jié)點(diǎn)鏈入鏈尾
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é)點(diǎn)的后繼鏈表中求最大值
if ( f -> data > temp ) return f ->data; //如果當(dāng)前結(jié)點(diǎn)的值還要大, 返回當(dāng)前檢點(diǎn)值
else return temp; //否則返回后繼鏈表中的最大值
} int List :: Num ( ListNode *f )? //遞歸算法 : 求鏈表中結(jié)點(diǎn)個(gè)數(shù)
{
if ( f == NULL ) return 0; //空表, 返回 0
return 1+ Num ( f -> link ); //否則, 返回后繼鏈表結(jié)點(diǎn)個(gè)數(shù)加 1
}
float List :: Avg ( ListNode *f , int& n )? //遞歸算法 : 求鏈表中所有元素的平均值
{
if ( f -> link == NULL ) //鏈表中只有一個(gè)結(jié)點(diǎn), 遞歸結(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é)束標(biāo)志數(shù)據(jù) ： ";
cin >> finished; //輸入建表結(jié)束標(biāo)志數(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”。試?yán)米址幕具\(yùn)算實(shí)現(xiàn)這個(gè)替換操作。
String & String :: Replace ( String & t, String &v)
{
if ( ( int id = Find ( t ) ) == -1 ) //沒(méi)有找到，當(dāng)前字符串不改，返回
{
cout << "The (replace) operation failed." << endl;
return *this;
}
String temp( ch ); //用當(dāng)前串建立一個(gè)空的臨時(shí)字符串
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é)果串連接后的長(zhǎng)度
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]; //刪改原來(lái)的字符串
temp.curLen -= ( id + t.curLen );
id = temp.Find ( t );
}
return *this;
}
99.試編寫(xiě)一個(gè)求解Josephus問(wèn)題的函數(shù)。用整數(shù)序列1, 2, 3, ……, n表示順序圍坐在圓桌周?chē)娜?，并采用?shù)組表示作為求解過(guò)程中使用的數(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是無(wú)效的參數(shù)！" << endl;
return;
}
for ( i = 0; i < n; i++ ) A[i] = i + 1; /*初始化，執(zhí)行n次*/
i = s - 1; /*報(bào)名起始位置*/
for ( k = n; k > 1; i-- ){/*逐個(gè)出局，執(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; // 用于保存字符串
};
請(qǐng)編寫(xiě)String的上述4個(gè)函數(shù)。
// String 的析構(gòu)函數(shù)
String::~String(void)
{
delete [] m_data;
// 由于m_data 是內(nèi)部數(shù)據(jù)類(lèi)型，也可以寫(xiě)成 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）返回本對(duì)象的引用
return *this;
}
