第一部分：基本概念及其它問答題1、關鍵字ｓｔaｔiｃ的作用是什么？這個簡樸的問題很少有人能回答完全。在C語言中,關鍵字static有三個明顯的作用：１）.在函數體,一個被聲明為靜態的變量在這一函數被調用過程中維持其值不變。2）.在模塊內(但在函數體外),一個被聲明為靜態的變量可以被模塊內所用函數訪問,但不能被模塊外其它函數訪問。它是一個本地的全局變量。3).在模塊內,一個被聲明為靜態的函數只可被這一模塊內的其它函數調用。那就是,這個函數被限制在聲明它的模塊的本地范圍內使用。大多數應試者能對的回答第一部分，一部分能對的回答第二部分,同是很少的人能懂得第三部分。這是一個應試者的嚴重的缺陷，由于他顯然不懂得本地化數據和代碼范圍的好處和重要性。2、“引用”與指針的區別是什么?答、1)引用必須被初始化,指針不必。２)引用初始化以后不能被改變,指針可以改變所指的對象。３)不存在指向空值的引用,但是存在指向空值的指針。指針通過某個指針變量指向一個對象后，對它所指向的變量間接操作。程序中使用指針,程序的可讀性差;而引用自身就是目的變量的別名，對引用的操作就是對目的變量的操作。流操作符＜<和>>、賦值操作符=的返回值、拷貝構造函數的參數、賦值操作符=的參數、其它情況都推薦使用引用3、.h頭文獻中的ifｎdef/dｅfｉne/ｅndｉｆ的作用?答:防止該頭文獻被反復引用。4、#includｅ<file．h＞與#inｃludｅ"file.ｈ"的區別?答：前者是從ＳｔandａrdＬibrarｙ的途徑尋找和引用file.h，而后者是從當前工作途徑搜尋并引用fｉle.ｈ。５、描述實時系統的基本特性答:在特定期間內完畢特定的任務，實時性與可靠性。６、全局變量和局部變量在內存中是否有區別?假如有，是什么區別？答:全局變量儲存在靜態數據區，局部變量在堆棧中。７、什么是平衡二叉樹?答：左右子樹都是平衡二叉樹且左右子樹的深度差值的絕對值不大于1。８、堆棧溢出一般是由什么因素導致的?答：１.沒有回收垃圾資源?2.層次太深的遞歸調用9、冒泡排序算法的時間復雜度是什么？答:O(n＾２)10、什么函數不能聲明為虛函數?答:ｃｏnstｒuctｏr１1、隊列和棧有什么區別?答：隊列先進先出，棧后進先出1２、不能做switcｈ()的參數類型答：swiｔch的參數不能為實型。13、局部變量能否和全局變量重名？答：能，局部會屏蔽全局。要用全局變量,需要使用"：：＂局部變量可以與全局變量同名,在函數內引用這個變量時，會用到同名的局部變量，而不會用到全局變量。對于有些編譯器而言，在同一個函數內可以定義多個同名的局部變量,比如在兩個循環體內都定義一個同名的局部變量，而那個局部變量的作用域就在那個循環體內１４、如何引用一個已經定義過的全局變量?答、可以用引用頭文獻的方式，也可以用eｘtｅｒn關鍵字，假如用引用頭文獻方式來引用某個在頭文獻中聲明的全局變量，假定你將那個變量寫錯了，那么在編譯期間會報錯,假如你用exteｒn方式引用時,假定你犯了同樣的錯誤,那么在編譯期間不會報錯,而在連接期間報錯。15、全局變量可不可以定義在可被多個.Ｃ文獻包含的頭文獻中?為什么？答、可以,在不同的C文獻中以ｓｔatｉｃ形式來聲明同名全局變量。可以在不同的C文獻中聲明同名的全局變量,前提是其中只能有一個C文獻中對此變量賦初值,此時連接不會犯錯。１6、語句for（;1；）有什么問題?它是什么意思？答、和whilｅ(1)相同，無限循環。１7、do……wｈｉle和whilｅ……do有什么區別?答、前一個循環一遍再判斷,后一個判斷以后再循環。18、statac全局變量、局部變量、函數與普通全局變量、局部變量、函數statｉc全局變量與普通的全局變量有什么區別?statｉc局部變量和普通局部變量有什么區別?statｉc函數與普通函數有什么區別?答、全局變量（外部變量)的說明之前再冠以static就構成了靜態的全局變量。全局變量自身就是靜態存儲方式，靜態全局變量當然也是靜態存儲方式。這兩者在存儲方式上并無不同。這兩者的區別雖在于非靜態全局變量的作用域是整個源程序,當一個源程序由多個源文獻組成時，非靜態的全局變量在各個源文獻中都是有效的。而靜態全局變量則限制了其作用域,即只在定義該變量的源文獻內有效，在同一源程序的其它源文獻中不能使用它。由于靜態全局變量的作用域局限于一個源文獻內，只能為該源文獻內的函數公用，因此可以避免在其它源文獻中引起錯誤。從以上分析可以看出,把局部變量改變為靜態變量后是改變了它的存儲方式即改變了它的生存期。把全局變量改變為靜態變量后是改變了它的作用域,限制了它的使用范圍。ｓｔａtic函數與普通函數作用域不同。僅在本文獻。只在當前源文獻中使用的函數應當說明為內部函數（ｓtatic)，內部函數應當在當前源文獻中說明和定義。對于可在當前源文獻以外使用的函數,應當在一個頭文獻中說明，要使用這些函數的源文獻要包含這個頭文獻statｉc全局變量與普通的全局變量有什么區別:stａtiｃ全局變量只初使化一次,防止在其他文獻單元中被引用;statiｃ局部變量和普通局部變量有什么區別:static局部變量只被初始化一次，下一次依據上一次結果值；static函數與普通函數有什么區別:stａtｉc函數在內存中只有一份,普通函數在每個被調用中維持一份拷貝1９、程序的內存分派?答：一個由ｃ／C＋+編譯的程序占用的內存分為以下幾個部分

1、棧區（sｔａck)—由編譯器自動分派釋放,存放函數的參數值,局部變量的值等。其操作方式類似于數據結構中的棧。

2、堆區（heap)—一般由程序員分派釋放,若程序員不釋放，程序結束時也許由ＯS回收。注意它與數據結構中的堆是兩回事,分派方式倒是類似于鏈表，呵呵。

3、全局區(靜態區)（sｔatｉc）—全局變量和靜態變量的存儲是放在一塊的，初始化的全局變量和靜態變量在一塊區域，未初始化的全局變量和未初始化的靜態變量在相鄰的另一塊區域。程序結束后由系統釋放。

4、文字常量區—常量字符串就是放在這里的。程序結束后由系統釋放。?5、程序代碼區—存放函數體的二進制代碼例子程序

這是一個前輩寫的，非常具體?／/maiｎ.cpp?

ｉnta=0;

//全局初始化區?

cｈar*p1；

//全局未初始化區

main()

｛?

iｎtb;棧?

charｓ［]="aｂc＂；

／/棧

cｈar*p2；

／/棧

char＊p3="１2３４5６"；

//１２34５6\０在常量區，ｐ３在棧上。

staticiｎtc=０；

//全局（靜態）初始化區

p1=(ｃhaｒ*)malloｃ(10);

ｐ２＝(cｈar*）mallｏc（20);

//分派得來得10和20字節的區域就在堆區。?

ｓｔｒcpｙ(p1，"123４５6");

/／1２3456\０放在常量區，編譯器也許會將它與p３所向"１23456＂優化成一個地方。

｝２0、解釋堆和棧的區別答:堆(hｅａｐ）和棧(stａcｋ)的區別（1)申請方式

sｔack:由系統自動分派。例如，聲明在函數中一個局部變量ｉntb;系統自動在棧中為ｂ開辟空間

hｅap：需要程序員自己申請，并指明大小,在ｃ中malｌoｃ函數?如ｐ1=(cｈar*)malloc(1０);?在C＋+中用new運算符?如p2=（cｈaｒ*)mallｏc(10)；

但是注意ｐ１、p2自身是在棧中的。（2)申請后系統的響應?棧:只要棧的剩余空間大于所申請空間，系統將為程序提供內存,否則將報異常提醒棧溢出。?堆:一方面應當知道操作系統有一個記錄空閑內存地址的鏈表,當系統收到程序的申請時,?會遍歷該鏈表,尋找第一個空間大于所申請空間的堆結點,然后將該結點從空閑結點鏈表中刪除，并將該結點的空間分派給程序,此外,對于大多數系統,會在這塊內存空間中的首地址處記錄本次分派的大小,這樣,代碼中的ｄelｅte語句才干對的的釋放本內存空間。此外，由于找到的堆結點的大小不一定正好等于申請的大小,系統會自動的將多余的那部分重新放入空閑鏈表中。（3）申請大小的限制?棧：在Wiｎdowｓ下,棧是向低地址擴展的數據結構，是一塊連續的內存的區域。這句話的意思是棧頂的地址和棧的最大容量是系統預先規定好的,在WINＤOWS下,棧的大小是2M（也有的說是1M，總之是一個編譯時就擬定的常數)，假如申請的空間超過棧的剩余空間時,將提醒overfｌoｗ。因此,能從棧獲得的空間較小。?堆：堆是向高地址擴展的數據結構，是不連續的內存區域。這是由于系統是用鏈表來存儲的空閑內存地址的,自然是不連續的，而鏈表的遍歷方向是由低地址向高地址。堆的大小受限于計算機系統中有效的虛擬內存。由此可見,堆獲得的空間比較靈活，也比較大。（４）申請效率的比較:?棧:由系統自動分派，速度較快。但程序員是無法控制的。

堆：是由new分派的內存，一般速度比較慢，并且容易產生內存碎片,但是用起來最方便.

此外，在WINDOWS下，最佳的方式是用ViｒtuａlAlloc分派內存，他不是在堆，也不是在棧,而是直接在進程的地址空間中保存一塊內存，雖然用起來最不方便。但是速度快，也最靈活。(5)堆和棧中的存儲內容

棧：在函數調用時,第一個進棧的是主函數中后的下一條指令（函數調用語句的下一條可執行語句）的地址,然后是函數的各個參數,在大多數的Ｃ編譯器中，參數是由右往左入棧的,然后是函數中的局部變量。注意靜態變量是不入棧的。?當本次函數調用結束后,局部變量先出棧，然后是參數，最后棧頂指針指向最開始存的地址，也就是主函數中的下一條指令,程序由該點繼續運營。?堆：一般是在堆的頭部用一個字節存放堆的大小。堆中的具體內容由程序員安排。(6)存取效率的比較charｓ1[］="aａａａaaaａaａａaaaa";?char*s2="bｂbbbbbbbbbbbbbbb";?aaaａaaaａａaa是在運營時刻賦值的；

而bbbbbbbbbbb是在編譯時就擬定的;?但是,在以后的存取中,在棧上的數組比指針所指向的字符串(例如堆)快。

比如：?＃ｉｎclｕde

vｏidmaｉn（)?{

cｈａｒa=１;?charｃ[]="";

cｈar*p＝"";?a=c［1]；

a=p[1];

retuｒn;

}?相應的匯編代碼

1０:a=c[1];

A4DF１moｖcl,ｂｙteptr［ebp-０Ｆh]

00４０106A88４DFCmovbyｔepｔｒ[ebp-4］,ｃl

11:a＝p［1];

004０106D8B５5ＥCｍovedｘ,ｄwordｐtr[ebｐ－14ｈ]?A４2０1movａｌ,bytepｔr[ｅｄｘ+１]

FCmovbyｔeｐtr[ebｐ-４],al?第一種在讀取時直接就把字符串中的元素讀到寄存器cｌ中，而第二種則要先把指針值讀到edx中，在根據eｄx讀取字符，顯然慢了。２１、什么是預編譯，何時需要預編譯?答：預編譯又稱為預解決,是做些代碼文本的替換工作。解決＃開頭的指令，比如拷貝#incｌude包含的文獻代碼，＃deｆiｎe宏定義的替換，條件編譯等,就是為編譯做的預備工作的階段，重要解決#開始的預編譯指令,預編譯指令指示了在程序正式編譯前就由編譯器進行的操作,可以放在程序中的任何位置。c編譯系統在對程序進行通常的編譯之前，先進行預解決。c提供的預解決功能重要有以下三種:1)宏定義2）文獻包含3）條件編譯總是使用不經常改動的大型代碼體。2、程序由多個模塊組成,所有模塊都使用一組標準的包含文獻和相同的編譯選項。在這種情況下，可以將所有包含文獻預編譯為一個預編譯頭。22、關鍵字const是什么含意？答：我只要一聽到被面試者說：“const意味著常數”,我就知道我正在和一個業余者打交道。去年DanＳaks已經在他的文章里完全概括了ｃonst的所有用法，因此ESP(譯者:EmbeｄｄedSystemsPｒogramming)的每一位讀者應當非常熟悉const能做什么和不能做什么．假如你從沒有讀到那篇文章,只要能說出consｔ意味著“只讀”就可以了。盡管這個答案不是完全的答案，但我接受它作為一個對的的答案。(假如你想知道更具體的答案，仔細讀一下Saｋs的文章吧。）假如應試者能對的回答這個問題，我將問他一個附加的問題：下面的聲明都是什么意思?conｓtinｔa;intｃonｓta;constinｔ＊ａ；iｎｔ*cｏnsta；intｃoｎsｔ*aconsｔ;前兩個的作用是同樣，a是一個常整型數。第三個意味著ａ是一個指向常整型數的指針（也就是,整型數是不可修改的,但指針可以)。第四個意思ａ是一個指向整型數的常指針(也就是說,指針指向的整型數是可以修改的，但指針是不可修改的）。最后一個意味著a是一個指向常整型數的常指針(也就是說,指針指向的整型數是不可修改的,同時指針也是不可修改的)。假如應試者能對的回答這些問題,那么他就給我留下了一個好印象。順帶提一句，也許你也許會問，即使不用關鍵字ｃｏｎｓt，也還是能很容易寫出功能對的的程序,那么我為什么還要如此看重關鍵字ｃoｎsｔ呢？我也如下的幾下理由：1).關鍵字conｓt的作用是為給讀你代碼的人傳達非常有用的信息，事實上,聲明一個參數為常量是為了告訴了用戶這個參數的應用目的。假如你曾花很多時間清理其它人留下的垃圾,你就會不久學會感謝這點多余的信息。（當然，懂得用cｏｎsｔ的程序員很少會留下的垃圾讓別人來清理的。)2)．通過給優化器一些附加的信息，使用關鍵字const也許能產生更緊湊的代碼。３).合理地使用關鍵字cｏｎst可以使編譯器很自然地保護那些不希望被改變的參數，防止其被無意的代碼修改。簡而言之，這樣可以減少bug的出現2３、關鍵字ｖｏｌａｔiｌe有什么含意并給出三個不同的例子。答:一個定義為voｌatilｅ的變量是說這變量也許會被意想不到地改變,這樣,編譯器就不會去假設這個變量的值了。精確地說就是，優化器在用到這個變量時必須每次都小心地重新讀取這個變量的值，而不是使用保存在寄存器里的備份。下面是volatilｅ變量的幾個例子:1）.并行設備的硬件寄存器（如：狀態寄存器)2).一個中斷服務子程序中會訪問到的非自動變量（Non-autoｍaticｖariableｓ）3).多線程應用中被幾個任務共享的變量回答不出這個問題的人是不會被雇傭的。我認為這是區分Ｃ程序員和嵌入式系統程序員的最基本的問題。嵌入式系統程序員經常同硬件、中斷、RTOS等等打交道，所用這些都規定voｌatｉle變量。不懂得vｏlatile內容將會帶來劫難。假設被面試者對的地回答了這是問題（嗯，懷疑這否會是這樣）,我將稍微深究一下,看一下這家伙是不是直正懂得ｖolatile完全的重要性。1).一個參數既可以是ｃonst還可以是ｖolatｉle嗎?解釋為什么。2).一個指針可以是voｌａtilｅ嗎？解釋為什么。3)．下面的函數有什么錯誤：ｉｎtｓquare（voｌａｔｉleinｔ*ptｒ){returｎ＊ｐtr**ｐｔｒ;}下面是答案：1）.是的。一個例子是只讀的狀態寄存器。它是volatile由于它也許被意想不到地改變。它是coｎsｔ由于程序不應當試圖去修改它。2).是的。盡管這并不很常見。一個例子是當一個中服務子程序修該一個指向一個bｕffer的指針時。3).這段代碼的有個惡作劇。這段代碼的目的是用來返指針*ｐtr指向值的平方，但是，由于*pｔr指向一個ｖoｌａtile型參數,編譯器將產生類似下面的代碼：iｎtsｑuarｅ(voｌａｔilｅｉnt*ptr){intａ，b；a=*pｔｒ;ｂ=*ptr；rｅｔurna*b;｝由于*ｐtｒ的值也許被意想不到地該變,因此ａ和b也許是不同的。結果，這段代碼也許返不是你所盼望的平方值!對的的代碼如下:ｌongsquａre(volatiｌeint*ｐtr){inｔａ;ａ=＊pｔr；retｕrna*a;}2４、三種基本的數據模型答:按照數據結構類型的不同,將數據模型劃分為層次模型、網狀模型和關系模型。25、結構與聯合有和區別？答:(1).結構和聯合都是由多個不同的數據類型成員組成，但在任何同一時刻,聯合中只存放了一個被選中的成員（所有成員共用一塊地址空間）,而結構的所有成員都存在(不同成員的存放地址不同)。

(2)．對于聯合的不同成員賦值,將會對其它成員重寫,

本來成員的值就不存在了,而對于結構的不同成員賦值是互不影響的26、描述內存分派方式以及它們的區別?答：1）從靜態存儲區域分派。內存在程序編譯的時候就已經分派好，這塊內存在程序的整個運營期間都存在。例如全局變量,ｓtaｔic變量。

２)在棧上創建。在執行函數時，函數內局部變量的存儲單元都可以在棧上創建，函數執行結束時這些存儲單元自動被釋放。棧內存分派運算內置于解決器的指令集。?3)從堆上分派，亦稱動態內存分派。程序在運營的時候用malｌoc或nｅｗ申請任意多少的內存，程序員自己負責在何時用ｆree或deleｔe釋放內存。動態內存的生存期由程序員決定，使用非常靈活,但問題也最多2７、請說出cｏnst與#define相比,有何優點?答：Ｃonsｔ作用：定義常量、修飾函數參數、修飾函數返回值三個作用。被Coｎst修飾的東西都受到強制保護,可以防止意外的變動，能提高程序的健壯性。1)ｃonst常量有數據類型，而宏常量沒有數據類型。編譯器可以對前者進行類型安全檢查。而對后者只進行字符替換,沒有類型安全檢查,并且在字符替換也許會產生意料不到的錯誤。?

2）有些集成化的調試工具可以對cｏnst常量進行調試,但是不能對宏常量進行調試。28、簡述數組與指針的區別?答：數組要么在靜態存儲區被創建（如全局數組)，要么在棧上被創建。指針可以隨時指向任意類型的內存塊。?(1）修改內容上的差別

chara[]＝“hellｏ”；?ａ[0]=‘X’;?char*ｐ=“world”;//注意p指向常量字符串?ｐ[0]=‘X’;/／編譯器不能發現該錯誤，運營時錯誤

(2)用運算符ｓｉzeof可以計算出數組的容量（字節數)。sizeof(ｐ),p為指針得到的是一個指針變量的字節數,而不是ｐ所指的內存容量。Ｃ++/Ｃ語言沒有辦法知道指針所指的內存容量,除非在申請內存時記住它。注意當數組作為函數的參數進行傳遞時，該數組自動退化為同類型的指針。

chaｒa[]=＂heｌloｗorld";

chaｒ*p=a；?ｃouｔ＜<sｉzeoｆ(a)＜<ｅｎdl;／/1２字節

cｏut<<sizeｏf(p)<＜ｅｎdｌ;//4字節?計算數組和指針的內存容量

ｖoｉｄFunc（ｃhａra[1００］）

｛?cout<<ｓizeoｆ(a）<<ｅndl;//4字節而不是100字節

}29、分別寫出BOOL,ｉｎｔ,fｌｏat,指針類型的變量a與“零”的比較語句。答：BOOL:

ｉf(!a）oriｆ(a)

int：

ｉf（ａ==0）?flｏat:

constEXPRＥSSIOＮＥXP＝0．０00001

if（a＜EXP&&ａ>－EXP）

poinｔeｒ：iｆ(ａ!=NULL)orif(a＝＝ＮＵLL)30、如何判斷一段程序是由C編譯程序還是由C++編譯程序編譯的?答：#ｉｆdef__cplｕsplｕs

coｕｔ<＜"c++＂；?#elｓe

coｕｔ<<"c";?#ｅndｉf3１、論述含參數的宏與函數的優缺陷答：帶參宏函數解決時間編譯時程序運營時參數類型沒有參數類型問題定義實參、形參類型解決過程不分派內存分派內存程序長度變長不變運營速度不占運營時間調用和返回占用時間32、用兩個棧實現一個隊列的功能?規定給出算法和思緒！答、設2個棧為A,B，一開始均為空．入隊:將新元素ｐush入棧A;出隊:（1)判斷棧B是否為空;(2）假如不為空，則將棧A中所有元素依次poｐ出并puｓh到棧B;(3)將棧B的棧頂元素pｏp出;這樣實現的隊列入隊和出隊的平攤復雜度都還是Ｏ(１),比上面的幾種方法要好33、嵌入式系統中經常要用到無限循環,你怎么樣用C編寫死循環呢?答:這個問題用幾個解決方案。我首選的方案是:whｉｌｅ（１）｛}一些程序員更喜歡如下方案:for(;;)｛}這個實現方式讓我為難，由于這個語法沒有確切表達成底怎么回事。假如一個應試者給出這個作為方案，我將用這個作為一個機會去探究他們這樣做的基本原理。假如他們的基本答案是：“我被教著這樣做,但從沒有想到過為什么。”這會給我留下一個壞印象。第三個方案是用ｇｏｔoLoop:...goｔｏLooｐ;應試者如給出上面的方案，這說明或者他是一個匯編語言程序員(這也許是好事)或者他是一個想進入新領域的BＡSＩC／FORTＲＡN程序員。３4、位操作(Bｉtmanｉpulation)答：嵌入式系統總是要用戶對變量或寄存器進行位操作。給定一個整型變量ａ，寫兩段代碼，第一個設立a的bit3，第二個清除ａ的ｂit3。在以上兩個操作中，要保持其它位不變。?對這個問題有三種基本的反映

1)不知道如何下手。該被面者從沒做過任何嵌入式系統的工作。

2)用bitfieｌds。Biｔｆiｅｌｄｓ是被扔到C語言死角的東西,它保證你的代碼在不同編譯器之間是不可移植的，同時也保證了的你的代碼是不可重用的。我最近不幸看到Infiｎeon為其較復雜的通信芯片寫的驅動程序，它用到了biｔfields因此完全對我無用,由于我的編譯器用其它的方式來實現ｂitfｉｅｌds的。從道德講：永遠不要讓一個非嵌入式的家伙粘實際硬件的邊。

3)用#deｆｉneｓ和ｂiｔmaskｓ操作。這是一個有極高可移植性的方法，是應當被用到的方法。最佳的解決方案如下：?#deｆｉneBIT3(0x1<<3)?staticintａ;??ｖoidseｔ＿bｉt3（vｏid)?｛?

a|=BIT３;?｝?voｉdclear_bit3(void)?{

a＆=~BＩＴ3;?}?一些人喜歡為設立和清除值而定義一個掩碼同時定義一些說明常數,這也是可以接受的。我希望看到幾個要點:說明常數、｜=和&=～操作。3５、訪問固定的內存位置（Accessinｇfiｘｅdmemoｒyloｃａtionｓ）答:嵌入式系統經常具有規定程序員去訪問某特定的內存位置的特點。在某工程中,規定設立一絕對地址為０ｘ６7a９的整型變量的值為0xａa6６。編譯器是一個純粹的AＮSI編譯器。寫代碼去完畢這一任務。

這一問題測試你是否知道為了訪問一絕對地址把一個整型數強制轉換（ｔypecａｓｔ)為一指針是合法的。這一問題的實現方式隨著個人風格不同而不同。典型的類似代碼如下:

ｉｎt＊ｐｔｒ；?

ptr=(int＊)０x6７a9;

*ptr＝0ｘaa66；?

Amoｒeobｓcｕreapproachiｓ:

一個較晦澀的方法是：?*(int＊conｓt）(０x6７a9)＝0xａa55;

即使你的品味更接近第二種方案，但我建議你在面試時使用第一種方案。36、中斷（Ｉnteｒruptｓ）答:中斷是嵌入式系統中重要的組成部分,這導致了很多編譯開發商提供一種擴展—讓標準C支持中斷。具代表事實是,產生了一個新的關鍵字__iｎterrupt。下面的代碼就使用了__inteｒｒuｐt關鍵字去定義了一個中斷服務子程序(ISR),請評論一下這段代碼的。?

＿_intｅrrupｔdouｂlecoｍpute_arｅa(doｕｂleradius）?{

ｄouｂleaｒea=PI＊raｄiｕｓ*ｒadiuｓ；

printf（"＼nArea=%ｆ",aｒea);

rｅtｕrｎarｅa；

}?這個函數有太多的錯誤了,以至讓人不知從何說起了:?1)ＩSR不能返回一個值。假如你不懂這個,那么你不會被雇用的。?2)ISR不能傳遞參數。假如你沒有看到這一點,你被雇用的機會等同第一項。

3)在許多的解決器/編譯器中,浮點一般都是不可重入的。有些解決器／編譯器需要讓額處的寄存器入棧，有些解決器/編譯器就是不允許在IＳR中做浮點運算。此外，IＳR應當是短而有效率的,在ISＲ中做浮點運算是不明智的。?4）與第三點一脈相承,ｐｒintf(）經常有重入和性能上的問題。假如你丟掉了第三和第四點,我不會太為難你的。不用說,假如你能得到后兩點,那么你的被雇用前景越來越光明了。37、動態內存分派(Dyｎａmｉｃmemｏｒyallｏcａtion）答:盡管不像非嵌入式計算機那么常見,嵌入式系統還是有從堆（heap）中動態分派內存的過程的。那么嵌入式系統中,動態分派內存也許發生的問題是什么？?這里，我盼望應試者能提到內存碎片,碎片收集的問題，變量的持行時間等等。這個主題已經在ESP雜志中被廣泛地討論過了（重要是P.J.Plauger,他的解釋遠遠超過我這里能提到的任何解釋）,所有回過頭看一下這些雜志吧！讓應試者進入一種虛假的安全感覺后，我拿出這么一個小節目：?下面的代碼片段的輸出是什么,為什么??ｃhａr*ｐtｒ;?iｆ((ｐtr＝（char＊)malｌｏｃ（0))=＝NULL)

pｕtｓ("Goｔanullｐointeｒ");

else?

puts（"Gotavaｌｉdpｏｉnｔeｒ");?這是一個有趣的問題。最近在我的一個同事不經意把0值傳給了函數maｌloc,得到了一個合法的指針之后,我才想到這個問題。這就是上面的代碼,該代碼的輸出是"Gotavalidｐｏｉnter"。我用這個來開始討論這樣的一問題，看看被面試者是否想到庫例程這樣做是對的。得到對的的答案固然重要，但解決問題的方法和你做決定的基本原理更重要些。38、Ｔyｐeｄef答:Tｙｐedｅf在Ｃ語言中頻繁用以聲明一個已經存在的數據類型的同義字。也可以用預解決器做類似的事。例如,思考一下下面的例子：?#definedPSstructs*?typeｄefstruｃtｓ＊tPS;?以上兩種情況的意圖都是要定義dＰS和tＰS作為一個指向結構s指針。哪種方法更好呢?(假如有的話）為什么？

這是一個非常微妙的問題,任何人答對這個問題（合法的因素）是應當被恭喜的。答案是:typeｄef更好。思考下面的例子:

dPSｐ1，ｐ2;?tPSｐ３,p4；?第一個擴展為

structｓ*p1,p2;

上面的代碼定義p1為一個指向結構的指,p2為一個實際的結構,這也許不是你想要的。第二個例子對的地定義了p3和p4兩個指針。?3９、用變量a給出下面的定義答：a)一個整型數（Aninteger）b)一個指向整型數的指針（Apoiｎteｒtoａnｉnteger）c)一個指向指針的的指針,它指向的指針是指向一個整型數（Apｏintｅrtoaｐｏintｅｒtｏanｉｎtegeｒ)ｄ)一個有１0個整型數的數組（Anａrrａyof10iｎteｇers)e)一個有1０個指針的數組,該指針是指向一個整型數的(Anａｒrayoｆ10poｉntｅrstｏintegｅｒs)ｆ)一個指向有10個整型數數組的指針（Apointertｏanaｒｒａyof10iｎｔegｅrs)g)一個指向函數的指針，該函數有一個整型參數并返回一個整型數（Ａpｏinteｒtoafｕnctiontｈattakesaniｎtegerａｓａnargumｅｎtandreturnsanｉntｅｇer)h)一個有10個指針的數組，該指針指向一個函數，該函數有一個整型參數并返回一個整型數（Anarｒａyｏｆteｎpｏinteｒstofunctioｎsthａtｔakｅanintegｅｒarｇumｅｎｔanｄｒｅｔurnａnｉnteｇer)答案是:a）ｉnta;//Aniｎｔeｇerb）int＊ａ；／/Aｐointｅrtoanintegerc)ｉｎt＊*ａ;/／Aｐointｅｒtoａpoｉnｔerｔｏaniｎｔeｇerd)ｉｎta[10];／/Anａrrayｏf１0inteｇｅrｓｅ）ｉnt*ａ[１0];／/Ａnarrayof10ｐoiｎｔerstｏiｎteｇersf)ｉnt（*ａ）[10]；/／Apｏiｎtertｏaｎarrayof10ｉntegersg)ｉｎt（*a)(int);／/Ａpoiｎtertｏafｕnctionathａtｔakesaninｔegｅｒaｒｇｕmeｎｔaｎdretuｒｎsanｉnｔegerｈ）int（*a［10])(iｎt)；//Anarrａyoｆ10pointerstofuncｔionｓthattａｋeａniｎteｇｅrargumeｎtaｎdreturnaｎinteger４0、解釋局部變量、全局變量和靜態變量的含義。答：41、寫一個“標準”宏答：互換兩個參數值的宏定義為:.#defiｎeＳＷAP(a,b)\(a)=(ａ)+（ｂ);＼（ｂ)=(a)－(b);＼(a)=(a)-（b);輸入兩個參數,輸出較小的一個：#defineＭIN（A，B)(（A）＜(Ｂ)）?（A）：(B）)表白1年中有多少秒（忽略閏年問題）：#dｅfｉneSＥCＯＮDS＿PEＲ＿ＹＥAＲ(60*60＊24*3６5)UL#deｆiｎeＤOＵBLE(x)ｘ+x與#dｅfineDOUBLE(x)(（x）+（x）)i＝5*ＤOＵＢLE(5)；i為30i=５*DOUBLE（5）；i為50已知一個數組ｔablｅ，用一個宏定義,求出數據的元素個數＃defｉneNTＢＬ#dｅｆinｅＮＴBＬ(sizｅof(tablｅ）／sizeof(tabｌe[０]))4２、A.ｃ和B．c兩個c文獻中使用了兩個相同名字的ｓtatiｃ變量,編譯的時候會不會有問題?這兩個stａtiｃ變量會保存到哪里(棧還是堆或者其他的)?答：sｔatic的全局變量,表白這個變量僅在本模塊中故意義,不會影響其他模塊。他們都放在數據區,但是編譯器對他們的命名是不同的。假如要使變量在其他模塊也故意義的話，需要使用exｔern關鍵字。43、一個單向鏈表，不知道頭節點,一個指針指向其中的一個節點，問如何刪除這個指針指向的節點?答:將這個指針指向的nexｔ節點值coｐｙ到本節點，將ｎexｔ指向next－>next,并隨后刪除原ｎexｔ指向的節點。第二部分：程序代碼評價或者找錯1、下面的代碼輸出是什么，為什么?

ｖoidfoo（ｖoid)

｛

ｕnｓiｇnedｉｎta=6；?

intb=-2０；?

(a＋b>6）?ｐuts（＂>6"）:ｐuts(＂<＝6")；

}

這個問題測試你是否懂得C語言中的整數自動轉換原則，我發現有些開發者懂得很少這些東西。不管如何，這無符號整型問題的答案是輸出是">6"。因素是當表達式中存在有符號類型和無符號類型時所有的操作數都自動轉換為無符號類型。因此-20變成了一個非常大的正整數,所以該表達式計算出的結果大于6。這一點對于應當頻繁用到無符號數據類型的嵌入式系統來說是豐常重要的。假如你答錯了這個問題，你也就到了得不到這份工作的邊沿。

2、評價下面的代碼片斷:

uｎｓigneｄintzｅrｏ＝0;

uｎsignedintｃompzeｒｏ=0ｘFＦFF;?/＊１＇ｓcompleｍenｔｏfzerｏ*／?對于一個int型不是1６位的解決器為說，上面的代碼是不對的的。應編寫如下:

unsignｅdｉｎｔｃompｚeｒo=~0；

這一問題真正能揭露出應試者是否懂得解決器字長的重要性。在我的經驗里，好的嵌入式程序員非常準確地明白硬件的細節和它的局限，然而PC機程序往往把硬件作為一個無法避免的煩惱。3、C語言批準一些令人震驚的結構,下面的結構是合法的嗎，假如是它做些什么?

ｉnta＝5,b=7,c;?c=ａ+＋+b；?這個問題將做為這個測驗的一個快樂的結尾。不管你相不相信,上面的例子是完全合乎語法的。問題是編譯器如何解決它？水平不高的編譯作者事實上會爭論這個問題，根據最解決原則，編譯器應當能解決盡也許所有合法的用法。因此,上面的代碼被解決成:?ｃ=a＋++b;?因此,這段代碼持行后a=6，b=7,ｃ=12。

假如你知道答案，或猜出對的答案,做得好。假如你不知道答案，我也不把這個當作問題。我發現這個問題的最大好處是這是一個關于代碼編寫風格,代碼的可讀性，代碼的可修改性的好的話題。

４、設有以下說明和定義:typｅdefｕnioｎ｛longｉ;intｋ［5］;ｃhaｒc;}DＡＴE;sｔructｄata{ｉｎtｃat;DATEcow;ｄoｕbledｏｇ；}too;ＤＡTEmax;則語句priｎtf("%d",sizeof（ｓｔrｕctdate）+ｓiｚｅｏf(max）);的執行結果是？答、結果是：52。DATE是一個ｕnion，變量公用空間．里面最大的變量類型是int［５],占用20個字節.所以它的大小是20daｔａ是一個ｓｔruct,每個變量分開占用空間.依次為iｎt4+DATE２０+doｕblｅ8=32．所以結果是２0+3２=５2.當然...在某些1６位編輯器下,int也許是2字節,那么結果是iｎt2+DATＥ１０+ｄouble８=205、請寫出下列代碼的輸出內容#ｉnclｕｄe<sｔdio．h＞ｍａin()｛inta,b，c,d;a＝1０;b＝a++;c＝+＋a；ｄ=10*a＋+;prｉntｆ（"ｂ，c,d:%ｄ，%d，％d＂，ｂ，c，ｄ）;reｔuｒｎ0;｝答：１０,12,1２06、寫出下列代碼的輸出內容#includｅ＜stｄｉo．ｈ＞ｉntinｃ(inｔa）{ｒeｔurn(+＋ａ)；}intmｕlti（iｎt*a，ｉnt*ｂ,ｉnt*ｃ){reｔurn(*c＝＊a**b)；}tyｐeｄefｉnt(FUNC1)（iｎｔin);tyｐedefiｎｔ（FUＮC2)(int*,iｎｔ*,int*);voidshoｗ(ＦUＮC２ｆun,intarｇ1,inｔ*arg2）｛INCp=&inc;inｔteｍｐ=p(arg１）;fuｎ（＆tｅmp,&aｒｇ1,arg2);pｒiｎｔf（"%d\n",*aｒg２);｝ｍain(){iｎta;show(mulｔi，10,&a）;reｔurｎ0;}答:１10?７、請找出下面代碼中的所以錯誤說明:以下代碼是把一個字符串倒序，如“abｃd”倒序后變為“dｃba”1、#ｉnclude"strinｇ．ｈ＂2、main()3、{4、cｈar＊src＝"ｈeｌｌo,ｗｏｒld";5、char＊dｅst＝ＮULL;6、intlen=sｔｒlｅn（src);７、dest＝（ｃhar＊)mａlloc(leｎ)；8、chaｒ*d=dest;9、char*s＝ｓｒｃ[ｌｅｎ];１0、whｉｌｅ（len--!=0)１1、d＋+＝s--;12、ｐrｉntf("%ｓ",dest）;13、retuｒｎ0;14、}答：方法1：iｎtｍａｉn(){chaｒ＊ｓrｃ="hello,ｗorld";intｌen=ｓtrlen（srｃ)；char＊deｓｔ=（cｈａr*)malloc(ｌen＋1）;/／要為\0分派一個空間ｃｈar＊d=dest;ｃhar*s=&src[len－1];//指向最后一個字符while（lｅn--!=０)*d++=*ｓ-－;*d=０;//尾部要加＼0printf("％s＼n",desｔ)；fｒｅe(dｅst);/／使用完，應當釋放空間,以免導致內存匯泄露ｒｅtuｒn0;}方法２:#inclｕde<sｔdiｏ.ｈ＞#inclｕｄe<striｎｇ.ｈ>main（){charstr[]＝"hello,worｌd＂;ｉntlen＝strｌeｎ(ｓtr）；ｃhａrt;fｏｒ(inti=0；ｉ<ｌen/2;i++){t=sｔｒ［i];str[i]=ｓｔr[ｌeｎ-i-１］；stｒ[len-i-1]＝t;}ｐｒintｆ（"%s",str)；returｎ０;}?8、請問下面程序有什么錯誤?ｉntａ[６０][250][10０0］，i,j，k;ｆor(k=0;k<=100０;k++)fｏr(j=0；j＜250;j+＋)for（i=0；i<60；i++）ａ[ｉ][j]［k］=0;答案:把循環語句內外換一下9、請問下面程序會出現什么情況?.#deｆineMaｘ＿CB5０0voｉｄＬmiQueryCＳmd(SｔructＭSgCB*pmsｇ){unsｉgnｅdｃharucCｍdNum;......foｒ(ucＣmdNｕm=0;ucCmdNum<Max_CB;ucCmdNｕm＋+)｛...．.．;}答案:死循環１0、以下3個有什么區別?ｃhar＊conｓtｐ;//常量指針，p的值不可以修改charｃonst*p;//指向常量的指針，指向的常量值不可以改coｎstchａr*p；/／和ｃｈａrｃｏｎst*p11、寫出下面的結果ｃhａrstｒ１[］="abc"；ｃharsｔr2［]＝"ａbｃ";conｓｔchａｒstｒ３［]="abc";constcｈaｒｓtr４[]=＂abc"；ｃoｎｓtｃhaｒ*sｔr5=＂ａbc";constchａr*sｔｒ6="abc";char＊str７＝"ａbc";char*stｒ８=＂abc";couｔ<＜(str1==str2)<<eｎｄl；ｃout<<(sｔr３==ｓtr4)<<enｄl;ｃout＜<(stｒ5＝=stｒ6)<<enｄl;ｃout<<（ｓtr7==str8)<<endl;結果是:0０11解答:str1,ｓtr2，ｓｔr3，ｓｔr４是數組變量，它們有各自的內存空間；而str5,ｓtr６，sｔr7，str8是指針，它們指向相同的常量區域。１２、以下代碼中的兩個sｉzｅoｆ用法有問題嗎？vｏidUｐpｅrＣａse(cｈarｓtr［]）／/將ｓtr中的小寫字母轉換成大寫字母{foｒ(sizｅ_ｔｉ=0;ｉ＜ｓizeof(sｔｒ)/sｉｚｅof（stｒ[０]);+＋i)iｆ('ａ'＜＝str[i]＆&str［i］<='z＇）stｒ[ｉ]-=('ａ'-'A');}chａrsｔr[]="ａBcＤe＂;ｃout<＜"stｒ字符長度為:＂<＜sｉｚeof(stｒ)/sｉzｅｏf(ｓｔr[0]）<＜ｅｎdl；ＵppｅｒCase(str);coｕt<<stｒ<＜enｄl;答：函數內的sizｅof有問題。根據語法,sｉzeof如用于數組，只能測出靜態數組的大小,無法檢測動態分派的或外部數組大小。函數外的stｒ是一個靜態定義的數組,因此其大小為６,函數內的str實際只是一個指向字符串的指針,沒有任何額外的與數組相關的信息，因此sｉzｅｏf作用于上只將其當指針看，一個指針為4個字節,因此返回４。13、寫出輸出結果maiｎ(）｛inｔa[５］={１,２,3,4,5}；inｔ＊ptr=(inｔ*)（&a＋1);printf(＂％d,%d"，*(ａ+１),*(pｔr-1)）;}輸出:2,５*(a+1)就是ａ［１],*(ptr-1）就是a[4]，執行結果是2，5&a+1不是首地址+１，系統會認為加一個a數組的偏移,是偏移了一個數組的大小（本例是5個ｉｎt)int＊ｐtr=(int*)(＆a＋1）；則ptr實際是&（a［5］),也就是ａ+5因素如下：＆a是數組指針，其類型為int(*)[5］；而指針加1要根據指針類型加上一定的值,不同類型的指針+1之后增長的大小不同ａ是長度為５的iｎt數組指針，所以要加5*ｓizeof(inｔ)所以ptr實際是a[5]但是ｐｒt與(&ａ＋1)類型是不同樣的（這點很重要)所以prt－1只會減去ｓizeof(int*）a,&a的地址是同樣的,但意思不同樣，a是數組首地址,也就是ａ［0］的地址，&a是對象(數組)首地址,ａ+１是數組下一元素的地址，即ａ[1],&a+１是下一個對象的地址，即a[５].１4、請問以下代碼有什么問題:intmａin（){cｈara;chaｒ＊stｒ＝＆a;ｓtrcpｙ(ｓtr，＂hello＂);printf(str)；rｅturn0;}沒有為sｔr分派內存空間，將會發生異常問題出在將一個字符串復制進一個字符變量指針所指地址。雖然可以對的輸出結果,但由于越界進行內在讀寫而導致程序崩潰。char*s="ＡAA＂;ｐrintｆ("%s",ｓ）;s[0]=＇B';pｒiｎtf(＂%s＂,s);有什么錯？"AＡA"是字符串常量。s是指針,指向這個字符串常量,所以聲明s的時候就有問題。cosnｔchar*s＝"AＡA＂;然后又由于是常量，所以對是s[0]的賦值操作是不合法的。15、有以下表達式：intａ=２48;b=4；intconsｔc=２1;ｃoｎstint*d=&a;int＊ｃonsｔe=＆b；intconｓt＊fｃonｓt=＆ａ;請問下列表達式哪些會被編譯器嚴禁?為什么？＊ｃ=3２；ｄ=&b;*d=４3;ｅ=３4;e＝&a;ｆ=０x321f;*c這是個什么東東，嚴禁*d說了是conｓt，嚴禁ｅ=&a說了是ｃｏnsｔ嚴禁const*fcoｎst=＆a;嚴禁1６、互換兩個變量的值，不使用第三個變量。即a＝3,b=5,互換之后a=５,b=3;有兩種解法，一種用算術算法,一種用^(異或)a=ａ+b;b=a－ｂ；a=a-b；ｏra=a^b；//只能對int,chａr..b=a^ｂ；a＝a^b;ｏra^=b^=a；1７、下面的程序會出現什么結果.#inｃluｄe<ｓｔdio.ｈ>＃includｅ＜stdliｂ.ｈ>vｏidgetmemｏｒy(chaｒ*p）{p=（chａr*)mａlloｃ(１0０)；strcpy(p,"hｅllowｏrlｄ＂)；｝inｔmａｉｎ(){chａｒ＊sｔｒ=NUＬＬ;geｔmemoｒｙ（str);ｐriｎtｆ("％s/n",sｔr）;ｆｒee(str);retｕrｎ0；}程序崩潰,getｍeｍory中的malｌｏc不能返回動態內存,ｆree（)對str操作很危險１8、下面的語句會出現什么結果?chａｒsｚstr[10］;sｔｒcpy(szstr，"＂);答案:長度不同樣,會導致非法的ＯS,應當改為cｈarszｓtr[11];19、(vｏｉd*）ptｒ和（*(voｉd*＊))pｔｒ的結果是否相同?答：其中pｔｒ為同一個指針.（voiｄ*）ｐtｒ和(*(void**))ptr值是相同的２0、問函數既然不會被其它函數調用，為什么要返回1？intmain(）{intx=3;ｐrｉｎtf(＂%d＂，ｘ);ｒeturｎ１;}答:ｍian中,ｃ標準認為0表達成功，非０表達錯誤。具體的值是某中具體犯錯信息21、對絕對地址０x１０0000賦值且想讓程序跳轉到絕對地址是0x10０000去執行(unsignedint*）0ｘ1００000＝１2３4；一方面要將0x１00000強制轉換成函數指針，即：（void(*）())０ｘ100000然后再調用它:*((vｏid(*)(））0x１0０00０)()；用typｅdef可以看得更直觀些:tｙpedｅｆvoiｄ(*)()voiｄFuncPtr;*((ｖｏidFunｃPtr）0x1０0000）()；22、輸出多少?并分析過程ｕnsigｎedｓhorｔＡ=10;ｐrintf("~A=％u\ｎ",~A);cｈarc=１２８；ｐｒiｎtf（＂c=％ｄ\n",c);第一題,～Ａ＝0ｘfffffｆf5，iｎt值為-11,但輸出的是uint。所以輸出第二題，ｃ=０x１0,輸出的是iｎt,最高位為1,是負數,所以它的值就是0ｘ00的補碼就是１28,所以輸出－1２８。這兩道題都是在考察二進制向iｎｔ或uint轉換時的最高位解決。２３、分析下面的程序:voｉｄGetMeｍory(chaｒ**p,iｎtnuｍ){＊p=(chａr*)mallｏc(ｎｕm）;}iｎtmaiｎ(）{char*str=NＵLL;GｅｔMemｏrｙ（&ｓｔr，100);strcpy(sｔr,"hｅllo"）;ｆree（str）;if（ｓtr!=NULL）{strcpy(str,"wｏrld");}printf（"\nｓtrｉｓ%s",str);getcｈaｒ（);}問輸出結果是什么?希望大家能說說因素,先謝謝了輸出strｉsworld。free只是釋放的ｓtｒ指向的內存空間,它自身的值還是存在的.所以fｒee之后,有一個好的習慣就是將ｓtr=NUＬL.此時stｒ指向空間的內存已被回收,假如輸出語句之前還存在分派空間的操作的話,這段存儲空間是也許被重新分派給其他變量的，盡管這段程序的確是存在大大的問題（上面各位已經說得很清楚了),但是通常會打印出ｗｏrld來。這是由于,進程中的內存管理一般不是由操作系統完畢的，而是由庫函數自己完畢的。當你maｌloc一塊內存的時候,管理庫向操作系統申請一塊空間(也許會比你申請的大一些),然后在這塊空間中記錄一些管理信息(一般是在你申請的內存前面一點），并將可用內存的地址返回。但是釋放內存的時候,管理庫通常都不會將內存還給操作系統,因此你是可以繼續訪問這塊地址的,只但是。。。。。。。。樓上都說過了,最佳別這么干。2４、chａｒa[1０],ｓｔｒleｎ(a)為什么等于15?運營的結果#include"stdio.ｈ"#incｌudｅ＂ｓｔｒing．h"ｖoidmain(）{cｈａraa[10];pｒｉntf("%ｄ＂，sｔrｌen(aa));｝siｚeof（)和初不初始化,沒有關系；stｒｌen（)和初始化有關。char（*str)［２０］；/＊ｓtｒ是一個數組指針，即指向數組的指針．＊/char*ｓｔr[2０];／*ｓｔr是一個指針數組,其元素為指針型數據．＊／２５、ｌonga=0x８０１010;a+５=?答：0x801０10用二進制表達為:“10０0０００0０001０00000０１000０”，十進制的值為８３92720，再加上５就是839272526、給定結構stｒｕctA{charｔ::4;cｈａrｋ:4；ｕｎｓｉgｎedｓhorti：８;uｎsigｎeｄloｎgm;｝;問sizeoｆ(Ａ)＝?給定結構structA{ｃｈart:4;4位chark：４;４位ｕnsignedshorti:8;8位unsigｎｅdlｏｎgm;//偏移2字節保證4字節對齊}；／/共８字節２7、下面的函數實現在一個數上加一個數,有什么錯誤?請改正。intadd＿n(intn)｛sｔaｔiｃiｎtｉ=100；i+=n;ｒｅturni;｝當你第二次調用時得不到對的的結果,難道你寫個函數就是為了調用一次？問題就出在static上２８、給出下面程序的答案＃inｃｌｕde＜ioｓtream.ｈ>#iｎclude<striｎg.h>＃inｃlude<ｍalloｃ.h＞＃incluｄe＜stdio.h>#iｎclｕde<stdliｂ.h>#inclｕdｅ＜meｍory．ｈ＞typedefstruｃtＡA{intｂ1：５;iｎtｂ2:２；｝AA;ｖoｉdmaiｎ（)｛ＡAaa;cｈarcc[1０0];ｓｔｒcｐy(ｃc,＂ａbcdeｆgｈijkｌmnoｐｑrstuvwｘyｚ");meｍcｐｙ(＆aａ，cc,sｉzｅof（ＡA）)；cｏｕt<<ａａ.b1＜<ｅndl;cｏｕt＜<ａa．b2<＜endl;｝答案是-16和１一方面ｓizeｏf(AＡ)的大小為4,b1和ｂ2分別占5bit和2bit.通過sｔrcpy和memcｐy后,aａ的4個字節所存放的值是:0，1,2,3的ＡSＣ碼,即００11000０，0０１１0０01,001１0010,０011００11所以,最后一步:顯示的是這４個字節的前5位,和之后的２位分別為：1０00０,和01由于iｎt是有正負之分所以：答案是-１６和1２9、求函數返回值,輸入x=9９99；intfunｃ（x){ｉntcounｔｘ＝0;whiｌｅ（x){countx++；x＝ｘ＆(x-1）;｝reｔurｎｃountx;}結果呢?知道了這是記錄9999的二進制數值中有多少個1的函數,且有9999＝9×1024+512＋２56＋159×10２4中具有1的個數為2；5１2中具有1的個數為１；25６中具有１的個數為1；１5中具有1的個數為４;故共有1的個數為８,結果為8。1000-1＝0111,正好是原數取反。這就是原理。用這種方法來求1的個數是很效率很高的。不必去一個一個地移位。循環次數最少。３0、分析:strｕctbit{ｉnta：3；iｎtb:2;intc:3;};intｍaｉn(）{bits;char*ｃ=(ｃhaｒ＊)&s;cout<<sｉzeoｆ(ｂiｔ)<<ｅndl；＊c=0ｘ9９；cout＜<ｓ.a<<endｌ<<s.ｂ<<enｄl<<s．ｃ<<enｄl;ｉnta=－1;pｒiｎtf("％x",a);rｅtｕrｎ０;}輸出為什么是41-1-4ｆffffｆfｆ由于0x99在內存中表達為１0０11001，a=001，b=11,c＝100當c為有符合數時,c=100，最高1為表達c為負數，負數在計算機用補碼表達,所以ｃ=-4;同理b=－1;當c為有符合數時,c＝10０,即c＝４,同理b＝3３1、下面這個程序執行后會有什么錯誤或者效果:#ｄefinｅMＡX２55intｍaiｎ(){unsigｎedcharＡ[MAX]，ｉ；／/ｉ被定義為unsignedcｈarfoｒ（ｉ=0;i<=MAＸ;i＋+)Ａ[i]=ｉ;}解答:死循環加數組越界訪問(C/C++不進行數組越界檢查）MAX=255數組A的下標范圍為:0..MAＸ－1,這是其一..其二.當i循環到255時,循環內執行:A[２55］=25５;這句自身沒有問題..但是返回ｆor(i=0;i<＝MAＸ;i++)語句時,由于unsiｇnedchar的取值范圍在(０..255)，i++以后i又為０了．．無限循環下去．3２、寫出ｓizeof(structｎame1)=,ｓiｚeof(strucｔnaｍe２)=的結果strｕctnaｍe1{cｈarstr;shoｒtx;inｔnum;}sｔructnamｅ2｛charstr；intｎｕm;sｈoｒｔx；}sｉzeof(ｓｔｒucｔnaｍe１)=8,ｓizeｏｆ(structnａme2)=１2在第二個結構中，為保證nｕm按四個字節對齊，ｃhar后必須留出3字節的空間；同時為保證整個結構的自然對齊(這里是4字節對齊)，在x后還要補齊2個字節,這樣就是12字節。３３、struｃts1{intｉ:8;inｔj:4;inta:3;ｄoublｅb;};stｒｕctｓ2｛inti:8;inｔj:４;doubｌｅb；intａ:3;};printf(＂sizeoｆ(s1)＝%ｄ\n",sizeｏf(ｓ1));prｉntf("siｚeof(s2)＝％d\n",ｓiｚeｏf(s2));rｅsult：１6,24第一個ｓｔructs１{inti:8；inｔj:４;inta:3;dｏｕbleb;｝;理論上是這樣的，一方面是i在相對0的位置,占8位一個字節,然后，ｊ就在相對一個字節的位置,由于一個位置的字節數是4位的倍數,因此不用對齊,就放在那里了，然后是a,要在3位的倍數關系的位置上，因此要移一位，在15位的位置上放下，目前總共是1８位，折算過來是2字節2位的樣子，由于ｄoｕｂle是8字節的，因此要在相對０要是8個字節的位置上放下,因此從1８位開始到8個字節之間的位置被忽略，直接放在8字節的位置了,因此，總共是16字節。第二個最后會對照是不是結構體內最大數據的倍數，不是的話,會補成是最大數據的倍數3４、在對齊為４的情況下strucｔBBB{longnuｍ；ｃhar*namｅ；ｓhｏrtiｎtdata;charha;shorｔba[5];}*ｐ；p=０ｘ10000０0；p＋0x200=____;(Ulｏng)p+0x200=_＿__;(ｃｈar*)p＋０ｘ200=____;希望各位達人給出答案和因素，謝謝拉解答：假設在３2位CＰＵ上,sizeof（long）=4byｔesｓｉzeof(char*)＝４bytｅssizeof(ｓhorｔｉnt)=ｓiｚeof(ｓhｏrt)＝2bytessizeof(cｈar)=１ｂyｔeｓ由于是4字節對齊,siｚeｏf（stｒｕcｔBBＢ)＝sｉzeof（*ｐ)=4+4+２+1＋1/＊補齊*/+2＊５+2／*補齊*/＝24bytes(經Ｄev-C++驗證)p＝0x100０000；p+0x200=____;=0x1０0００００+０x20０＊24(Ulｏng）p＋０x2０0=___＿;=0ｘ10000００+0x２00(char*）p+0x200=____;＝０x1０00０00+０ｘ200＊４35、找錯Voｉdtest1(){cｈaｒstring［10]；ｃhａr*ｓtr1＝"";strcpy(ｓtring,str１)；//溢出,應當涉及一個存放'\0'的字符strｉng［１1]}Voidtest2(）{cｈarstriｎg[１0],stｒ1[１0］;for（I＝０;Ｉ<10;I++){ｓtr1[i］='ａ';}sｔrcpy（stｒing，sｔｒ1);/／I，ｉ沒有聲明。}Vｏidｔest3(cｈａr*stｒ1）{ｃhａrstring[10];if(ｓｔrlｅｎ（str１）<＝10)//改成＜１0,字符溢出，將strleｎ改為sｉzeof也可以{sｔrcpy(ｓtriｎｇ,ｓtr1)；}}36、寫出輸出結果voidg(iｎt＊*）;ｉntｍain（）{inｔliｎe[10］,i;iｎｔ*p=lｉnｅ;/／p是地址的地址fｏr（i＝0;ｉ＜10;i++）{＊p=i;g(&p）;//數組相應的值加1}foｒ(ｉ=０;i<１0;i++)ｐｒintf(＂%d＼ｎ",lｉne［i]);reｔurn0;}voidg(ｉnt**ｐ）{(＊*p)＋+；(＊ｐ)＋+；/／無效}輸出：12３45６7８９１037、寫出程序運營結果intsum（iｎta){autointc＝０;staｔicintb=３;c+=1;b＋＝2;rｅtｕrn(a+ｂ＋c);}voidmain()｛intＩ；ｉntａ＝2;for(I＝0；I<5;I＋+){printｆ("%ｄ，",sｕm(a));｝}//ｓtatic會保存上次結果,記住這一點,剩下的自己寫輸出：８，1０,12，14,１6，3８、評價代碼intｆunc(intａ）{intb;swｉtch（a)｛ｃａse1：３0；casｅ２:20;cａｓe3:16;dｅfault:０}rｅtｕrnｂ;}則funｃ（1)=？／／b定義后就沒有賦值ｉnta[3]；a[0］=0;a[1]＝１;a[2］=2；int*p,*ｑ;ｐ=ａ;q=＆a[2];則a[ｑ-p]=ａ[２]解釋：指針一次移動一個int但計數為139、請問一下程序將輸出什么結果？ｃhaｒ＊RetMenory(vｏid){charp[]=“hｅｌｌowworlｄ”;ｒeturnp;}voidＴeｓt(void)｛char*ｓtr=NULL;str=RｅtＭeｍｏrｙ();prｉntｆ(str);}RetMeｎｏry執行完畢,p資源被回收,指向未知地址。返回地址，ｓtr的內容應是不可預測的,打印的應當是str的地址40、寫出輸出結果tyｐｅdefｓtruct{intａ：2；intb:2；ｉntc：１；}tesｔ；tesｔt;t.a=1；t．b＝３;t.ｃ=1;pｒiｎtf("％ｄ",t.a);priｎtf（"%d＂,ｔ.b);ｐrintf("%d"，t.c）;ｔ．a為01,輸出就是1t．ｂ為１1，輸出就是－1ｔ.c為１，輸出也是-1３個都是有符號數ｉnt嘛。這是位擴展問題０1１11編譯器進行符號擴展41、對下面程序進行分析voiｄtesｔ2（){charstrｉng[１0]，stｒ1[1０］；ｉnti;ｆor(i=0；i＜１０；i++）{sｔr1[i]=＇a＇;｝ｓｔrcｐy(string，sｔr1)；}解答：假如面試者指出字符數組stｒ１不能在數組內結束可以給3分；假如面試者指出ｓtrｃpｙ(striｎg,stｒ1)調用使得從str1內存起復制到string內存起所復制的字節數具有不擬定性可以給7分，在此基礎上指出庫函數strｃpy工作方式的給10分；ｓtｒ1不能在數組內結束:由于str１的存儲為：{a,ａ,a,ａ,a,a,ａ,a,a,a｝,沒有＇\0＇(字符串結束符)，所以不能結束sｔrcpy(chａr＊s1,cｈaｒ*s2)他的工作原理是,掃描s2指向的內存，逐個字符付到ｓ1所指向的內存，直到碰到'＼０'，由于stｒ１結尾沒有'＼０'，所以具有不擬定性，不知道他后面還會付什么東東。對的應如下voidtest2()｛cｈarstriｎg[10］,stｒ１[10］；ｉｎｔｉ;ｆor(ｉ＝0;i<９;i＋+）｛str１[i］＝'a'+i;／/把ａｂcｄefgｈi賦值給字符數組}str[ｉ］＝＇\0＇;//加上結束符ｓtrｃｐy（strｉng,ｓtr1)；}42、分析:intａrr[]＝{6，7,8，９，10};ｉnｔ*ptｒ＝arr;＊（ptr++）+=1２３；pｒintf（“％d％d”,*ptr,*（++ｐtr));輸出：8８過程:對于*(pｔr++)+=123;先做加法6+123,然后+＋，指針指向7;對于printf(“％d％d”，*ｐtr,*(+＋ｐtｒ)）;從后往前執行,指針先+＋,指向8,然后輸出8，緊接著再輸出843、分析下面的代碼：ｃhar*a="hello＂;ｃhａr*b="ｈello＂;if(a＝=b）priｎtf("YES")；elseprinｔf（"NＯ＂）;這個簡樸的面試題目，我選輸出no(對比的應當是指針地址吧）,可在VC是YEＳ在C是ＮOlz的呢，是一個常量字符串。位于靜態存儲區,它在程序生命期內恒定不變。假如編譯器優化的話,會有也許a和b同時指向同一個hellｏ的。則地址相同。假如編譯器沒有優化，那么就是兩個不同的地址，則不同44、寫出輸出結果#ｉnｃlude<stdｉo.h>voｉｄfoo（iｎｔｍ，inｔｎ){prinｔf（＂m＝%d,ｎ=%d\n＂,ｍ,ｎ）；｝iｎtmａin(){ｉntｂ=3;foｏ（b+=3,++ｂ)；ｐrｉntｆ（"b=%d\ｎ",ｂ);rｅturn0；}輸出:m＝７,n＝４,ｂ＝７(VC6．0)這種方式和編譯器中得函數調用關系相關即先后入棧順序。但是不同編譯器得解決不同。也是由于Ｃ標準中對這種方式說明為未定義，所以各個編譯器廠商都有自己得理解，所以最后產生得結果完全不同。由于這樣，所以碰見這種函數，我們一方面要考慮我們得編譯器會如何解決這樣得函數,另一方面看函數得調用方式，不同得調用方式，也許產生不同得結果。最后是看編譯器優化。４5、找犯錯誤#includestrｉng.ｈmain(voｉｄ){chａr*sｒｃ="ｈello,ｗoｒld";chａr*dest=NUＬL；dest＝(chａr*)mａｌｌoc(ｓtrleｎ(sｒc));intleｎ=strｌeｎ(str);chａr*d＝dest;chａr＊s=ｓrｃ[ｌen];while（ｌｅn－-！=０）d＋＋＝ｓ--;prinｔｆ("%ｓ"，deｓt）;}找犯錯誤!!#ｉnｃlude"striｎｇ．h"#ｉｎcｌｕdｅ"stｄｉo.ｈ"#ｉnclude"malloc.h＂main(void）{cｈar*srｃ="helｌo,ｗorld";cｈａr*dｅｓt=NULＬ;dest=(chａｒ*)malloc（sizeｏf(cｈar）*(strlen(src）+1));intlen＝strlｅn(sｒc);char*d=dest;ｃhar*s=sｒc+len-1;