C、程序員面試常見問題

第一部分:簡答題

Lnew、delete>malloc、free關(guān)系

delete會調(diào)用對象的析構(gòu)函數(shù)，和new對應free只會釋放內(nèi)存，new調(diào)用構(gòu)造

函數(shù)。malloc與free是C++/C語言的標準庫函數(shù)，new/delete是C++的運算符。

它們都可用于申請動態(tài)內(nèi)存和釋放內(nèi)存。對于非內(nèi)部數(shù)據(jù)類型的對象而言，光用

maloc/free無法滿足動態(tài)對象的要求。對象在創(chuàng)建的同時要自動執(zhí)行構(gòu)造函數(shù)，

對象在消亡之前要自動執(zhí)行析構(gòu)函數(shù)。由于malloc/free是庫函數(shù)而不是運算符,

不在編譯器控制權(quán)限之內(nèi)，不能夠把執(zhí)行構(gòu)造函數(shù)和析構(gòu)函數(shù)的任務(wù)強加于

malloc/freeo因此C++語言需要一個能完成動態(tài)內(nèi)存分配和初始化工作的運算符

new,以及一個能完成清理與釋放內(nèi)存工作的運算符deleteo注意new/delete不

是庫函數(shù)。

'delete與delete口區(qū)別

delete只會調(diào)用一次析構(gòu)函數(shù)，而delete口會調(diào)用每一個成員的析構(gòu)函數(shù)。在

MoreEffectiveC++中有更為詳細的解釋：“當delete操作符用于數(shù)組時，它為

每個數(shù)組元素調(diào)用析構(gòu)函數(shù)，然后調(diào)用operatordelete來釋放內(nèi)存。"delete與New

配套，delete□與new□配套

MemTest*mTest1=newMemTest[10];

MemTest*mTest2=newMemTest;

int*pIntl=newint[10];

int*plnt2=newint;

delete[]plntl;//-l-

delete[]plnt2;//-2-

delete[]mTestl;//-3-

delete[]mTest2;//-4-

在-4-處報錯。

這就說明：對于內(nèi)建簡單數(shù)據(jù)類型，delete和delete口功能是相同的。對于自

定義的復雜數(shù)據(jù)類型，delete和delete□不能互用。delete口刪除一個數(shù)組，delete

刪除一個指針簡單來說，用new分配的內(nèi)存用delete刪除用new口分配的內(nèi)存用

delete口刪除delete□會調(diào)用數(shù)組元素的析構(gòu)函數(shù)。內(nèi)部數(shù)據(jù)類型沒有析構(gòu)函數(shù)，

所以問題不大。如果你在用delete時沒用括號，delete就會認為指向的是單個對

象，否則，它就會認為指向的是一個數(shù)組。

3.CC++JAVA共同點，不同之處?

4.繼承優(yōu)缺點。

類繼承是在編譯時刻靜態(tài)定義的，且可直接使用，類繼承可以較方便地改變

父類的實現(xiàn)。但是類繼承也有一些不足之處。首先，因為繼承在編譯時刻就定義

了，所以無法在運行時刻改變從父類繼承的實現(xiàn)。更糟的是，父類通常至少定義

了子類的部分行為，父類的任何改變都可能影響子類的行為。如果繼承下來的實

現(xiàn)不適合解決新的問題，則父類必須重寫或被其他更適合的類替換。這種依賴關(guān)

系限制了靈活性并最終限制了復用性。

（待補充）

5.C++有哪些性質(zhì)（面向?qū)ο筇攸c）

封裝，繼承和多態(tài)。

在面向?qū)ο蟪绦蛟O(shè)計語言中，封裝是利用可重用成分構(gòu)造軟件系統(tǒng)的特性,

它不僅支持系統(tǒng)的可重用性，而且還有利于提高系統(tǒng)的可擴充性；消息傳遞可以

實現(xiàn)發(fā)送一個通用的消息而調(diào)用不同的方法；封裝是實現(xiàn)信息隱蔽的一種技術(shù),

其目的是使類的定義和實現(xiàn)分離。

6.子類析構(gòu)時要調(diào)用父類的析構(gòu)函數(shù)嗎?

析構(gòu)函數(shù)調(diào)用的次序是先派生類的析構(gòu)后基類的析構(gòu)，也就是說在基類的的

析構(gòu)調(diào)用的時候,派生類的信息已經(jīng)全部銷毀了定義一個對象時先調(diào)用基類的構(gòu)

造函數(shù)、然后調(diào)用派生類的構(gòu)造函數(shù)；析構(gòu)的時候恰好相反：先調(diào)用派生類的析

構(gòu)函數(shù)、然后調(diào)用基類的析構(gòu)函數(shù)JAVA無析構(gòu)函數(shù)深拷貝和淺拷貝

7.多態(tài)，虛函數(shù)，純虛函數(shù)

8.求下面函數(shù)的返回值（微軟）

intfiinc(x)

intcountx=0;

while（x）

{

countx++;

X=x&（x-l）;

}

returncountx;

假定x=9999。答案：8

思路：將x轉(zhuǎn)化為2進制，看含有的1的個數(shù)。

9.什么是“引用”？申明和使用“引用”要注意哪些問題?

答：引用就是某個目標變量的“別名”（alias）,對應用的操作與對變量直接操

作效果完全相同。申明一個引用的時候，切記要對其進行初始化。引用聲明完畢

后，相當于目標變量名有兩個名稱，即該目標原名稱和引用名，不能再把該引用

名作為其他變量名的別名。聲明一個引用，不是新定義了一個變量，它只表示該

引用名是目標變量名的一個別名，它本身不是一種數(shù)據(jù)類型，因此引用本身不占

存儲單元，系統(tǒng)也不給引用分配存儲單元。不能建立數(shù)組的引用。

10.將“引用”作為函數(shù)參數(shù)有哪些特點?

（1）傳遞引用給函數(shù)與傳遞指針的效果是一樣的。這時，被調(diào)函數(shù)的形參

就成為原來主調(diào)函數(shù)中的實參變量或?qū)ο蟮囊粋€別名來使用，所以在被調(diào)函數(shù)中

對形參變量的操作就是對其相應的目標對象（在主調(diào)函數(shù)中）的操作。

（2）使用引用傳遞函數(shù)的參數(shù)，在內(nèi)存中并沒有產(chǎn)生實參的副本，它是直

接對實參操作；而使用一般變量傳遞函數(shù)的參數(shù)，當發(fā)生函數(shù)調(diào)用時，需要給形

參分配存儲單元，形參變量是實參變量的副本；如果傳遞的是對象，還將調(diào)用拷

貝構(gòu)造函數(shù)。因此，當參數(shù)傳遞的數(shù)據(jù)較大時，用引用比用一般變量傳遞參數(shù)的

效率和所占空間都好。

（3）使用指針作為函數(shù)的參數(shù)雖然也能達到與使用引用的效果，但是，在

被調(diào)函數(shù)中同樣要給形參分配存儲單元，且需要重復使用"*指針變量名"的形式

進行運算，這很容易產(chǎn)生錯誤且程序的閱讀性較差；另一方面，在主調(diào)函數(shù)的調(diào)

用點處，必須用變量的地址作為實參。而引用更容易使用，更清晰。

11.在什么時候需要使用“常引用”?

如果既要利用引用提高程序的效率，又要保護傳遞給函數(shù)的數(shù)據(jù)不在函數(shù)中

被改變，就應使用常引用。常引用聲明方式：const類型標識符&引用名=目標

變量名；

例1

inta;

constint&ra=a;

ra=l;〃錯誤

a=l;//正確

例2

stringfdo();

voidbar(string&s);

那么下面的表達式將是非法的：

bar(foo());

bar(nhelloworld0);

原因在于foo()和”helloworld”串都會產(chǎn)生一個臨時對象，而在C++中，這些

臨時對象都是const類型的。因此上面的表達式就是試圖將一個const類型的對

象轉(zhuǎn)換為非const類型，這是非法的。引用型參數(shù)應該在能被定義為const的情

況下，盡量定義為consto

12.將“引用”作為函數(shù)返回值類型的格式、好處和需要遵守的規(guī)則?

格式：類型標識符&函數(shù)名(形參列表及類型說明){//函數(shù)體}

好處：在內(nèi)存中不產(chǎn)生被返回值的副本；(注意：正是因為這點原因，所以

返回一個局部變量的引用是不可取的。因為隨著該局部變量生存期的結(jié)束，相應

的引用也會失效，產(chǎn)生runtimeerror!注意事項：

(1)不能返回局部變量的引用。這條可以參照EffectiveC++[l]的Item31。

主要原因是局部變量會在函數(shù)返回后被銷毀，因此被返回的引用就成為了"無所

指"的引用，程序會進入未知狀態(tài)。

(2)不能返回函數(shù)內(nèi)部new分配的內(nèi)存的引用。這條可以參照Effective

C++川的Item3k雖然不存在局部變量的被動銷毀問題，可對于這種情況(返

回函數(shù)內(nèi)部new分配內(nèi)存的引用)，又面臨其它尷尬局面。例如，被函數(shù)返回的

引用只是作為一個臨時變量出現(xiàn)，而沒有被賦予一個實際的變量，那么這個引用

所指向的空間(由new分配)就無法釋放，造成memoryleak。

(3)可以返回類成員的引用，但最好是const。這條原則可以參照Effective

C++[1]^JItem30o主要原因是當對象的屬性是與某種業(yè)務(wù)規(guī)則(businessrule)

相關(guān)聯(lián)的時候，其賦值常常與某些其它屬性或者對象的狀態(tài)有關(guān)，因此有必要將

賦值操作封裝在一個業(yè)務(wù)規(guī)則當中。如果其它對象可以獲得該屬性的非常量引用

(或指針)，那么對該屬性的單純賦值就會破壞業(yè)務(wù)規(guī)則的完整性。

(4)流操作符重載返回值申明為“引用”的作用：

流操作符＜＜和＞＞，這兩個操作符常常希望被連續(xù)使用，例如：cout＜＜"hello"

?endl;因此這兩個操作符的返回值應該是一個仍然支持這兩個操作符的流引

用?？蛇x的其它方案包括：返回一個流對象和返回一個流對象指針。但是對于返

回一個流對象，程序必須重新(拷貝)構(gòu)造一個新的流對象，也就是說，連續(xù)的

兩個＜＜操作符實際上是針對不同對象的！這無法讓人接受。對于返回一個流指

針則不能連續(xù)使用＜＜操作符。因此，返回一個流對象引用是惟一選擇。這個唯

一選擇很關(guān)鍵，它說明了引用的重要性以及無可替代性，也許這就是C++語言中

引入引用這個概念的原因吧。賦值操作符=。這個操作符象流操作符一樣，是可

以連續(xù)使用的，例如：x=j=10;或者(x=10尸100;賦值操作符的返回值必須是一

個左值，以便可以被繼續(xù)賦值。因此引用成了這個操作符的惟一返回值選擇。

例3

#include<iostream.h>

int&put(intn);

intvals[10];

interror=-1;

voidmain()

(

put(0)=10;〃以put(O)函數(shù)值作為左值，等價于vals[0]=10;

put(9尸20;//以put(9)函數(shù)值作為左值，等價于vals[9]=20;

cout?vals[0];

cout?vals[9];

}

int&put(intn)

(

if(n>=0&&n<=9)returnvals[n];

else{cout?nsubscripterror0;returnerror;}

}

(5)在另外的一些操作符中，卻千萬不能返回引用：+-*/四則運算符。它

們不能返回引用，EffectiveC++[l]的Item23詳細的討論了這個問題。主要原因

是這四個操作符沒有sideeffect,因此，它們必須構(gòu)造一個對象作為返回值，可

選的方案包括：返回一個對象、返回一個局部變量的引用，返回一個new分配

的對象的引用、返回一個靜態(tài)對象引用。根據(jù)前面提到的引用作為返回值的三個

規(guī)則，第2、3兩個方案都被否決了。靜態(tài)對象的引用又因為((a+b)==(c+d))會

永遠為true而導致錯誤。所以可選的只剩下返回一個對象了。

13.“引用”與多態(tài)的關(guān)系？

引用是除指針外另一個可以產(chǎn)生多態(tài)效果的手段。這意味著，一個基類的引

用可以指向它的派生類實例。例4

ClassA;ClassB:ClassA{...};Bb;A&ref=b;

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

指針通過某個指針變量指向一個對象后，對它所指向的變量間接操作。程序

中使用指針，程序的可讀性差；而引用本身就是目標變量的別名，對引用的操作

就是對目標變量的操作。此外，就是上面提到的對函數(shù)傳ref和pointer的區(qū)別。

15.什么時候需要“引用”?

流操作符＜＜和＞＞、賦值操作符=的返回值、拷貝構(gòu)造函數(shù)的參數(shù)、賦值操作

符=的參數(shù)、其它情況都推薦使用引用。以上2-8參考：

http://develop.csai.en/c/N0000002l.htm

16.結(jié)構(gòu)與聯(lián)合有和區(qū)別？

(1).結(jié)構(gòu)和聯(lián)合都是由多個不同的數(shù)據(jù)類型成員組成，但在任何同一時刻，聯(lián)合

中只存放了一個被選中的成員(所有成員共用一塊地址空間)，而結(jié)構(gòu)的所有成

員都存在(不同成員的存放地址不同)。

(2).對于聯(lián)合的不同成員賦值，將會對其它成員重寫，原來成員的值就不存在了,

而對于結(jié)構(gòu)的不同成員賦值是互不影響的。

17.面關(guān)于“聯(lián)合”的題目的輸出？

a)

#include<stdio.h>

union

{

inti;

charx[2];

)a；

voidmain()

(

a.x[0]=10;

a.x[l]=1;

printf(H%dn,a.i);

)

答案：266(低位低地址，高位高地址，內(nèi)存占用情況是OxOlOA)

b)

main()

(

union{/*定義一個聯(lián)合*/

inti;

struct{/*在聯(lián)合中定義一個結(jié)構(gòu)*/

charfirst;

charsecond;

}half;

}number;

number.i=0x4241;/*聯(lián)合成員賦值*/

printf("%c%cn",number.half.first,mumber.half.second);

number.half.first='a';/*聯(lián)合中結(jié)構(gòu)成員賦值*/

number,half.second='b';

printf("%xn",number.i);

getch();

}

答案：AB(0x41對應是低位；0x42對應B,是高位)

6261(number.i和number.half共用一塊地址空間)

18.關(guān)聯(lián)、聚合（Aggregation）以及組合（Composition）的區(qū)別？

涉及到UML中的一些概念：關(guān)聯(lián)是表示兩個類的一般性聯(lián)系，比如“學生”

和“老師”就是一種關(guān)聯(lián)關(guān)系；聚合表示has-a的關(guān)系，是一種相對松散的關(guān)系，

聚合類不需要對被聚合類負責，如下圖所示，用空的菱形表示聚合關(guān)系：從實現(xiàn)

的角度講，聚合可以表示為：

classAclassB{A*a;..…）

而組合表示contains-a的關(guān)系，關(guān)聯(lián)性強于聚合：組合類與被組合類有相同

的生命周期，組合類要對被組合類負責，采用實心的菱形表示組合關(guān)系：實現(xiàn)的

形式是：

classA{...}classB{Aa;...}

參考文章:/Lily/archive/2006/02/23/6860.html

/document/viewdoc/7idM22

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

1.封裝：將客觀事物抽象成類，每個類對自身的數(shù)據(jù)和方法實行

protection（private,protected,public）

2.繼承：廣義的繼承有三種實現(xiàn)形式：實現(xiàn)繼承（指使用基類的屬性和方

法而無需額外編碼的能力）、可視繼承（子窗體使用父窗體的外觀和實現(xiàn)代碼）、

接口繼承（僅使用屬性和方法，實現(xiàn)滯后到子類實現(xiàn)）。前兩種（類繼承）和后

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

3.多態(tài)：是將父對象設(shè)置成為和一個或更多的他的子對象相等的技術(shù)，賦

值之后，父對象就可以根據(jù)當前賦值給它的子對象的特性以不同的方式運作。簡

單的說，就是一句話：允許將子類類型的指針賦值給父類類型的指針。

20.重載（overload）和重寫（overried,有的書也叫做“覆蓋”）的區(qū)別？

?？嫉念}目。從定義上來說：

重載：是指允許存在多個同名函數(shù)，而這些函數(shù)的參數(shù)表不同（或許參數(shù)個

數(shù)不同，或許參數(shù)類型不同，或許兩者都不同）。

重寫：是指子類重新定義父類虛函數(shù)的方法。

從實現(xiàn)原理上來說：

重載：編譯器根據(jù)函數(shù)不同的參數(shù)表，對同名函數(shù)的名稱做修飾，然后這些

同名函數(shù)就成了不同的函數(shù)（至少對于編譯器來說是這樣的）。如，有兩個同名

函數(shù)：functionfunc（p:integer）:integer;^0functionfunc（p:string）:integer;o那么編譯

器做過修飾后的函數(shù)名稱可能是這樣的：int_fiinc、str_funco對于這兩個函數(shù)的

調(diào)用，在編譯器間就已經(jīng)確定了，是靜態(tài)的。也就是說，它們的地址在編譯期就

綁定了（早綁定），因此，重載和多態(tài)無關(guān)！

重寫：和多態(tài)真正相關(guān)。當子類重新定義了父類的虛函數(shù)后，父類指針根據(jù)

賦給它的不同的子類指針，動態(tài)的調(diào)用屬于子類的該函數(shù)，這樣的函數(shù)調(diào)用在編

譯期間是無法確定的（調(diào)用的子類的虛函數(shù)的地址無法給出）。因此，這樣的函

數(shù)地址是在運行期綁定的（晚綁定）。

21.多態(tài)的作用？

主要是兩個：

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

2.接口重用：為了類在繼承和派生的時候，保證使用家族中任一類的實例

的某一屬性時的正確調(diào)用。

22.Ado與A的相同與不同？

除了“能夠讓應用程序處理存儲于DBMS中的數(shù)據(jù)“這一基本相似點外，

兩者沒有太多共同之處。但是Ado使用OLEDB接口并基于微軟的COM技術(shù)，

而ADO.NET擁有自己的ADO.NET接口并且基于微軟的.NET體系架構(gòu)。眾所

周知.NET體系不同于COM體系,ADO.NET接口也就完全不同于ADO和OLE

DB接口，這也就是說ADO.NET和ADO是兩種數(shù)據(jù)訪問方式。ADO.net提供

對XML的支持。

23.Newdelete與mallocfree的聯(lián)系與區(qū)別？

答案：都是在堆（heap）上進行動態(tài)的內(nèi)存操作。用malloc函數(shù)需要指定內(nèi)存

分配的字節(jié)數(shù)并且不能初始化對象，new會自動調(diào)用對象的構(gòu)造函數(shù)。delete會

調(diào)用對象的destructor,而free不會調(diào)用對象的destructor.

24.#defineDOUBLE(x)x+x，i=5*DOUBLE(5)；i是多少？

答案：i為30o

25.有哪幾種情況只能用intializationlist而不能用assignment?

答案：當類中含有const、reference成員變量；基類的構(gòu)造函數(shù)都需要初始

化表。

26.C++是不是類型安全的？

答案：不是。兩個不同類型的指針之間可以強制轉(zhuǎn)換（用reinterpretcast）。

C#是類型安全的。

27.main函數(shù)執(zhí)行以前，還會執(zhí)行什么代碼?

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

28.描述內(nèi)存分配方式以及它們的區(qū)別?

1）從靜態(tài)存儲區(qū)域分配。內(nèi)存在程序編譯的時候就已經(jīng)分配好，這塊內(nèi)存

在程序的整個運行期間都存在。例如全局變量，static變量。

2）在棧上創(chuàng)建。在執(zhí)行函數(shù)時，函數(shù)內(nèi)局部變量的存儲單元都可以在棧上

創(chuàng)建，函數(shù)執(zhí)行結(jié)束時這些存儲單元自動被釋放。棧內(nèi)存分配運算內(nèi)置于處

理器的指令集。

3）從堆上分配，亦稱動態(tài)內(nèi)存分配。程序在運行的時候用malloc或new申

請任意多少的內(nèi)存，程序員自己負責在何時用free或delete釋放內(nèi)存。動

態(tài)內(nèi)存的生存期由程序員決定，使用非常靈活，但問題也最多。

29.struct和class的區(qū)別

答案：struct的成員默認是公有的，而類的成員默認是私有的。struct和class

在其他方面是功能相當?shù)?。從感情上講，大多數(shù)的開發(fā)者感到類和結(jié)構(gòu)有很大的

差別。感覺上結(jié)構(gòu)僅僅象一堆缺乏封裝和功能的開放的內(nèi)存位，而類就象活的并

且可靠的社會成員，它有智能服務(wù)，有牢固的封裝屏障和一個良好定義的接口。

既然大多數(shù)人都這么認為，那么只有在你的類有很少的方法并且有公有數(shù)據(jù)（這

種事情在良好設(shè)計的系統(tǒng)中是存在的!）時，你也許應該使用struct關(guān)鍵字，否

則，你應該使用class關(guān)鍵字。

30.當一個類A中沒有任何成員變量與成員函數(shù)，這時sizeof（A）的值是多少？

答案：如果不是零，請解釋一下編譯器為什么沒有讓它為零。（Autodesk）

肯定不是零。舉個反例，如果是零的話，聲明一個classA[10]對象數(shù)組，而每一

個對象占用的空間是零，這時就沒辦法區(qū)分A[0],A[l]…了。

31.在8086匯編下，邏輯地址和物理地址是怎樣轉(zhuǎn)換的？（Intel）

答案：通用寄存器給出的地址，是段內(nèi)偏移地址，相應段寄存器地址*10H+

通用寄存器內(nèi)地址，就得到了真正要訪問的地址。

32.比較C++中的4種類型轉(zhuǎn)換方式？

請參考：/wfwd/archive/2006/05/30/763785.aspx,重點是

static_cast,dynamic_cast和reinterpretcast的區(qū)別和應用。

Jynamic_casts法幫助你瀏覽繼永層次上是有限制的。它不能被用于缺乏虛

函數(shù)的類型工，它被用于安全地沿著類的繼承關(guān)系向下進行類型轉(zhuǎn)換。如你想在

沒有繼承關(guān)系的類型中進行轉(zhuǎn)換，你可能想到static_cast

33.分別寫出BOOL,int,float,指針類型的變量a與“零”的比較語句。

答案：

BOOL:if(!a)orif(a)

int:if(a=0)

float:constEXPRESSIONEXP=0.000001

if(a<EXP&&a>-EXP)

pointer:if(a!=NULL)orififa==NULL)

34.請說出const與#define相比，有何優(yōu)點？

答案：

Const作用：定義常量、修飾函數(shù)參數(shù)、修飾函數(shù)返回值三個作用。被Const

修飾的東西都受到強制保護，可以預防意外的變動，能提高程序的健壯性。

1)const常量有數(shù)據(jù)類型，而宏常量沒有數(shù)據(jù)類型。編譯器可以對前者進

行類型安全檢查。而對后者只進行字符替換，沒有類型安全檢查，并且在字符替

換可能會產(chǎn)生意料不到的錯誤。

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

進行調(diào)試。

35.簡述數(shù)組與指針的區(qū)別？

數(shù)組要么在靜態(tài)存儲區(qū)被創(chuàng)建(如全局數(shù)組)，要么在棧上被創(chuàng)建。指針可

以隨時指向任意類型的內(nèi)存塊。

(1)修改內(nèi)容上的差別

chara[]="hello”；

a[0]='X';

char*p="world”；〃注意p指向常量字符串

p[0]='X';〃編譯器不能發(fā)現(xiàn)該錯誤，運行時錯誤

(2)用運算符sizeof可以計算出數(shù)組的容量(字節(jié)數(shù))。sizeof(p),p為指針得到的

是一個指針變量的字節(jié)數(shù)，而不是p所指的內(nèi)存容量。C++/C語言沒有辦法知

道指針所指的內(nèi)存容量，除非在申請內(nèi)存時記住它。注意當數(shù)組作為函數(shù)的參數(shù)

進行傳遞時，該數(shù)組自動退化為同類型的指針。

chara[]="helloworld";

char*p=a;

cout?sizeof(a)?endl;//12字節(jié)

cout?sizeoRp)?endl;〃4字節(jié)

計算數(shù)組和指針的內(nèi)存容量

voidFunc(chara[100])

{

cout?sizeof(a)?endl;//4字節(jié)而不是100字節(jié)

36.類成員函數(shù)的重載、覆蓋和隱藏區(qū)別？

答案：a.成員函數(shù)被重載的特征:

(1)相同的范圍(在同一個類中)；

(2)函數(shù)名字相同；

(3)參數(shù)不同；

(4)virtual關(guān)鍵字可有可無。

b.覆蓋是指派生類函數(shù)覆蓋基類函數(shù)，特征是：

(1)不同的范圍(分別位于派生類與基類)；

(2)函數(shù)名字相同；

(3)參數(shù)相同；

(4)基類函數(shù)必須有virtual關(guān)鍵字。

c.“隱藏”是指派生類的函數(shù)屏蔽了與其同名的基類函數(shù)，規(guī)則如下：

(1)如果派生類的函數(shù)與基類的函數(shù)同名，但是參數(shù)不同。此時，不論有無virtual

關(guān)鍵字，基類的函數(shù)將被隱藏(注意別與重載混淆)。

(2)如果派生類的函數(shù)與基類的函數(shù)同名，并且參數(shù)也相同，但是基類函數(shù)沒

有virtual關(guān)鍵字。此時，基類的函數(shù)被隱藏(注意別與覆蓋混淆)

37.求出兩個數(shù)中的較大這

Therearetwointvariables:aandb,don'tuse"if","?:","switch“orother

judgementstatements,findoutthebiggestoneofthetwonumbers.

答案：((a+b)+abs(a-b))/2

38.如何打印出當前源文件的文件名以及源文件的當前行號？

答案：

cout?_FILE_;

cout?_LINE_;

_FILEZ和_EINE_是系統(tǒng)預定義宏，這種宏并不是在某個文件中定義的，而

是由編譯器定義的。

39.main主函數(shù)執(zhí)行完畢后，是否可能會再執(zhí)行一段代碼，給出說明？

答案：可以，可以用_onexit注冊一個函數(shù)，它會在main之后執(zhí)行int

fhl(void),fh2(void),fh3(void),fn4(void);

voidmain(void)

{

Stringstr("zhanglin");

_onexit(fnl);

_onexit(fh2);

_onexit(fn3);

_onexit(fn4);

prints"Thisisexecutedfirst.n");

intfnlQ

printf(unext.nu);

return0;

intfn2()

(

prints"executed”);

return0;

)

intfn3()

(

printf("is”)；

return0;

}

intfn4()

(

prints“This”);

return0;

)

The_onexitfunctionispassedtheaddressofafunction(func)tobecalledwhenthe

programterminatesnormally.Successivecallstoonexitcreatearegisteroffunctions

thatareexecutedinLIFO(last-in-first-out)order.Thefunctionspassedtoonexit

cannottakeparameters.

40.如何判斷一段程序是由C編譯程序還是由C++編譯程序編譯的？

答案：

#iftlef_cplusplus

cout?nc-w-n;

#else

cout?,,cH;

#endif

41.文件中有一組整數(shù)，要求排序后輸出到另一個文件中

答案：

#include<iostream>

#include<fstream>

usingnamespacestd;

voidOrder(vector<int>&data)//bubblesort

(

intcount=data.size();

inttag=false;//設(shè)置是否需要繼續(xù)冒泡的標志位

for(inti=0;i<count;i++)

(

fbr(intj=0;j<count-i-1;j++)

{

if(data[j]>data[j+l])

(

tag=true;

inttemp=data[j];

data[j]=data[j+l];

data[j4-l]=temp;

f

}

if(!tag)

break;

voidmain(void)

{

vector<int>data;

ifstreamin(uc:\data.txtH);

if(!in)

{

cout?nfileerror!n;

exit(l);

}

inttemp;

while(!in.eof())

{

in?temp;

data,pushback(temp);

)

in.close();〃關(guān)閉輸入文件流

Order(data);

ofstreamout(nc:\result.txtn);

if(!out)

cout?nfileerror!M;

exit(l);

for(i=0;i<data.size();i++)

out?data[i]?n°;

out.close();〃關(guān)閉輸出文件流

42.鏈表題：一個鏈表的結(jié)點結(jié)構(gòu)

structNode

{

intdata;

Node*next;

);

typedefstructNodeNode;

(1)已知鏈表的頭結(jié)點head,寫一個函數(shù)把這個鏈表逆序(Intel)

Node*ReverseList(Node*head)//鏈表逆序

(

if(head=NULL||head->next==NULL)

returnhead;

Node*pl=head;

Node*p2=pl->next;

Node*p3=p2->next;

pl->next=NULL;

while(p3!=NULL)

(

p2->next=pl;

pl=p2;

p2=p3;

p3=p3->next;

)

p2->next=pl;

head=p2;

returnhead;

)

(2)已知兩個鏈表headl和head2各自有序，請把它們合并成一個鏈表依然有序。

(保留所有結(jié)點，即便大小相同)

Node*Merge(Node*headl,Node*head2)

(

if(head1==NULL)

returnhead2;

if(head2==NULL)

returnheadl;

Node*head=NULL;

Node*pl=NULL;

Node*p2=NULL;

if(headl->data<head2->data)

(

head=headl;

p1=head1->next;

p2=head2;

)

else

{

head=head2;

p2=head2->next;

pl=headl;

i

Node*pcurrent=head;

while(pl!=NULL&&p2!=NULL)

(

if(p1->data<=p2->data)

(

pcurrent->next=pl;

pcurrent=pl;

pl=pl->next;

}

else

(

pcurrent->next=p2;

pcurrent=p2;

p2=p2->next;

}

)

if(pl!=NULL)

pcurrent->next=pl;

if(p2!=NULL)

pcurrent->next=p2;

returnhead;

}

(3)已知兩個鏈表headl和head2各自有序，請把它們合并成一個鏈表依然有序,

這次要求用遞歸方法進行。(Autodesk)

答案：

Node*MergeRecursive(Node*headl,Node*head2)

(

if(headl==NULL)

returnhead2;

if(head2==NULL)

returnheadl;

Node*head=NULL;

if(headl->data<head2->data)

(

head=headl;

head->next=MergeRecursive(head1->next,head2);

)

else

(

head=head2;

head->next=MergeRecursive(head1,head2->next);

)

returnhead;

41.分析一下這段程序的輸出(Autodesk)

classB

(

public:

B()

(

cout?ndefaultconstructorn?endl;

}

?B()

(

cout?ndestructedn?endl;

)

B(inti):data(i)//B(int)worksasaconverter(int->instanceofB)

(

cout?nconstructedbyparametern?data?endl;

)

private:

intdata;

};

BPlay(Bb)

(

returnb;

)

(1)results:

intmain(intargc,char*argv[])constructedbyparameter5

{destructedB(5)形參析構(gòu)

Btl=Play(5);Bt2=Play(tl);destructedtl形參析構(gòu)

return0;destructedt2注意順序！

}destructedtl

(2)results:

intmain(intargc,char*argv[])constructedbyparameter5

{destructedB(5)形參析構(gòu)

Btl=Play(5);Bt2=Play(10);constructedbyparameter10

return0;destructedB(10)形參析構(gòu)

}destructedt2注意順序！

destructedtl

43.寫一個函數(shù)找出一個整數(shù)數(shù)組中，第二大的數(shù)(microsoft)

答案：

constintMINNUMBER=-32767;

intfindsecmax(intdata[],intcount)

(

intmaxnumber=data[0];

intsecmax=MINNUMBER;

for(inti=1;i<count;i++)

(

if(data[i]>maxnumber)

{

secmax=maxnumber;

maxnumber=data[i];

}

else

(

if(datafi]>secmax)

secmax=data[i];

)

)

returnsecmax;

44.寫一個在一個字符串(n)中尋找一個子串(m)第一個位置的函數(shù)。

KMP算法效率最好，時間復雜度是0(n+m),詳見：

http:"/blog/c_335_kmp.html

46.多重繼承的內(nèi)存分配問題:

比如有classA:publicclassB,publicclassC{}那么A的內(nèi)存結(jié)構(gòu)大致是怎

么樣的？

這個是compiler-dependent的，不同的實現(xiàn)其細節(jié)可能不同。如果不考慮有虛函

數(shù)、虛繼承的話就相當簡單；否則的話，相當復雜?？梢詤⒖肌渡钊胩剿鰿++

對象模型》，或者：

/rainlight/archive/2006/03/03/614792.aspx

/archive/default.asp?url=/archive/en-us/dnarvc/html/jangra

yhood.asp

47.如何判斷一個單鏈表是有環(huán)的？（注意不能用標志位，最多只能用兩個額外

指針）

structnode{charval;node*next;}

boolcheck(constnode*head){}//returnfalse:無環(huán)；true:有環(huán)一種O(n)的辦

法就是(搞兩個指針，一個每次遞增一步，一個每次遞增兩步，如果有環(huán)的話兩

者必然重合，反之亦然)：

boolcheck(constnode*head)

(

if(head==NULL)returnfalse;

node*low=head,*fast=head->next;

while(fast!=NULL&&fast->next!=NULL)

{

low=low->next;

fast=fast->next->next;

if(low=fast)returntrue;

)

returnfalse;

48.指針找錯題

分析這些面試題，本身包含很強的趣味性;而作為一名研發(fā)人員，通過對這

些面試題的深入剖析則可進一步增強自身的內(nèi)功。

2.找錯題試題1：

以下是引用片段：

voidtest1()〃數(shù)組越界

{

charstring[10];

char*strl="0123456789";

strcpy(string,strl);

)

試題2：

以下是引用片段：

voidtest2()

{

charstring[10],strl[10];

inti;

fbr(i=O;i<10;i++)

{

strl='a';

)

strcpy(string,strl);

)

試題3：

以下是引用片段：

voidtest3(char*strl)

{

charstring[10];

if(strlen(strl)<=10)

(

strcpy(string,strl);

}

)

解答:

試題1字符串strl需要11個字節(jié)才能存放下(包括末尾的而string只

有10個字節(jié)的空間，strcpy會導致數(shù)組越界;對試題2,如果面試者指出字符數(shù)

組strl不能在數(shù)組內(nèi)結(jié)束可以給3分;如果面試者指出strcpy(string,strl)調(diào)用使得

從strl內(nèi)存起復制到string內(nèi)存起所復制的字節(jié)數(shù)具有不確定性可以給7分，在

此基礎(chǔ)上指出庫函數(shù)strcpy工作方式的給10分；

對試題3,if(strlen(strl)<=10)應改為i[strlen(strl)<10),因為strlen的結(jié)果未統(tǒng)

計'(F所占用的1個字節(jié)。剖析：考查對基本功的掌握

⑴字符串以'\0'結(jié)尾；

(2)對數(shù)組越界把握的敏感度；

(3)庫函數(shù)strcpy的工作方式，

49.如果編寫一個標準strcpy函數(shù)

總分值為10,下面給出幾個不同得分的答案：2分以下是引用片段:

voidstrcpy(char*strDest,char*strSrc)

(

while((*strDest++=*strSrc++)!='\0');

)

4分以下是引用片段：

voidstrcpy(char*strDest,constchar*strSrc)

//將源字符串加const,表明其為輸入?yún)?shù)，加2分

(

while((*strDest++=*strSrc++)!='\0');

)

7分以下是引用片段：

voidstrcpy(char*strDest,constchar*strSrc)

{

〃對源地址和目的地址加非0斷言，加3分

assert((strDest!=NULL)&&(strSrc!=NULL));

while((*strDest++=*strSrc++)!='\0');

}

10分以下是引用片段：

〃為了實現(xiàn)鏈式操作，將目的地址返回，加3分！

char*strcpy(char*strDest,constchar*strSrc)

(

assert((strDest!=NULL)&&(strSrc!=NULL));

char*address=strDest;

while((*strDest++=*strSrc++)!='\0');

returnaddress;

)

從2分到10分的幾個答案我們可以清楚的看到，小小的strcpy竟然暗藏著

這么多玄機，真不是蓋的!需要多么扎實的基本功才能寫一個完美的strcpy啊！

(4)對strlen的掌握，它沒有包括字符串末尾的

讀者看了不同分值的strcpy版本，應該也可以寫出一個10分的strlen函數(shù)

了，完美的版本為：intstrlen(constchar*str)〃輸入?yún)?shù)const以下是引用片

段：

{

assert(strt!=NULL);〃斷言字符串地址非0

intlen=0;〃注，一定要初始化。

while((*str++)!='\0')

{

len++;

)

returnlen;

}

試題4：以下是引用片段：

voidGetMemory(char*p)

p=(char*)malloc(100);

)

voidTest(void)

(

char*str=NULL;

GetMemory(str);

strcpy(str,"helloworld");

printf(str);

}

試題5：

以下是引用片段：

char*GetMemory(void)

(

charp[]="helloworld”;

returnp;

)

voidTest(void)

(

char*str=NULL;

str=GetMemory();

printf(str);

)

試題6：以下是引用片段：

voidGetMemory(char**p,intnum)

(

*p=(char*)malloc(num);

)

voidTest(void)

(

char*str=NULL;

GetMemory(&str,100);

strcpy(str,"hello”)；

printf(str);

)

試題7：以下是引用片段：

voidTest(void)

(

char*str=(char*)malloc(100);

strcpy(str,"hello");

free(str);

…〃省略的其它語句

)

解答：試題4傳入中GetMemory(char*p)函數(shù)的形參為字符串指針，在函

數(shù)內(nèi)部修改形參并不能真正的改變傳入形參的值，執(zhí)行完

char*str=NULL;

GetMemory(str);

后的str仍然為NULL;試題5中

charp[]="helloworld";

returnp;

的p口數(shù)組為函數(shù)內(nèi)的局部自動變量，在函數(shù)返回后，內(nèi)存已經(jīng)被釋放。這

是許多程序員常犯的錯誤，其根源在于不理解變量的生存期。

試題6的GetMemory避免了試題4的問題，傳入GetMemory的參數(shù)為字符

串指針的指針，但是在GetMemory中執(zhí)行申請內(nèi)存及賦值語句tiffanybracelets

*p=(char*)malloc(num);

后未判斷內(nèi)存是否申請成功，應加上：

if(*p=NULL)

{

…〃進行申請內(nèi)存失敗處理

)

試題7存在與試題6同樣的問題，在執(zhí)行

char*str=(char*)malloc(lOO);

后未進行內(nèi)存是否申請成功的判斷;另外，在free(str)后未置str為空，導致

可能變成一個“野”指針，應加上：

str=NULL;

試題6的Test函數(shù)中也未對malloc的內(nèi)存進行釋放。

剖析：

試題4?7考查面試者對內(nèi)存操作的理解程度，基本功扎實的面試者一般都

能正確的回答其中50?60的錯誤。但是要完全解答正確，卻也絕非易事。

軟件開發(fā)網(wǎng)

對內(nèi)存操作的考查主要集中在：

(1)指針的理解；

(2)變量的生存期及作用范圍；

(3)良好的動態(tài)內(nèi)存申請和釋放習慣。

再看看下面的一段程序有什么錯誤：

以下是引用片段：

swap(int*pl,int*p2)

(

int*p;

*p=*pl;

*pl=*p2;

*p2=*p;

)

在swap函數(shù)中，p是一個“野”指針，有可能指向系統(tǒng)區(qū)，導致程序運行的

崩潰。在VC++中DEBUG運行時提示錯誤"AccessViolatkm"。該程序應該改為

以下是引用片段：

swap(int*pl,int*p2)

intp;

p=*pl;

*pl=*p2;

*p2=p;

5O.String的具體實現(xiàn)

已知String類定義如下：

classString

(

public:

String(constchar*str=NULL);//通用構(gòu)造函數(shù)

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

?String。;〃析構(gòu)函數(shù)

String&operater=(constString&rhs);//賦值函數(shù)

private:

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

｝；

嘗試寫出類的成員函數(shù)實現(xiàn)。

答案：

String::String(constchar*str)

(

if(str=NULL)//strlen在參數(shù)為NULL時會拋異常才會有這步判斷

(

mdata=newchar[l];

m_data[0]='\0'；

)"

else

(

m_data=newchar[strlen(str)+1];

strcpy(m_data,str);

String::String(constString&another)

m_data=newchar[strlen(another.m_data)+1];

strcpy(m_data,other.m_data);

String&String:operator=(constString&rhs)

{

if(this==&rhs)

return*this;

delete[]m_data;//刪除原來的數(shù)據(jù)，新開一塊內(nèi)存

mdata=newchar[strlen(rhs.mdata)+1];

strcpy(m_data,rhs.m_data);

return*this;

String::-String()

{,

delete[]m_data;

51.h頭文件中的ifndef/define/endif的作用？

答：防止該頭文件被重復引用。

52.#include<file.h>與#inchide的區(qū)別？

答：前者是從StandardLibrary的路徑尋找和引用file.h,而后者是從當前工

作路徑搜尋并引用file.h。

53.在C++程序中調(diào)用被C編譯器編譯后的函數(shù)，為什么要加extern"C”？

C++語言支持函數(shù)重載，C語言不支持函數(shù)重載。C++提供了C連接交換指定符

號extern"C"

解決名字匹配問題。

首先，作為extern是C/C++語言中表明函數(shù)和全局變量作用范圍（可見性）的關(guān)

鍵字，該關(guān)鍵字告訴編譯器，其聲明的函數(shù)和變量可以在本模塊或其它模塊中使

用。

通常，在模塊的頭文件中對本模塊提供給其它模塊引用的函數(shù)和全局變量以關(guān)鍵

字extern聲明。例如，如果模塊B欲引用該模塊A中定義的全局變量和函數(shù)時

只需包含模塊A的頭文件即可。這樣，模塊B中調(diào)用模塊A中的函數(shù)時，在編

譯階段，模塊B雖然找不到該函數(shù)，但是并不會報錯；它會在連接階段中從模

塊A編譯生成的目標代碼中找到此函數(shù)

extern"C"是連接申明(linkagedeclaration),被extern"C"修飾的變量和函數(shù)是按照

C語言方式編譯和連接的,來看看C++中對類似C的函數(shù)是怎樣編譯的：

作為一種面向?qū)ο蟮恼Z言，C++支持函數(shù)重載，而過程式語言C則不支持。函數(shù)

被C++編譯后在符號庫中的名字與C語言的不同。例如，假設(shè)某個函數(shù)的原型

為：

voidfoo(intx,inty);

該函數(shù)被C編譯器編譯后在符號庫中的名字為_foo,而C++編譯器則會產(chǎn)生像

_foo_int_int之類的名字(不同的編譯器可能生版的名字不同，但是都采用了相

鬲桶I制，生成的新名字稱為“mangledname")。

_foo_int_int這樣的名字包含了函數(shù)名、函數(shù)參數(shù)數(shù)量及類型信息，C++就是靠

這種機制來實現(xiàn)函數(shù)重載的。例如，在C++中，函數(shù)voidfoo(intx,inty)與void

foo(intx,floaty)編譯生成的符號是不相同的,后者為_foo_int_float。

同樣地，C++中的變量除支持局部變量外，還支持類成員變量和全局變量。用戶

所編寫程序的類成員變量可能與全局變量同名，我們以"."來區(qū)分。而本質(zhì)上，編

譯器在進行編譯時，與函數(shù)的處理相似，也為類中的變量取了一個獨一無二的名

字，這個名字與用戶程序中同名的全局變量名字不同。

未加extern"C"聲明時的連接方式

假設(shè)在C++中，模塊A的頭文件如下：

//模塊A頭文件moduleA.h

#ifndefMODULEAH

//defineMODULEAH

intfoo(intx,inty);

#endif

在模塊B中引用該函數(shù)：

//模塊B實現(xiàn)文件moduleB.cpp

#include"moduleA.h"

foo(2,3)；

加extern"C"聲明后的編譯和連接方式

加extern"。，聲明后，模塊A的頭文件變?yōu)椋?/p>

//模塊A頭文件moduleA.h

#ifndefMODULE_A_H

#defineMODULEAH

extern"C"intfbo(intx,inty);

#endif

在模塊B的實現(xiàn)文件中仍然調(diào)用foo(2,3),其結(jié)果是：

(1)模塊A編譯生成fo。的目標代碼時，沒有對其名字進行特殊處理，采用了

C語言的方式；

(2)連接器在為模塊B的目標代碼尋找foo(2,3)調(diào)用時，尋找的是未經(jīng)修改的

符號名_foo。

如果在模塊A中函數(shù)聲明了foo為extern"C"類型，而模塊B中包含的是externint

foo(intx,inty),則模塊B找不到模塊A中的函數(shù)；反之亦然。

所以，可以用一句話概括extern"C”這個聲明的真實目的(任何語言中的任何語

法特性的誕生都不是隨意而為的，來源于真實世界的需求驅(qū)動。我們在思考問題

時，不能只停留在這個語言是怎么做的，還要問一問它為什么要這么做，動機是

什么，這樣我們可以更深入地理解許多問題)：實現(xiàn)C++與C及其它語言的混合

編程。

明白了C++中extern"C"的設(shè)立動機，我們下面來具體分析extern"C"通常的使用

技巧：

extern"C"的慣用法

(1)在C++中引用C語言中的函數(shù)和變量，在包含C語言頭文件(假設(shè)為

cExample.h)時，需進行下列處理：

extern"C"

(

#include"cExample.h"

而在C語言的頭文件中，對其外部函數(shù)只能指定為extern類型，C語言中不支持

extern"C"聲明，在.c文件中包含了extern"C"時會出現(xiàn)編譯語法錯誤。

C++引用C函數(shù)例子工程中包含的三個文件的源代碼如下:

/*c語言頭文件：cExample.h*/

#ifhdefC_EXAMPLE_H

#defineC_EXAMPLE_H

externintadd(intx,inty);

#endif

/*c語言實現(xiàn)文件：cExample.c*/

#include"cExample.h"

intadd(intx,inty)

(

returnx+y;

〃c+4?實現(xiàn)文件，調(diào)用add：cppFile.cpp

extern

(

#include"cExample.h"

}

intmain(intargc,char*argv[])

{」

add(2,3)；

return0;

)

如果C++調(diào)用一個C語言編寫的.DLL時，當包括.DLL的頭文件或聲明接口函數(shù)

時，應加extern"C"{}。

(2)在C中引用C++語言中的函數(shù)和變量時，C++的頭文件需添加extern"C",

但是在C語言中不能直接引用聲明了extern"。的該頭文件，應該僅將C文件中

將C++中定義的extern"C"函數(shù)聲明為extern類型。

C引用C++函數(shù)例子工程中包含的三個文件的源代碼如下：

//C++頭文件cppExample.h

#ifhdefCPPEXAMPLEH

#defineCPP_EXAMPLE_H

extern"C"intadd(intx,inty);

#endif

〃GH■實現(xiàn)文件cppExample.cpp

#include"cppExample.h"

intadd(intx,inty)

(

returnx+y;

/*C實現(xiàn)文件cFile.c

/*這樣會編譯出錯：#includencExample.hn*/

intmain(intargc,char*argv[])

{1

add(2,3);

return0;

15題目的解答請參考《C++中extern"C”含義深層探索》注解:

幾道c筆試題(含參考答案)

1.

WhatisdisplayedwhenfQiscalledgiventhecode:

classNumber{

public:

stringtype;

Number():type(“void"){}

explicitNum