2023年C++面試寶典版

１.nｅｗ、deleｔe、ｍallｏc、freｅ關系dｅｌeｔe會調用對象的析構函數,和nｅｗ相應free只會釋放內存,new調用構造函數。ｍalloc與free是C+＋/C語言的標準庫函數,nｅw/delete是C++的運算符。它們都可用于申請動態(tài)內存和釋放內存。對于非內部數據類型的對象而言，光用maloｃ/free無法滿足動態(tài)對象的規(guī)定。對象在創(chuàng)建的同時要自動執(zhí)行構造函數，對象在消亡之前要自動執(zhí)行析構函數。由于malloc/frｅe是庫函數而不是運算符，不在編譯器控制權限之內，不可以把執(zhí)行構造函數和析構函數的任務強加于ｍａｌloc/freｅ。因此C+＋語言需要一個能完畢動態(tài)內存分派和初始化工作的運算符new，以及一個能完畢清理與釋放內存工作的運算符delete。注意new/delete不是庫函數。２.dｅｌeｔｅ與deｌete[］區(qū)別deleｔe只會調用一次析構函數,而ｄelete[]會調用每一個成員的析構函數。在MoreEｆｆｅcｔｉveC+＋中有更為具體的解釋：“當delｅｔe操作符用于數組時，它為每個數組元素調用析構函數，然后調用opｅraｔorｄeｌeｔe來釋放內存?！眃eｌete與New配套，deleｔe[]與ｎew[]配套MemTest*mＴest１=newMemTeｓt[10］；MemTｅｓt*mTesｔ2=ｎewMemTesｔ;inｔ*ｐＩｎt１=nｅwiｎt[10]；ｉnｔ*pＩnt２=neｗint;deｌｅte[]pInt1;//-1-deletｅ［]ｐInt2;//－2-delete[］mＴeｓt１;//－3-deｌete[]mTest2;//-4-在-4-處報錯。這就說明:對于內建簡樸數據類型,dｅｌetｅ和dｅletｅ[]功能是相同的。對于自定義的復雜數據類型，delete和ｄeｌｅte[］不能互用。ｄelete[］刪除一個數組,delｅte刪除一個指針簡樸來說，用ｎｅw分派的內存用ｄelete刪除用nｅｗ[]分派的內存用delete[]刪除dｅlete[］會調用數組元素的析構函數。內部數據類型沒有析構函數，所以問題不大。假如你在用deletｅ時沒用括號,delｅte就會認為指向的是單個對象,否則，它就會認為指向的是一個數組。3.C和C++的共同點?不同之處?C是面向過程的語言,C++是HYPＥRLINK""\t"＿ｂlaｎｋ"面向對象,但是不全是。HＹＰERLINＫ""\t"＿ｂlank"JAVA是純ＨYPERLINK＂"＼t＂＿blank"面向對象在語言層面上,C++和JＡVA都基本同樣,只是JＡＶA語言去掉了指針,多繼承等容易犯錯的東東．現在的ＪAＶA不單純的是指語言,它是一個開發(fā)平臺的通稱,Jａｖa的通用性好,可以跨平臺直接移植，只要有安裝Ｊａｖa虛擬機（JVM）就可以了。開發(fā)的效率高。生成的機器碼效率沒有匯編和C的高。4.繼承的優(yōu)缺陷。類繼承是在編譯時刻靜態(tài)定義的,且可直接使用，類繼承可以較方便地改變父類的實現。但是類繼承也有一些局限性之處。一方面,由于繼承在編譯時刻就定義了,所以無法在運營時刻改變從父類繼承的實現。更糟的是,父類通常至少定義了子類的部分行為，父類的任何改變都也許影響子類的行為。假如繼承下來的實現不適合解決新的問題,則父類必須重寫或被其他更適合的類替換。這種依賴關系限制了靈活性并最終限制了復用性。（待補充)5.C++有哪些性質(面向對象特點）封裝，繼承和多態(tài)。在面向對象程序設計語言中，封裝是運用可重用成分構造軟件系統(tǒng)的特性,它不僅支持系統(tǒng)的可重用性,并且尚有助于提高系統(tǒng)的可擴充性;消息傳遞可以實現發(fā)送一個通用的消息而調用不同的方法;封裝是實現信息隱蔽的一種技術，其目的是使類的定義和實現分離。6．子類析構時要調用父類的析構函數嗎?析構函數調用的順序是先派生類的析構后基類的析構,也就是說在基類的的析構調用的時候,派生類的信息已經所有銷毀了定義一個對象時先調用基類的構造函數、然后調用派生類的構造函數;析構的時候恰好相反：先調用派生類的析構函數、然后調用基類的析構函數；JＡＶA無析構函數深拷貝和淺拷貝７．多態(tài),虛函數,純虛函數多態(tài)：是對于不同對象接受相同消息時產生不同的動作。Ｃ+＋的多態(tài)性具體體現在運營和編譯兩個方面:在程序運營時的多態(tài)性通過繼承和虛函數來體現；在程序編譯時多態(tài)性體現在函數和運算符的重載上虛函數：在基類中冠以關鍵字virtｕal的成員函數。它提供了一種接口界面。允許在派生類中對基類的虛函數重新定義。純虛函數的作用：在基類中為其派生類保存一個函數的名字，以便派生類根據需要對它進行定義。作為接口而存在純虛函數不具有函數的功能,一般不能直接被調用。從基類繼承來的純虛函數,在派生類中仍是虛函數。假如一個類中至少有一個純虛函數，那么這個類被稱為抽象類(ａbstractｃlasｓ)。抽象類中不僅涉及純虛函數,也可涉及虛函數。l抽象類必須用作派生其他類的基類，而不能用于直接創(chuàng)建對象實例。但仍可使用指向抽象類的指針支持運營時多態(tài)性。8．求下面函數的返回值（微軟)intｆuｎc(x)

{?intｃｏuntx=0;?wｈile(x)

{?countx＋+;

x=x＆(x-1);

}?reｔuｒncountx；?}假定x=9999。答案：8思緒：將x轉化為２進制，看具有的１的個數。9．什么是“引用”？申明和使用“引用”要注意哪些問題?答:引用就是某個目的變量的“別名”(ａliaｓ)，相應用的操作與對變量直接操作效果完全相同。申明一個引用的時候,牢記要對其進行初始化。引用聲明完畢后,相稱于目的變量名有兩個名稱，即該目的原名稱和引用名,不能再把該引用名作為其他變量名的別名。聲明一個引用,不是新定義了一個變量，它只表達該引用名是目的變量名的一個別名,它自身不是一種數據類型,因此引用自身不占存儲單元，系統(tǒng)也不給引用分派存儲單元。不能建立數組的引用。10.將“引用”作為函數參數有哪些特點？（1)傳遞引用給函數與傳遞指針的效果是同樣的。這時，被調函數的形參就成為本來主調函數中的實參變量或對象的一個別名來使用,所以在被調函數中對形參變量的操作就是對其相應的目的對象（在主調函數中)的操作。(2）使用引用傳遞函數的參數，在內存中并沒有產生實參的副本,它是直接對實參操作;而使用一般變量傳遞函數的參數,當發(fā)生函數調用時，需要給形參分派存儲單元,形參變量是實參變量的副本；假如傳遞的是對象,還將調用拷貝構造函數。因此,當參數傳遞的數據較大時，用引用比用一般變量傳遞參數的效率和所占空間都好。（３）使用指針作為函數的參數雖然也能達成與使用引用的效果,但是，在被調函數中同樣要給形參分派存儲單元,且需要反復使用"＊指針變量名"的形式進行運算,這很容易產生錯誤且程序的閱讀性較差；另一方面,在主調函數的調用點處,必須用變量的地址作為實參。而引用更容易使用，更清楚。1１.在什么時候需要使用“常引用”？假如既要運用引用提高程序的效率,又要保護傳遞給函數的數據不在函數中被改變,就應使用常引用。常引用聲明方式:consｔ類型標記符&引用名=目的變量名；例１ｉnta;

cｏnsｔiｎt&ra=ａ;

ｒa=1;／/錯誤

a＝1;//對的例2sｔriｎｇｆoo();?ｖｏidbａr(striｎg&s）;那么下面的表達式將是非法的:baｒ(ｆoｏ());?bar("heｌlｏwｏｒld");因素在于foｏ()和"helloworlｄ＂串都會產生一個臨時對象，而在C++中,這些臨時對象都是ｃoｎｓｔ類型的。因此上面的表達式就是試圖將一個const類型的對象轉換為非ｃonst類型，這是非法的。引用型參數應當在能被定義為cｏnsｔ的情況下,盡量定義為const。１2．將“引用”作為函數返回值類型的格式、好處和需要遵守的規(guī)則?格式:類型標記符&函數名（形參列表及類型說明）{/／函數體}好處：在內存中不產生被返回值的副本;(注意：正是由于這點因素,所以返回一個局部變量的引用是不可取的。由于隨著該局部變量生存期的結束，相應的引用也會失效,產生ｒuntimeeｒｒor!注意事項：（1)不能返回局部變量的引用。這條可以參照ＥffeｃtiveＣ+＋[1]的Item31。重要因素是局部變量會在函數返回后被銷毀，因此被返回的引用就成為了"無所指"的引用,程序會進入未知狀態(tài)。(２）不能返回函數內部new分派的內存的引用。這條可以參照EffectｉveC++[1］的Iｔｅm31。雖然不存在局部變量的被動銷毀問題，可對于這種情況(返回函數內部new分派內存的引用)，又面臨其它尷尬局面。例如，被函數返回的引用只是作為一個臨時變量出現,而沒有被賦予一個實際的變量，那么這個引用所指向的空間(由new分派）就無法釋放,導致memｏryｌeaｋ。(３)可以返回類成員的引用，但最佳是const。這條原則可以參照EffecｔiveC++[1]的Iｔeｍ30。重要因素是當對象的屬性是與某種業(yè)務規(guī)則(buｓinｅssrｕle)相關聯的時候,其賦值經常與某些其它屬性或者對象的狀態(tài)有關,因此有必要將賦值操作封裝在一個業(yè)務規(guī)則當中。假如其它對象可以獲得該屬性的非常量引用(或指針），那么對該屬性的單純賦值就會破壞業(yè)務規(guī)則的完整性。（4)流操作符重載返回值申明為“引用”的作用:流操作符<<和>>，這兩個操作符經常希望被連續(xù)使用，例如：ｃout<＜"hellｏ"<<endｌ;因此這兩個操作符的返回值應當是一個仍然支持這兩個操作符的流引用?？蛇x的其它方案涉及:返回一個流對象和返回一個流對象指針。但是對于返回一個流對象，程序必須重新(拷貝）構造一個新的流對象，也就是說,連續(xù)的兩個<<操作符事實上是針對不同對象的！這無法讓人接受。對于返回一個流指針則不能連續(xù)使用＜<操作符。因此，返回一個流對象引用是惟一選擇。這個唯一選擇很關鍵，它說明了引用的重要性以及無可替代性，也許這就是C++語言中引入引用這個概念的因素吧。賦值操作符=。這個操作符象流操作符同樣，是可以連續(xù)使用的,例如：x=j=10；或者(x=10)＝10０;賦值操作符的返回值必須是一個左值，以便可以被繼續(xù)賦值。因此引用成了這個操作符的惟一返回值選擇。例3＃inｃluｄe<ｉostｒｅam.h>

iｎt&puｔ(intn);?intvals[10];?interror=-1;

voidmaｉn（)?{

put(0)=10;//以put(０)函數值作為左值，等價于valｓ[０]=1０；

ｐut(9)=２0;//以ｐut（9)函數值作為左值,等價于ｖａls［9]＝２0;?cout<<ｖａls[0];

ｃout<<vals[9］；

}?int＆put(intｎ)?{

if（n>=0＆&n<=９)retｕrnvals［n］;?ｅlsｅ{ｃoｕt＜<"subsｃrｉpterｒor";ｒeturnｅｒｒｏr;}

｝（5）在此外的一些操作符中，卻千萬不能返回引用:+-*／四則運算符。它們不能返回引用，EｆｆecｔiveC++[1］的Ｉtem23具體的討論了這個問題。重要因素是這四個操作符沒有ｓideeffect,因此,它們必須構造一個對象作為返回值,可選的方案涉及:返回一個對象、返回一個局部變量的引用，返回一個new分派的對象的引用、返回一個靜態(tài)對象引用。根據前面提到的引用作為返回值的三個規(guī)則,第２、3兩個方案都被否決了。靜態(tài)對象的引用又由于((a+b）==(ｃ+ｄ））會永遠為true而導致錯誤。所以可選的只剩下返回一個對象了。13.“引用”與多態(tài)的關系?引用是除指針外另一個可以產生多態(tài)效果的手段。這意味著，一個基類的引用可以指向它的派生類實例。例4ClassA;ClassB:ＣlassA{...};Bｂ;Ａ＆ref=b;14.“引用”與指針的區(qū)別是什么?指針通過某個指針變量指向一個對象后,對它所指向的變量間接操作。程序中使用指針,程序的可讀性差；而引用自身就是目的變量的別名,對引用的操作就是對目的變量的操作。此外，就是上面提到的對函數傳rｅf和pointer的區(qū)別。１５.什么時候需要“引用”?流操作符＜<和＞>、賦值操作符＝的返回值、拷貝構造函數的參數、賦值操作符=的參數、其它情況都推薦使用引用。以上2-8參考：1６.結構與聯合有和區(qū)別？?（1）.結構和聯合都是由多個不同的數據類型成員組成,但在任何同一時刻，聯合中只存放了一個被選中的成員(所有成員共用一塊地址空間)，而結構的所有成員都存在（不同成員的存放地址不同)。

(2）.對于聯合的不同成員賦值,將會對其它成員重寫,本來成員的值就不存在了，而對于結構的不同成員賦值是互不影響的。17.面關于“聯合”的題目的輸出?a）＃include<stdio．ｈ>?uｎion?{

inｔi;

chaｒｘ[2];?}a；

voidmain（)?｛

ａ．ｘ[０]=10;

ａ.ｘ［１］=１;

prｉntf(＂%d",a．i);?}?答案：26６(低位低地址,高位高地址,內存占用情況是Ox０10Ａ）b）ｍaｉn()?{

ｕnioｎ｛/＊定義一個聯合*/?iｎti;

struct｛/*在聯合中定義一個結構*/?ｃｈarfirｓt;

charseｃoｎd;?｝hａlf;?｝nｕmbｅr;

number．i＝0x4241;／*聯合成員賦值*/?printｆ（"%c％ｃn",number.haｌf.fｉrsｔ，muｍｂer.hａｌｆ.secｏnd）；?numbｅｒ．hａｌf．firsｔ=＇a';/＊聯合中結構成員賦值*/?nuｍｂer.haｌf.ｓecond='b';?printf("%ｘn＂,numｂｅr．ｉ);

geｔch（)；

}

答案:AB(0x4１相應'A',是低位；Ox42相應'B＇,是高位)６２６１(number.i和number．hａlｆ共用一塊地址空間）18．關聯、聚合(Aggｒegatiｏn)以及組合(Ｃompｏsition)的區(qū)別?涉及到UML中的一些概念:關聯是表達兩個類的一般性聯系,比如“學生”和“老師”就是一種關聯關系;聚合表達has-a的關系，是一種相對松散的關系,聚合類不需要對被聚合類負責,如下圖所示,用空的菱形表達聚合關系：從實現的角度講，聚合可以表達為:cｌａｓsA{.．.}classＢ{A*ａ;..．..}而組合表達contaｉns-a的關系,關聯性強于聚合:組合類與被組合類有相同的生命周期,組合類要對被組合類負責,采用實心的菱形表達組合關系:實現的形式是：claｓsA｛...}clａｓｓB{Aa;...}１9.面向對象的三個基本特性,并簡樸敘述之?1.封裝:將客觀事物抽象成類,每個類對自身的數據和方法實行prｏtection（privａt(yī)e，prｏｔected,pｕbliｃ)2．繼承:廣義的繼承有三種實現形式：實現繼承（指使用基類的屬性和方法而無需額外編碼的能力）、可視繼承（子窗體使用父窗體的外觀和實現代碼）、接口繼承（僅使用屬性和方法,實現滯后到子類實現）。前兩種(類繼承）和后一種（對象組合=>接口繼承以及純虛函數）構成了功能復用的兩種方式。3.多態(tài):是將父對象設立成為和一個或更多的他的子對象相等的技術，賦值之后，父對象就可以根據當前賦值給它的子對象的特性以不同的方式運作。簡樸的說，就是一句話：允許將子類類型的指針賦值給父類類型的指針。20.重載（ovｅｒloaｄ)和重寫（overried,有的書也叫做“覆蓋”)的區(qū)別？?？嫉念}目。從定義上來說:重載：是指允許存在多個同名函數,而這些函數的參數表不同(或許參數個數不同,或許參數類型不同,或許兩者都不同）。重寫:是指子類重新定義父類虛函數的方法。從實現原理上來說:重載:編譯器根據函數不同的參數表，對同名函數的名稱做修飾，然后這些同名函數就成了不同的函數（至少對于編譯器來說是這樣的）。如，有兩個同名函數：ｆunｃｔionfunc（p:inｔegｅr）:inteｇer;和functionｆunｃ(p：stｒｉng):ｉnteger;。那么編譯器做過修飾后的函數名稱也許是這樣的：iｎt_func、ｓｔr_fｕｎc。對于這兩個函數的調用,在編譯器間就已經擬定了,是靜態(tài)的。也就是說，它們的地址在編譯期就綁定了(早綁定），因此，重載和多態(tài)無關!重寫:和多態(tài)真正相關。當子類重新定義了父類的虛函數后,父類指針根據賦給它的不同的子類指針，動態(tài)的調用屬于子類的該函數，這樣的函數調用在編譯期間是無法擬定的(調用的子類的虛函數的地址無法給出)。因此,這樣的函數地址是在運營期綁定的(晚綁定）。21.多態(tài)的作用？重要是兩個：1．隱藏實現細節(jié),使得代碼可以模塊化;擴展代碼模塊,實現代碼重用；2．接口重用:為了類在繼承和派生的時候,保證使用家族中任一類的實例的某一屬性時的對的調用。2２.Ado與Ａdｏ.ｎeｔ的相同與不同?除了“可以讓應用程序解決存儲于DＢMS中的數據“這一基本相似點外，兩者沒有太多共同之處。但是Ａdo使用ＯＬＥＤB接口并基于微軟的COM技術,而AＤO．NET擁有自己的ADO.NＥT接口并且基于微軟的．NEＴ體系架構。眾所周知.ＮET體系不同于COM體系，ADＯ.ＮET接口也就完全不同于ADＯ和OLEDB接口，這也就是說ADO.ＮEＴ和ＡDO是兩種數據訪問方式。AＤO.net提供對XML的支持。２３.Newdelete與ｍaｌｌoｃfree的聯系與區(qū)別？答案:都是在堆（hｅap)上進行動態(tài)的內存操作。用mａlloc函數需要指定內存分派的字節(jié)數并且不能初始化對象,nｅw會自動調用對象的構造函數。deletｅ會調用對象的deｓtrucｔｏｒ，而ｆree不會調用對象的deｓｔrｕctor.24.＃dｅfｉneDOUＢＬE(x)ｘ+x,i=5*DOUBLE(５)；i是多少?答案：i為3０。25.有哪幾種情況只能用intializaｔionｌｉｓt而不能用assｉｇnmenｔ？1.當類中具有consｔ、rｅferencｅ成員變量,對象成員;基類的構造函數都需要初始化。２．當基類有帶參構造,子類就應當聲明一個將參數傳遞給基類構造函數的途徑。3.當基類派生子類對象時,就要對基類數據成員等初始化。(1)#iｎｃlude<iostreaｍ>

usinｇｎameｓpacesｔd;claｓsＡ｛?prｉｖａｔe:?ｃｏｎsｔinta;//coｎst成員

ｃｏnstｉntb;/／const成員

public：

A(ｉnｔi,intｊ):ａ（ｉ),b(j）{}//必須在這里初始化?｝;intmａin(）{

Aａ(１,2）;

return0;?}(2)#ｉnｃludｅ<ioｓtｒｅａm>

usiｎｇnａmeｓpacｅstｄ;claｓｓA{?private:?inｔx1;?pｕbliｃ：?A(iｎｔｉ){／/只有一個帶參的構造函數

x１=i;?}?}；

ｃlaｓsB:ｐuｂlicA{

prｉvate:

iｎtx2;?public:?B(iｎti):Ａ（ｉ+10){/／必須在這里初始化?ｘ2=i;?}?}；ｉｎｔmain()｛

Ｂb（2）;

retuｒn０;

}26.C++是不是類型安全的？答案：不是。兩個不同類型的指針之間可以強制轉換(用ｒeｉntｅrpreｔcast)。C＃是類型安全的。２7.maiｎ函數執(zhí)行以前，還會執(zhí)行什么代碼?答案:全局對象的構造函數會在ｍａiｎ函數之前執(zhí)行。一、main結束不代表整個進程結束?（１)全局對象的構造函數會在main函數之前執(zhí)行,

全局對象的析構函數會在main函數之后執(zhí)行;?用ateｘiｔ注冊的函數也會在maiｎ之后執(zhí)行。?（２)一些全局變量、對象和靜態(tài)變量、對象的空間分派和賦初值就是在執(zhí)行ｍain函數之前，而ｍaiｎ函數執(zhí)行完后,還要去執(zhí)行一些諸如釋放空間、釋放資源使用權等操作

（３)進程啟動后，要執(zhí)行一些初始化代碼（如設立環(huán)境變量等），然后跳轉到maｉn執(zhí)行。全局對象的構造也在main之前。

二、maｉｎ(）之后執(zhí)行的代碼，用ａt(yī)exｉt注冊的函數也會在ｍaｉn之后執(zhí)行28.描述內存分派方式以及它們的區(qū)別?1)從靜態(tài)存儲區(qū)域分派。內存在程序編譯的時候就已經分派好，這塊內存在程序的整個運營期間都存在。例如全局變量,sｔaｔic變量。?２）在棧上創(chuàng)建。在執(zhí)行函數時,函數內局部變量的存儲單元都可以在棧上創(chuàng)建，函數執(zhí)行結束時這些存儲單元自動被釋放。棧內存分派運算內置于解決器的指令集。

3）從堆上分派,亦稱動態(tài)內存分派。程序在運營的時候用malloc或neｗ申請任意多少的內存,程序員自己負責在何時用frｅe或deｌete釋放內存。動態(tài)內存的生存期由程序員決定，使用非常靈活,但問題也最多。２9.stｒuｃt和cｌasｓ的區(qū)別答案：stｒucｔ的成員默認是公有的,而類的成員默認是私有的。struct和ｃｌass在其他方面是功能相稱的。從感情上講，大多數的開發(fā)者感到類和結構有很大的差別。感覺上結構僅僅象一堆缺少封裝和功能的開放的內存位，而類就象活的并且可靠的社會成員,它有智能服務，有牢固的封裝屏障和一個良好定義的接口。既然大多數人都這么認為,那么只有在你的類有很少的方法并且有公有數據（這種事情在良好設計的系統(tǒng)中是存在的!）時，你也許應當使用strucｔ關鍵字，否則，你應當使用class關鍵字。３0.當一個類A中沒有任何成員變量與成員函數，這時siｚeoｆ(A)的值是多少？答案:一個空類對象的大小是1ｂyte。這是被編譯器安插進去的一個字節(jié)，這樣就使得這個空類的兩個實例得以在內存中配置獨一無二的地址也就是說這個chａｒ是用來標記類的不同對象的。31.在8０８6匯編下，邏輯地址和物理地址是如何轉換的？(Inｔｅl)答案:通用寄存器給出的地址，是段內偏移地址,相應段寄存器地址*10H+通用寄存器內地址,就得到了真正要訪問的地址。32.比較Ｃ+＋中的４種類型轉換方式?類型轉換有c風格的，當然尚有ｃ＋+風格的。c風格的轉換的格式很簡樸(TYPE)EXＰＲＥSSION,但是c風格的類型轉換有不少的缺陷，有的時候用c風格的轉換是不合適的,由于它可以在任意類型之間轉換,比如你可以把一個指向cｏｎst對象的指針轉換成指向非consｔ對象的指針,把一個指向基類對象的指針轉換成指向一個派生類對象的指針,這兩種轉換之間的差別是巨大的,但是傳統(tǒng)的c語言風格的類型轉換沒有區(qū)分這些。尚有一個缺陷就是,c風格的轉換不容易查找,他由一個括號加上一個標記符組成,而這樣的東西在c+＋程序里一大堆。所以c＋＋為了克服這些缺陷，引進了4新的類型轉換操作符,他們是1.static_cast2.const_ｃast3．ｄynaｍic_ｃａｓt4.reｉntｅrpret_cａｓt.1.static_cａst最常用的類型轉換符，在正常狀況下的類型轉換,如把ｉｎt轉換為flｏat,如：ｉntｉ;floａt(yī)f;f=（floａt(yī)）ｉ；或者f＝ｓtatic_caｓｔ<fｌoat>（i);２.const_ｃast用于取出const屬性,把cｏnst類型的指針變?yōu)榉莄onｓt類型的指針，如:conｓtｉｎt*fuｎ(intｘ,inｔy）｛｝inｔ*ptｒ=ｃonst_casｔ<ｉnt*＞(fun（2.3）)３．ｄynamic_ｃａst該操作符用于運營時檢查該轉換是否類型安全，但只在多態(tài)類型時合法,即該類至少具有一個虛擬方法。ｄynamｉc＿cast與staｔic_caｓt具有相同的基本語法，dynamic_cast重要用于類層次間的上行轉換和下行轉換,還可以用于類之間的交叉轉換。在類層次間進行上行轉換時，ｄyｎａmic_casｔ和sｔatｉｃ_cast的效果是同樣的;在進行下行轉換時,ｄynａmic_cast具有類型檢查的功能,比staｔｉc＿cast更安全。如:cｌassC｛//…C沒有虛擬函數

}；ｃlassT｛

/／…｝?iｎｔｍaｉn()?｛dｙnamic_cａsｔ<T*＞(newC);//錯誤?}此時如改為以下則是合法的:?ｃｌassC｛?pｕbｌｉc:

virｔuaｌvoidm()｛}；/／C現在是多態(tài)?｝4.ｒeiｎｔerpret_ｃastinterprｅt是解釋的意思,rｅinｔerｐret即為重新解釋，此標記符的意思即為數據的二進制形式重新解釋,但是不改變其值。如：ｉnti;char*pｔr="helloｆreｉnｄ!＂;i=rｅｉnterpret_cａsｔ<ｉnt＞(ｐtr);這個轉換方式很少使用。3３.分別寫出BOＯL,inｔ,floａt(yī)，指針類型的變量a與“零”的比較語句。答案:

BOOL：if(!a)ｏrif（ａ)

inｔ：if(ａ==0)?ｆloat：ｃｏｎｓtEＸPRＥSSIONEXＰ=０.０0000１

if（a＜EＸP&&a>-ＥXP)fｌｏata;?consｔｆloａt(yī)eps＝０．００00０1;?ｉf（（a＞=-ｅｐs)＆&(a<=ｅpｓ)）?poｉntｅr:if(a!=NULL)ｏrif（a＝=ＮUＬL)34.請說出const與#dｅｆinｅ相比,有何優(yōu)點?答案：Ｃｏnｓt作用:定義常量、修飾函數參數、修飾函數返回值三個作用。被Ｃonst修飾的東西都受到強制保護,可以防止意外的變動,能提高程序的健壯性。1)cｏｎｓt常量有數據類型，而宏常量沒有數據類型。編譯器可以對前者進行類型安全檢查。而對后者只進行字符替換，沒有類型安全檢查,并且在字符替換也許會產生意料不到的錯誤。

2）有些集成化的調試工具可以對consｔ常量進行調試，但是不能對宏常量進行調試。3５.簡述數組與指針的區(qū)別?數組要么在靜態(tài)存儲區(qū)被創(chuàng)建(如全局數組）,要么在棧上被創(chuàng)建。指針可以隨時指向任意類型的內存塊。?(１)修改內容上的差別

chara[］=“hｅｌｌo”;

a[0］=‘X’;

char*p=“worｌｄ”;／/注意ｐ指向常量字符串?p［０]=‘Ｘ’;／/編譯器不能發(fā)現該錯誤,運營時錯誤?(2)用運算符siｚeof可以計算出數組的容量（字節(jié)數）。ｓizeｏf（ｐ）,p為指針得到的是一個指針變量的字節(jié)數,而不是p所指的內存容量。C＋+/C語言沒有辦法知道指針所指的內存容量，除非在申請內存時記住它。注意當數組作為函數的參數進行傳遞時,該數組自動退化為同類型的指針。

charａ［]=＂heｌlｏwoｒld";

ｃhaｒ＊p=a;?cｏuｔ＜<sizｅｏf(a)<<endｌ;//12字節(jié)

ｃout＜<sizｅof(p)<<endl;／/４字節(jié)

計算數組和指針的內存容量

voidＦｕnｃ(chaｒa[１00]）?{

cout<<sizeof(a)<<endl;/／4字節(jié)而不是100字節(jié)?｝36.類成員函數的重載、覆蓋和隱藏區(qū)別?答案:a.成員函數被重載的特性:

（１)相同的范圍（在同一個類中);

(2)函數名字相同;?(3)參數不同;?（4）ｖirtual關鍵字可有可無。?b．覆蓋是指派生類函數覆蓋基類函數，特性是:?（1)不同的范圍(分別位于派生類與基類);?（2）函數名字相同；

(3)參數相同;

(4）基類函數必須有virtuaｌ關鍵字。?c.“隱藏”是指派生類的函數屏蔽了與其同名的基類函數，規(guī)則如下：

(1）假如派生類的函數與基類的函數同名，但是參數不同。此時,不管有無vｉrtual關鍵字,基類的函數將被隱藏(注意別與重載混淆）。

(2)假如派生類的函數與基類的函數同名,并且參數也相同，但是基類函數沒有vｉrｔual關鍵字。此時,基類的函數被隱藏(注意別與覆蓋混淆）37．求出兩個數中的較大的一個;不用ｉf,?:；switｃh或其他比較判斷Thereａreｔｗoｉntvariaｂlｅs:aandb,ｄon’tuse“if”,“?:”,“switch”oroｔｈerjｕｄｇemenｔstateｍｅnts，findoutthｅbｉｇgeｓｔoｎeofｔhetwonｕmｂeｒs.答案:(（a+b)+ａbｓ(a-ｂ)）／２假如ａ>b,那么a－b>０,所以表達式就變成了(ａ+ｂ＋a-b）/２=(a+a）/2=a。

假如ａ<ｂ，那么a－ｂ<0，取絕對值變成-(a-b),所以表達式變成了（a+b-a+b)/2＝(ｂ＋b)/2＝ｂ。?總的來說就是取a和ｂ中的最大值max。38.如何打印出當前源文獻的文獻名以及源文獻的當前行號?答案：

ｃout<<__FＩＬE__；?ｃoｕt＜＜__ＬINE__;

＿_FＩLE__和_＿LＩＮE__是系統(tǒng)預定義宏，這種宏并不是在某個文獻中定義的，而是由編譯器定義的。39.ｍａin主函數執(zhí)行完畢后，是否也許會再執(zhí)行一段代碼,給出說明？答案:可以，可以用＿oｎexｉt注冊一個函數,它會在main之后執(zhí)行intfｎ1(vｏid),fn2(void),fn3(vｏid),ｆn4(vｏid);

ｖｏidｍaiｎ(voｉd)?{

Ｓtringstr（"zｈaｎglｉn＂);

_onｅxｉt(fn1）;

_oneｘｉt(ｆn２）;?_oｎexit(fn３）;

_oｎｅxit(fn4);

ｐrintf("Thiｓｉsexｅｃｕteｄｆirｓt．n");?}?inｔｆn1()?｛?ｐｒintｆ("ｎexｔ.ｎ");?rｅturn0;?}?intfn2()

{

printｆ(＂eｘｅcuted＂）;

rｅturｎ0;?｝?intｆn3()

｛?priｎtf(＂is");?retuｒn0;?}?iｎtfn4()?{?prｉnｔf(＂This＂);?ｒeｔurn0；?}?Thｅ_oｎexiｔfunｃtｉoｎｉｓｐaｓｓedｔheadｄressoｆafunctiｏn(fｕnc）tobecalledwhｅｎthepｒoｇraｍteｒmiｎatｅsnｏrmalｌy.Ｓuccｅssiｖｅcallsto_onexitｃreaｔeaｒegisｔeｒｏfｆunctiｏnsthaｔａreexecuｔｅｄinLＩFＯ(last-ｉｎ-ｆiｒsｔ-out)oｒdｅr.Ｔｈefunctｉonｓpasseｄｔo＿oｎｅxｉtcannｏttakeparａmｅters.４０.如何判斷一段程序是由Ｃ編譯程序還是由C++編譯程序編譯的?答案:?#ifｄef＿_ｃplusｐｌus

cout<<"ｃ＋+＂;

#ｅlsｅ

cｏｕｔ＜<"ｃ";?#eｎdiｆ(1）假如是要你的代碼在編譯時發(fā)現編譯器類型，就判斷_cplusplus或_ＳTDC_宏,通常許多編譯器尚有其他編譯標志宏，#ifdef_＿cplｕｓpｌuscout<<"c＋＋";＃elsecouｔ<<"c＂；#endｉf假如要判斷已經編譯的代碼的編譯類型，就用nm查一下輸出函數符號是否和函數名相同。（相同為c,不同為c+＋。詳解見下面）(２）簡樸是說，由于c語言是沒有重載函數的概念的,所以c編譯器編譯的程序里,所有函數只有函數名相應的入口。而由于ｃ++語言有重載函數的概念,假如只有函數名相應的入口，則會出現混淆，所以c++編譯器編譯的程序,應當是函數名+參數類型列表相應到入口。注意,由于miaｎ函數是整個程序的入口，所以mian是不能有重載的,所以，假如一個程序只有maｉn函數,是無法確認是c還是c＋+編譯器編譯的可以通過nm來查看函數名入口如一個函數iｎtｆｏo(intｉ,floatｊ)c編譯的程序通過nｍ查看fｏo0x567xｘxxｘx(地址）ｃ＋+編譯程序,通過nm查看foo（int,ｆloａt(yī)）０ｘ567xxxxｘx此外,假如要在c++編譯器里使用通過ｃ編譯的目的文獻，必須告知ｃ＋+編譯器，我使用的函數是c風格的,不需要列出參數列表的,這樣c++編譯才干對的的連接41．文獻中有一組整數,規(guī)定排序后輸出到另一個文獻中?答案:＃include＜ioｓｔream＞#incｌude<vector>#inclｕde<fｓｔrｅam>usingnamespaceｓtd;vｏｉdBubbｌｅSｏrt(veｃtor＜iｎt>＆array）{ｆor(intｉ=0；i!=arｒａｙ．ｓize(）;i＋＋)｛foｒ（intj＝arrａy.ｓｉｚe()－１;j!＝i；j-－){if(array[j]<ａrray［j-1]){swap（ａrｒay[j］,array［j-1]);}}｝}voｉｄswａp（iｎt*ａ，int＊b){intｔｅmp;temp=*a;＊ａ=*b；*b=tｅmp;}voidmaiｎ()｛ｖectｏr<int>data；ｉfｓtreaｍiｎ("c：\\dａt(yī)a.txt")；if(!in){cｏｕt<<＂ｆiｌeerrｏｒ！"<＜enｄl;ｅxｉｔ(1);}inttemｐ;ｗhilｅ(!ｉn．ｅof()）{iｎ＞＞ｔemp；ｄata.push＿ｂack(tｅmp）;｝in．closｅ()；BubbｌeSorｔ（data);oｆstrｅaｍout(＂c:＼\result．ｔｘt")；if（!ouｔ）{coｕt＜<"fileｅrror!"<<ｅｎdl;exit（１)；}for(ｉnｔi＝0;i<data.sｉｚe(）；ｉ+＋)oｕt<<datａ[i]<<"";oｕｔ．ｃlose(）;}42．鏈表題：一個鏈表的結點結構//與結構類型組合使用typedｅfstrｕcttａｇMySｔｒuct{inｔiNuｍ；ｌｏnglLeｎgth；｝ＭyStrucｔ;／／（此處MySｔruｃt為結構類型別名）=＞struｃｔtagMyStruct｛intｉＮuｍ；longlLenｇtｈ；};//+typeｄefstｒｕcttaｇMyStrｕｃtＭyＳtｒuct;／／結構中包含指向自己的指針用法tｙpedｅfstruｃtｔａgNoｄe{ｃhar*pIteｍ;pNoｄeｐNext;}＊ｐＮoｄe;//=＞ｅrrｏr//1)ｔypedefstｒｕctｔagNode{ｃhar*pItｅm;ｓtrucｔtａｇＮode*pNeｘt;｝*pNodｅ;//2）typedefstｒuctｔaｇNode*ｐNodｅ；ｓtｒucttaｇNode{cｈar*pＩｔem;pNodepNext；};/／3)規(guī)范strucｔtagNｏdｅ{chaｒ*ｐＩteｍ;ｓtｒucｔtａgＮode*pNext;｝;typeｄeｆｓtruｃttagNodｅ＊pNｏde;strｕctＮodｅ

｛?inｔdatａ;

Nodｅ*neｘt;

};

tyｐedefstructNoｄｅNodｅ;?(1)已知鏈表的頭結點head,寫一個函數把這個鏈表逆序（Intel)Nｏde*RｅverseList(Nｏdｅ*head)//鏈表逆序

｛

if(head==NＵLL||head－>nｅｘt＝=NＵLL)

ｒｅtｕrnhｅad;?Nodｅ*ｐ1=hｅad；?Node＊ｐ2=p1->next；

Ｎoｄe*p3=ｐ２->nexｔ;?p1－>next=NULL;?whｉle(p3!＝NULL)?{

p2->nexｔ=p1;?p１＝p2;

p2＝ｐ3;

p3=p3->neｘt;?}?p2->neｘｔ=p1;?heａd=ｐ2;

ｒeｔurnheａd;?}?（2)已知兩個鏈表head1和head2各自有序,請把它們合并成一個鏈表仍然有序。(保存所有結點，即便大小相同)

Ｎode*Merge(Nｏｄe＊heａd1，Ｎode*ｈead2)

{

if(hｅad１==ＮULL)?reｔurｎheａd2;?ｉf（head2==ＮULＬ）?ｒｅｔuｒｎheaｄ1;?Node*head=NUＬL;?Ｎode*ｐ1=NＵLL;

Ｎoｄe*ｐ２=NULL；

ｉf（ｈeａd1->ｄata<head2->dａt(yī)ａ)?{?ｈeａｄ=ｈead１;?p１=head1->ｎext;

p２=head2;

｝

else?{?hｅad＝ｈead2；?p2=head2->nｅｘt;

ｐ１=ｈead１;

}?Node＊ｐcuｒrenｔ=heaｄ;

whilｅ(p１!=NＵLＬ&&ｐ2!＝NＵLＬ）

{?ｉf（p1－>data＜＝p2->datａ)?{

pcｕrｒent-＞next=p1;?ｐcｕｒreｎt=p１;

p1＝p１->next;?}?ｅｌse

{?ｐcurrｅnt-＞next=p2;

pｃuｒrent=p2；?p２=p２->next;?}?｝

iｆ(p1!=ＮULＬ）?pcurrent－＞nｅｘt=p1;

ｉｆ(p2!＝NULL)?pｃｕｒrent->neｘｔ=p2;?reｔurnhead;?｝

(3）已知兩個鏈表hｅad1和head2各自有序，請把它們合并成一個鏈表仍然有序，這次規(guī)定用遞歸方法進行。(Aｕｔｏdｅsｋ)?答案：?Nｏde*MeｒgeRｅｃursive(Nｏdｅ＊heａd1,Noｄe*ｈead2）

{

ｉｆ(hｅａd１==NULL)

returnhead2;?ｉf(heaｄ２==NULＬ)

ｒetuｒnhｅad1；?Nｏｄｅ*ｈead＝NUＬL;

if(heaｄ1－>daｔa<ｈead2-＞ｄatａ）?{?ｈead=heａd1；?head-＞next=MeｒgｅＲeｃuｒsｉve(head１->next，hｅad２)；

}?else?{?head=head2;

ｈｅaｄ->next=MergeRecｕrsiｖe(heａd1,ｈｅad2->nｅxt)；

}?reｔurnｈｅad;--－－----－-４1.分析一下這段程序的輸出（Autｏｄesｋ）

classB?{?public:?B()

｛

cout＜<"ｄｅｆaulｔｃｏnstｒuctor"＜<endｌ;?}?~Ｂ()

{

cｏuｔ＜<"dｅstructed"<<enｄl；?}

B(inti）:ｄata(ｉ）//B（inｔ)woｒｋｓaｓacｏnｖｅｒter(ｉnｔ-＞ｉｎstａncｅoｆB)?{

cｏuｔ<<"ｃｏｎstructｅdｂyparameｔer＂＜<ｄata<<endｌ;?}

privａt(yī)ｅ：?iｎｔdａｔａ；?｝;

BPlay(Bb)?｛

rｅtｕrｎｂ;

}（1)results:

intmain（iｎtargc,char*argｖ［］）ｃoｎsｔructedbypａrameteｒ5?{dｅｓtruｃtｅｄB(5)形參析構?Bｔ1＝Pｌay(５);Ｂt2=Ｐl(wèi)aｙ(t1）;destrucｔｅdt1形參析構

retuｒn0；destrｕctedt2注意順序！

｝ｄｅsｔrｕcｔｅdt１(2）ｒeｓults：

intｍaｉn(ｉntarｇc,ｃhaｒ＊argv[]）constructｅdbypaｒameter5

｛deｓtruｃｔedB(5）形參析構?Bt1＝Ｐl(wèi)ay(５）；Bt2=Plaｙ(1０);ｃonsｔｒucｔedｂyparameter1０?rｅｔuｒn0;dｅstｒuctｅdB(1０）形參析構

}ｄｅｓｔｒucｔeｄt2注意順序?。鋏structeｄt１43.寫一個函數找出一個整數數組中,第二大的數(microsｏft）答案:

ｃｏnstｉｎtMINＮUMBER＝-３2767;?inｔｆind_sec_maｘ(iｎtｄata[]，intｃounｔ)?{

iｎｔmａxnumber=dａｔa［0];

iｎtsｅｃ_max=MIＮNUＭBＥR；

for(ｉntｉ=１;i<count;i++)?{?if(daｔａ[i]>maｘnuｍber)

{?sｅｃ_max＝ｍaｘnｕｍbeｒ；?maxｎumber=dａt(yī)a[i];?}?else

{?if(data［i]>sec_mａx）?ｓｅc_ｍax=ｄａt(yī)ａ[ｉ];

}?｝

ｒeturnsec＿mａｘ；?｝44.寫一個在一個字符串（n)中尋找一個子串（m）第一個位置的函數。KMＰ算法效率最佳，時間復雜度是Ｏ(n+m),＃iｎcｌｕde<iｏstreaｍ>inｔSeａｒｃh(ｃhａr＊Str，chａr*Suｍ){intl1=strｌｅn(Stｒ）;ｉｎtl2=strlen(Ｓuｍ);if(l1-l2<0）//假如子串大于字符串長度直接返回return-1;inti;ｆor(i=０;ｉ<l1-l2;i++){iｎtm=ｉ；ｉntj;for（j＝0;ｊ<l２；j+＋){if（Sｔr[m］!＝Sum[ｊ])//有不匹配字符直接跳出break;m＋+;｝if(ｊ＝=l2)/／找到匹配,跳出循環(huán)ｂrｅak;}retuｒｎi＜=ｌ1-l2?i：－１;}voidmaiｎ(）{chａrStr［15]="abdedabjlfdf"；charSｕm[４]="ａj";std::coｕｔ<<Sｅａｒch(Sｔr，Sum);getｃhａr（）;}4６.多重繼承的內存分派問題：比如有classA:publicclassB,ｐublicclａssC{｝那么A的內存結構大體是怎么樣的？?這個是compiｌeｒ-ｄependeｎｔ的，不同的實現其細節(jié)也許不同。假如不考慮有虛函數、虛繼承的話就相稱簡樸;否則的話，相稱復雜?？梢詤⒖肌哆M一步探索C＋+對象模型４7.如何判斷一個單鏈表是有環(huán)的？（注意不能用標志位,最多只能用兩個額外指針)stｒuctnｏｄe｛ｃharｖal;node*ｎｅxt;}?boolcｈｅck(cｏnsｔｎode*hｅad){｝//retｕｒnfaｌse：無環(huán)；truｅ:有環(huán)一種O(n）的辦法就是(搞兩個指針,一個每次遞增一步,一個每次遞增兩步,假如有環(huán)的話兩者必然重合,反之亦然）：

bｏolchecｋ（ｃｏnstnode*heaｄ）

｛

if(head＝=NＵLL)returnｆalｓe;?nodｅ*ｌｏｗ=heaｄ,*faｓｔ=heａd->ｎｅｘｔ;

whiｌｅ(fａst!=ＮULL&&ｆａst－>next！=NＵLL）

{?loｗ=loｗ->ｎext;

fast=fast－>ｎext->ｎeｘt;?if(lｏw==faｓt)retｕｒntｒue;

}?retｕrnｆａlｓe;?}48．指針找錯題分析這些面試題，自身包含很強的趣味性;而作為一名研發(fā)人員，通過對這些面試題的進一步剖析則可進一步增強自身的內功。?2．找錯題試題1：

以下是引用片段:

vｏｉdtｅｓt１（）／/數組越界?｛

ｃｈaｒstrｉnｇ[10]；

ｃhａr*sｔｒ1=＂＂;

ｓｔｒcpy(striｎg,ｓtr１）;

}

試題2:?以下是引用片段:?voｉｄtｅst2()

｛

cｈaｒstｒing[10],str1[１0］;

intｉ;

foｒ(i＝0;i<１0;ｉ++）?{

str１='a＇;?}

stｒｃｐy(string,sｔr1）;?}

試題3：?以下是引用片段:?vｏｉdteｓt3(ｃhａr*str1）?{?charstrｉｎg［10];

if(strlｅn（sｔr1)<＝1０)?{

stｒcｐy(ｓtｒinｇ,ｓｔｒ１）；

}?}

解答:

試題1字符串ｓtｒ1需要11個字節(jié)才干存放下（涉及末尾的’＼0’),而ｓtｒing只有10個字節(jié)的空間，strcpｙ會導致數組越界；對試題2，假如面試者指出字符數組ｓｔr1不能在數組內結束可以給3分；假如面試者指出ｓtｒcpy(string,str1)調用使得從str1內存起復制到ｓｔｒing內存起所復制的字節(jié)數具有不擬定性可以給７分，在此基礎上指出庫函數stｒcpy工作方式的給10分;

對試題3,if(strｌen(str1)＜=10)應改為if(ｓtrlen(str1)<１0)，由于ｓtrlｅn的結果未記錄’＼０’所占用的1個字節(jié)。剖析：考核對基本功的掌握

（１)字符串以’\０’結尾;?(２）對數組越界把握的敏感度；

(3)庫函數strcpｙ的工作方式,49.假如編寫一個標準sｔｒcpy函數總分值為1０，下面給出幾個不同得分的答案:2分以下是引用片段：?voidsｔrcｐy(char*ｓtｒDｅst,cｈａr*sｔｒSｒｃ）

{

while（(*strDeｓt＋+=*ｓtｒＳrc++)！=‘＼0’);?｝

4分以下是引用片段：?voidsｔｒｃpｙ（cｈar*stｒDest,constｃhaｒ*sｔｒＳｒｃ)

/／將源字符串加ｃoｎsｔ,表白其為輸入參數,加2分

｛?whｉlｅ((*ｓｔｒＤest++＝＊sｔrＳrc＋+)!=‘\０’);?}?７分以下是引用片段：?voidstrcpy(cｈar＊ｓtrDest,conｓtcｈar＊stｒSrc）?{?//對源地址和目的地址加非0斷言,加3分

aｓserｔ((ｓtrDｅｓt!=NULＬ)&&(strSrc!=NULL));?ｗhｉle（(*strDeｓt+＋=*ｓtｒSrc+＋)！＝‘\0’);?｝?10分以下是引用片段：

／/為了實現鏈式操作，將目的地址返回,加3分!

cｈaｒ*ｓｔrcpｙ（ｃhar＊strDest，ｃoｎsｔchar*ｓtrSrｃ)

{

ａssｅrt(（sｔｒDest!=NULL)&&(strSrｃ！＝NUＬL));

cｈar*addｒess=ｓtｒＤｅst;?while((*ｓtｒDest++＝*sｔrSrｃ＋＋)!=‘\0’）;

returnadｄress;

}?從２分到10分的幾個答案我們可以清楚的看到,小小的strcpｙ居然暗藏著這么多玄機,真不是蓋的!需要多么扎實的基本功才干寫一個完美的ｓｔrｃpy啊!

（4）對strlen的掌握，它沒有涉及字符串末尾的'\０'。?讀者看了不同分值的strcｐy版本,應當也可以寫出一個10分的stｒlｅn函數了,完美的版本為:iｎｔstrlen(consｔｃｈaｒ*stｒ)／／輸入參數coｎst以下是引用片段:

{

ａｓsｅｒt(strt!=NULL）;//斷言字符串地址非0

ｉntlen=０；//注，一定要初始化。?whilｅ（（*sｔr++)?。?＼0')?{?ｌｅn++;

}?returnleｎ;

｝?試題４：以下是引用片段:

voidGeｔMemｏｒy（char*p)

｛

p＝(ｃhar*）mａｌloc(１０0）;

}

voiｄTｅｓt(ｖｏid）

{?char*ｓｔr=NＵLＬ;

GetMｅｍory（stｒ）;?sｔrcｐｙ（str,＂heｌlowoｒld");

ｐrintf(str);

}

試題5：

以下是引用片段：

cｈar*GeｔＭemory(ｖoid)

｛?cｈarp[]="ｈelloｗoｒld";?ｒetｕｒnp；

}?voidTｅst(void)

{?ｃhar*sｔr=NULＬ;

str=ＧetＭeｍory();?printf(str);

}

試題6：以下是引用片段：?voidGeｔＭemory(ｃｈaｒ**ｐ,intｎｕm)

{?*p＝(cｈaｒ*)mａllｏｃ(nuｍ);?}?vｏidTesｔ(void)?｛

ｃｈar*str=NUＬL;

GeｔＭeｍorｙ(&str，10０)；?sｔrｃpｙ(sｔr,"hｅllo")；

pｒintｆ(ｓtｒ）；

}

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

voｉdTest(ｖoｉd）?｛?ｃhaｒ*str=(char*)ｍａlｌoｃ(10０);

strｃpy(stｒ,"hello＂);?free(str)；?．..／／省略的其它語句

}

解答:試題４傳入中ＧｅｔMeｍoｒy(cｈar＊p)函數的形參為字符串指針,在函數內部修改形參并不能真正的改變傳入形參的值,執(zhí)行完

chａr*str=NULL;

GｅtMeｍｏry(stｒ);

后的sｔｒ仍然為NULL;試題5中?cｈａｒp［]＝"hｅlloｗoｒld＂;?reｔurｎｐ;?的p[]數組為函數內的局部自動變量，在函數返回后，內存已經被釋放。這是許多程序員常犯的錯誤,其根源在于不理解變量的生存期。?試題６的GeｔMemory避免了試題4的問題，傳入GetMemｏrｙ的參數為字符串指針的指針,但是在ＧetMｅｍory中執(zhí)行申請內存及賦值語句tｉffａｎyｂrａceleｔｓ?*ｐ＝(ｃｈar*)malｌoc(num)；

后未判斷內存是否申請成功，應加上:

if（*p==NULL)?｛?...／/進行申請內存失敗解決

}?試題7存在與試題6同樣的問題,在執(zhí)行?ｃｈaｒ*str=(char*）mａｌloc(10０);

后未進行內存是否申請成功的判斷；此外，在fｒeｅ(ｓtr)后未置sｔr為空,導致也許變成一個“野”指針,應加上：?str=NULL;?試題6的Test函數中也未對ｍaｌloc的內存進行釋放。?剖析：

試題４~７考察面試者對內存操作的理解限度,基本功扎實的面試者一般都能對的的回答其中50～60的錯誤。但是要完全解答對的，卻也絕非易事。

對內存操作的考察重要集中在:?(１)指針的理解;?(2）變量的生存期及作用范圍;?（3）良好的動態(tài)內存申請和釋放習慣。?再看看下面的一段程序有什么錯誤:

以下是引用片段：?sｗap(int*p1,inｔ*ｐ2)

{?ｉnt*p;?＊p=＊p1;?*p1=*p2;

*p２=*ｐ;

}

在swap函數中,p是一個“野”指針，有也許指向系統(tǒng)區(qū),導致程序運營的崩潰。在VC++中ＤEＢUG運營時提醒錯誤“AccessVioｌaｔｉon”。該程序應當改為

以下是引用片段：

sｗaｐ(iｎt*p1,iｎt*ｐ２）?{

inｔp;

p＝*ｐ1;?*p1＝*p2;

＊p2＝p;

}５0.Ｓtriｎg的具體實現已知Strｉng類定義如下：??ｃlａsｓSｔrｉｎｇ?{

pｕblic:?String(conｓtchar＊str=NULＬ);//通用構造函數?Ｓtriｎg(consｔＳｔring&aｎoｔher);//拷貝構造函數

~Ｓtring();//析構函數

Ｓtｒｉng＆opｅratｅｒ=(conｓtStｒing＆rhs)；//賦值函數

private:

cｈａｒ*m_dａt(yī)a；／／用于保存字符串

};

?嘗試寫出類的成員函數實現。

答案：?String：：Sｔrｉng(cｏｎsｔchar*str)?{?if(stｒ==ＮUＬL)／/sｔrlen在參數為ＮUＬＬ時會拋異常才會有這步判斷?{?m_ｄaｔa=nｅｗchar[1];

m＿data［0]＝'＼０';

}

else

{?m＿datａ=ｎeｗchar[strleｎ(str）+１]；

strcｐy(m_datａ,str);

}?

}?

Stｒｉng::Strinｇ(conｓtStｒiｎｇ＆ａnotｈer){?m_ｄaｔa=neｗchａr［strlen（anｏｔheｒ.m_daｔａ）+1]；?ｓｔrｃpy(m＿daｔａ,oｔｈer.m_data);

}

?Striｎg&Sｔrｉng：:ｏperａt(yī)or＝（coｎsｔＳｔring&rhs)?{?if（tｈis=＝&rhs)?reｔuｒn＊thiｓ;?ｄeｌeｔe[]m_daｔa;//刪除本來的數據,新開一塊內存?m_daｔa＝ｎewchar[sｔｒｌeｎ(rｈs．m＿dａt(yī)ａ)+1］;?strcpｙ（ｍ_datａ,rhs.m_data）；

retuｒn＊tｈis；?}???String：：~Stｒing(）?｛

ｄelｅtｅ［]m＿ｄata;

}51．h頭文獻中的ｉｆｎdef／ｄeｆine/endif的作用?答:防止該頭文獻被反復引用。52.＃ｉnｃlｕde<filｅ.h>與#ｉncluｄe"fiｌｅ.h"的區(qū)別？答:前者是從StandardLibrａry的途徑尋找和引用ｆile.h,而后者是從當前工作途徑搜尋并引用filｅ．ｈ。５3.在Ｃ++程序中調用被C編譯器編譯后的函數,為什么要加eｘtｅrｎ“C”？C++語言支持函數重載，C語言不支持函數重載。C+＋提供了C連接互換指定符號eｘteｒｎ“C”解決名字匹配問題。?一方面,作為exｔeｒn是Ｃ/C++語言中表白函數和全局變量作用范圍(可見性）的關鍵字,該關鍵字告訴編譯器，其聲明的函數和變量可以在本模塊或其它模塊中使用。

?通常，在模塊的頭文獻中對本模塊提供應其它模塊引用的函數和全局變量以關鍵字eｘtern聲明。例如,假如模塊Ｂ欲引用該模塊A中定義的全局變量和函數時只需包含模塊A的頭文獻即可。這樣，模塊B中調用模塊Ａ中的函數時,在編譯階段，模塊Ｂ雖然找不到該函數，但是并不會報錯;它會在連接階段中從模塊A編譯生成的目的代碼中找到此函數??exｔern＂C"是連接申明(lｉnkagedｅclaratｉｏn)，被exｔern"Ｃ"修飾的變量和函數是按照C語言方式編譯和連接的,來看看Ｃ++中對類似C的函數是如何編譯的:??

作為一種面向對象的語言,C++支持函數重載,而過程式語言C則不支持。函數被C+＋編譯后在符號庫中的名字與C語言的不同。例如，假設某個函數的原型為:??ｖｏidfoo(intｘ，inｔy）;

??該函數被Ｃ編譯器編譯后在符號庫中的名字為_foo，而Ｃ＋＋編譯器則會產生像_fｏｏ＿int_iｎt之類的名字（不同的編譯器也許生成的名字不同，但是都采用了相同的機制,生成的新名字稱為“ｍaｎgｌedｎame”）。

＿foo＿iｎt_inｔ這樣的名字包含了函數名、函數參數數量及類型信息，Ｃ+＋就是靠這種機制來實現函數重載的。例如，在Ｃ++中,函數ｖｏiｄｆoo(intx，inty）與voｉdfoo（inｔx,floaty）編譯生成的符號是不相同的，后者為_foｏ＿inｔ_ｆｌoat。

同樣地,C++中的變量除支持局部變量外,還支持類成員變量和全局變量。用戶所編寫程序的類成員變量也許與全局變量同名,我們以".＂來區(qū)分。而本質上，編譯器在進行編譯時,與函數的解決相似,也為類中的變量取了一個獨一無二的名字,這個名字與用戶程序中同名的全局變量名字不同。?

未加extｅｒn"C＂聲明時的連接方式

?假設在C++中,模塊A的頭文獻如下：

?//模塊A頭文獻modulｅA．ｈ

#ifｎdefＭOＤＵLE_Ａ_H?＃defｉneMODULE_A_Ｈ

ｉntfoo(iｎtｘ,iｎty);

#enｄｉf??在模塊Ｂ中引用該函數:??//模塊B實現文獻modulｅB．cｐp?＃iｎｃｌuｄｅ"moduｌeA．ｈ"

foo(2,3);加ｅxtｅrn＂C"聲明后的編譯和連接方式?

加ｅｘteｒn"Ｃ"聲明后,模塊A的頭文獻變?yōu)椋?/p>

/／模塊A頭文獻ｍoduleＡ.ｈ?#ifnｄefMOＤＵLE＿A＿H?#dｅfiｎｅMODＵＬE_Ａ_Ｈ?extern＂C"ｉntfｏｏ（iｎtx，inty);?＃ｅｎdif

在模塊B的實現文獻中仍然調用foo(2,3），其結果是：

(１）模塊Ａ編譯生成foo的目的代碼時，沒有對其名字進行特殊解決,采用了C語言的方式;??(２)連接器在為模塊B的目的代碼尋找foo(2,３)調用時,尋找的是未經修改的符號名_foｏ。

?假如在模塊A中函數聲明了ｆoo為ｅxtern"C＂類型,而模塊Ｂ中包含的是eｘterniｎｔfoｏ(ｉntｘ,inｔy),則模塊B找不到模塊A中的函數;反之亦然。??所以,可以用一句話概括extｅrn“C”這個聲明的真實目的（任何語言中的任何語法特性的誕生都不是隨意而為的，來源于真實世界的需求驅動。我們在思考問題時,不能只停留在這個語言是怎么做的,還要問一問它為什么要這么做,動機是什么，這樣我們可以更進一步地理解許多問題）：實現C++與C及其它語言的混合編程。??明白了C++中exｔｅrｎ＂C"的設立動機,我們下面來具體分析exｔerｎ"C"通常的使用技巧:

?eｘｔｅrn"Ｃ"的慣用法

?(１)在C++中引用C語言中的函數和變量，在包含C語言頭文獻(假設為ｃExample.ｈ)時,需進行下列解決：?

?ｅxterｎ"C"

{?＃incｌｕde＂cExamplｅ．ｈ"

}

?而在C語言的頭文獻中,對其外部函數只能指定為eｘteｒn類型，C語言中不支持eｘtern"C"聲明,在.c文獻中包含了eｘterｎ"Ｃ"時會出現編譯語法錯誤。

Ｃ++引用C函數例子工程中包含的三個文獻的源代碼如下:

?/*ｃ語言頭文獻：cＥxａｍplｅ.ｈ*/?#ifnｄeｆC_EXAMPLE_H

#defineＣ_EXAMPLE＿H?externintadd(intx,ｉntｙ）;

＃eｎdif???／*ｃ語言實現文獻:cExaｍpｌe．ｃ*/?#inclｕde＂cExaｍｐle.h"?ｉntaｄd(ｉｎtx，ｉnty)

｛

retuｒｎｘ+ｙ;

}?

?//ｃ＋＋實現文獻,調用add:cppFｉle.ｃpp

extern"Ｃ＂

{?＃include"cExａｍple．ｈ"

}?intmain（iｎtargc,chａr*argv［])

{?add(2，３);?return0;?}?

假如C++調用一個C語言編寫的.DＬL時,當涉及.DLL的頭文獻或聲明接口函數時，應加exｔern"C＂{}。??(2）在C中引用C++語言中的函數和變量時，Ｃ++的頭文獻需添加exteｒn"C"，但是在C語言中不能直接引用聲明了ｅxtern"C"的該頭文獻,應當僅將C文獻中將Ｃ＋＋中定義的eｘterｎ"Ｃ"函數聲明為exｔｅrn類型。?

Ｃ引用C++函數例子工程中包含的三個文獻的源代碼如下：

／/Ｃ+＋頭文獻ｃｐpEｘａmｐｌe.h

#ifndeｆCＰP＿ＥXAMPLE_H

＃ｄｅfinｅCPＰ_EXAMＰＬE_H

ｅxtｅrn"C"ｉntaｄｄ(inｔｘ,inｔｙ);?#endif

??//C++實現文獻cppExaｍplｅ.cｐp?＃inｃlｕde"cpｐExamplｅ.h"

intａdd(inｔx,ｉnｔｙ)?｛

returｎx＋y;

}?

/*C實現文獻cFile.c?/＊這樣會編譯犯錯:#incluｄe"ｃExample.h"＊/iｎｔmain(inｔargc,char*ａｒgv[］)?{

add（２,３)；

ｒeｔｕrn0;

}?

１５題目的解答請參考《C＋+中eｘtern“C”含義深層探索》注解：幾道c筆試題(含參考答案)?

1．?Wｈａt(yī)isｄiｓｐlayｅdｗhenf()isｃallｅdgiｖeｎｔhecode:

cｌassNumber{?publiｃ:?stringtype;??Ｎumbｅr():tyｐｅ(“void”）{}

explｉcitNumbｅr(short):type(“shorｔ”）{}?Number(int):tｙpe(“iｎｔ”){}?};

voidSｈｏw（cｏnstＮuｍｂｅr＆n){ｃout<<n.ｔype;}

voidf（)?{?shorｔｓ=42；?Ｓhｏw(s);

}

a)ｖoｉd?b)sｈort?ｃ)inｔ?d）Nｏｎeoftｈｅabove?

２.Ｗhiｃhistｈecｏｒrecｔoutputfortｈefｏlｌｏwingcｏde?ｄoubleｄＡｒrａy［２］={4,８}，*p,*q；

p=&dArray[0];?q＝p+１;?couｔ<<q–p＜<endl;?cｏut＜<(ｉnt）q－(int)p＜<endl;

a)1aｎd8

b）８aｎd４

c)４and8

ｄ)8and1???第一個選C;?雖然傳入的是shｏrt類型，但是ｓｈｏrｔ類型的構造函數被生命被expliｃｉt,也就是只能顯示類型轉換，不能使用隱式類型轉換。

第二個選Ａ;

第一個是指針加減，按照的是指向地址類型的加減,只跟類型位置有關，ｑ和p指向的數據類型以實際數據類型來算差一個位置，因此是1。而第二個加減是實際指針值得加減，在內存中一個dｏubｌｅ類型占據8個字節(jié),因此是8５４.Sｏny筆試題?1.完畢下列程序

*

*.*.

＊..＊..＊..?*...＊...*．．.＊...

＊．...*....＊..．．*．．..＊．..．

＊.....