C++笔试题目大全(笔试宝典)
1.new 、 delete 、 malloc 、 free 關(guān)系
delete 會調(diào)用對象的析構(gòu)函數(shù) , 和 new 對應(yīng) 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/free 。因此 C++ 語言需要一個能完成動態(tài)內(nèi)存分配和初始化工作的運算符 new ，以及一個能完成清理與釋放內(nèi)存工作的運算符 delete 。注意 new/delete 不是庫函數(shù)。
總結(jié)：new和delete會自動調(diào)用對象的構(gòu)造與析構(gòu)函數(shù)而malloc與free不會；
????? new和delete式C++運算符，而malloc和free是C/C++標準庫函數(shù)。
?
2.delete?與 delete [] 區(qū)別
delete 只會調(diào)用一次析構(gòu)函數(shù)，而 delete[] 會調(diào)用每一個成員的析構(gòu)函數(shù)。在 More Effective? C++ 中有更為詳細的解釋：“當(dāng) 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*pInt1=newint[10];
? int*pInt2=newint;
? delete[]pInt1;? //-1-
? delete[]pInt2;? //-2-
? delete[]mTest1;//-3-
? delete[]mTest2;//-4-
? 在 -4- 處報錯。
這就說明：對于內(nèi)建簡單數(shù)據(jù)類型， delete 和 delete[] 功能是相同的。對于自定義的復(fù)雜數(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ù)組。
總結(jié)： delete 只會調(diào)用一次析構(gòu)函數(shù)，而 delete[] 會調(diào)用每一個成員的析構(gòu)函數(shù)。
3.C C++ JAVA?共同點，不同之處？
?
4.?繼承優(yōu)缺點。
類繼承是在編譯時刻靜態(tài)定義的，且可直接使用，類繼承可以較方便地改變父類的實現(xiàn)。但是類繼承也有一些不足之處。首先，因為繼承在編譯時刻就定義了，所以無法在運行時刻改變從父類繼承的實現(xiàn)。更糟的是，父類通常至少定義了子類的部分行為，父類的任何改變都可能影響子類的行為。如果繼承下來的實現(xiàn)不適合解決新的問題，則父類必須重寫或被其他更適合的類替換。這種依賴關(guān)系限制了靈活性并最終限制了復(fù)用性。
（待補充）
?
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ù)的返回值（微軟）
int func(x)?
{?
??? int countx = 0;?
??? while(x)?
??? {?
????????? countx ++;?
????????? x = x&(x-1);?
???? }?
??? return countx;?
}?
假定 x = 9999 。 答案： 8
思路：將 x 轉(zhuǎn)化為 2 進制，看含有的 1 的個數(shù)。
9.?什么是 “ 引用 ” ？申明和使用 “ 引用 ” 要注意哪些問題？
答：引用就是某個目標變量的 “ 別名 ”(alias) ，對應(yīng)用的操作與對變量直接操作效果完全相同。申明一個引用的時候，切記要對其進行初始化。引用聲明完畢后，相當(dāng)于目標變量名有兩個名稱，即該目標原名稱和引用名，不能再把該引用名作為其他變量名的別名。聲明一個引用，不是新定義了一個變量，它只表示該引用名是目標變量名的一個別名，它本身不是一種數(shù)據(jù)類型，因此引用本身不占存儲單元，系統(tǒng)也不給引用分配存儲單元。不能建立數(shù)組的引用。
10.?將 “ 引用 ” 作為函數(shù)參數(shù)有哪些特點？
（ 1 ）傳遞引用給函數(shù)與傳遞指針的效果是一樣的。這時，被調(diào)函數(shù)的形參就成為原來主調(diào)函數(shù)中的實參變量或?qū)ο蟮囊粋€別名來使用，所以在被調(diào)函數(shù)中對形參變量的操作就是對其相應(yīng)的目標對象（在主調(diào)函數(shù)中）的操作。
（ 2 ）使用引用傳遞函數(shù)的參數(shù)，在內(nèi)存中并沒有產(chǎn)生實參的副本，它是直接對實參操作；而使用一般變量傳遞函數(shù)的參數(shù)，當(dāng)發(fā)生函數(shù)調(diào)用時，需要給形參分配存儲單元，形參變量是實參變量的副本；如果傳遞的是對象，還將調(diào)用拷貝構(gòu)造函數(shù)。因此，當(dāng)參數(shù)傳遞的數(shù)據(jù)較大時，用引用比用一般變量傳遞參數(shù)的效率和所占空間都好。
（ 3 ）使用指針作為函數(shù)的參數(shù)雖然也能達到與使用引用的效果，但是，在被調(diào)函數(shù)中同樣要給形參分配存儲單元，且需要重復(fù)使用 "* 指針變量名 " 的形式進行運算，這很容易產(chǎn)生錯誤且程序的閱讀性較差；另一方面，在主調(diào)函數(shù)的調(diào)用點處，必須用變量的地址作為實參。而引用更容易使用，更清晰。
11.?在什么時候需要使用 “ 常引用 ” ？
如果既要利用引用提高程序的效率，又要保護傳遞給函數(shù)的數(shù)據(jù)不在函數(shù)中被改變，就應(yīng)使用常引用。常引用聲明方式： const 類型標識符 & 引用名 = 目標變量名；
例 1
int a ;
const int &ra=a;
ra=1; // 錯誤?
a=1; // 正確
例 2
string foo( );
void bar(string & s);
那么下面的表達式將是非法的：
bar(foo( ));
bar("hello world");
原因在于 foo( ) 和 "hello world" 串都會產(chǎn)生一個臨時對象，而在 C++ 中，這些臨時對象都是 const 類型的。因此上面的表達式就是試圖將一個 const 類型的對象轉(zhuǎn)換為非 const 類型，這是非法的。引用型參數(shù)應(yīng)該在能被定義為 const 的情況下，盡量定義為 const 。
12.?將 “ 引用 ” 作為函數(shù)返回值類型的格式、好處和需要遵守的規(guī)則 ?
格式：類型標識符 & 函數(shù)名（形參列表及類型說明） { // 函數(shù)體 }
好處：在內(nèi)存中不產(chǎn)生被返回值的副本；（注意：正是因為這點原因，所以返回一個局部變量的引用是不可取的。因為隨著該局部變量生存期的結(jié)束，相應(yīng)的引用也會失效，產(chǎn)生 runtime error! 注意事項：
（ 1 ）不能返回局部變量的引用。這條可以參照 Effective C++[1] 的 Item 31 。主要原因是局部變量會在函數(shù)返回后被銷毀，因此被返回的引用就成為了 " 無所指 " 的引用，程序會進入未知狀態(tài)。
（ 2 ）不能返回函數(shù)內(nèi)部 new 分配的內(nèi)存的引用。這條可以參照 Effective C++[1] 的 Item 31 。雖然不存在局部變量的被動銷毀問題，可對于這種情況（返回函數(shù)內(nèi)部 new 分配內(nèi)存的引用），又面臨其它尷尬局面。例如，被函數(shù)返回的引用只是作為一個臨時變量出現(xiàn)，而沒有被賦予一個實際的變量，那么這個引用所指向的空間（由 new 分配）就無法釋放，造成 memory leak 。
（ 3 ）可以返回類成員的引用，但最好是 const 。這條原則可以參照 Effective C++[1] 的 Item 30 。主要原因是當(dāng)對象的屬性是與某種業(yè)務(wù)規(guī)則（ business rule ）相關(guān)聯(lián)的時候，其賦值常常與某些其它屬性或者對象的狀態(tài)有關(guān)，因此有必要將賦值操作封裝在一個業(yè)務(wù)規(guī)則當(dāng)中。如果其它對象可以獲得該屬性的非常量引用（或指針），那么對該屬性的單純賦值就會破壞業(yè)務(wù)規(guī)則的完整性。
（ 4 ）流操作符重載返回值申明為 “ 引用 ” 的作用：
流操作符 << 和 >> ，這兩個操作符常常希望被連續(xù)使用，例如： cout << "hello" << endl; 因此這兩個操作符的返回值應(yīng)該是一個仍然支持這兩個操作符的流引用。可選的其它方案包括：返回一個流對象和返回一個流對象指針。但是對于返回一個流對象，程序必須重新（拷貝）構(gòu)造一個新的流對象，也就是說，連續(xù)的兩個 << 操作符實際上是針對不同對象的！這無法讓人接受。對于返回一個流指針則不能連續(xù)使用 << 操作符。因此，返回一個流對象引用是惟一選擇。這個唯一選擇很關(guān)鍵，它說明了引用的重要性以及無可替代性，也許這就是 C++ 語言中引入引用這個概念的原因吧。 賦值操作符 = 。這個操作符象流操作符一樣，是可以連續(xù)使用的，例如： x = j = 10; 或者 (x=10)=100; 賦值操作符的返回值必須是一個左值，以便可以被繼續(xù)賦值。因此引用成了這個操作符的惟一返回值選擇。
例 3
＃ i nclude <iostream.h>
int &put(int n);
int vals[10];
int error=-1;
void main()
{
put(0)=10; // 以 put(0) 函數(shù)值作為左值，等價于 vals[0]=10;?
put(9)=20; // 以 put(9) 函數(shù)值作為左值，等價于 vals[9]=20;?
cout<<vals[0];?
cout<<vals[9];
}?
int &put(int n)
{
if (n>=0 && n<=9 ) return vals[n];?
else { cout<<"subscript error"; return error; }
}
（ 5 ）在另外的一些操作符中，卻千萬不能返回引用： +-*/ 四則運算符。它們不能返回引用， Effective C++[1] 的 Item23 詳細的討論了這個問題。主要原因是這四個操作符沒有 side effect ，因此，它們必須構(gòu)造一個對象作為返回值，可選的方案包括：返回一個對象、返回一個局部變量的引用，返回一個 new 分配的對象的引用、返回一個靜態(tài)對象引用。根據(jù)前面提到的引用作為返回值的三個規(guī)則，第 2 、 3 兩個方案都被否決了。靜態(tài)對象的引用又因為 ((a+b) == (c+d)) 會永遠為 true 而導(dǎo)致錯誤。所以可選的只剩下返回一個對象了。
13.“?引用 ” 與多態(tài)的關(guān)系？
引用是除指針外另一個可以產(chǎn)生多態(tài)效果的手段。這意味著，一個基類的引用可以指向它的派生類實例。例 4
Class A; Class B : Class A{...};? B b; A& ref = b;
14.“?引用 ” 與指針的區(qū)別是什么？
指針通過某個指針變量指向一個對象后，對它所指向的變量間接操作。程序中使用指針，程序的可讀性差；而引用本身就是目標變量的別名，對引用的操作就是對目標變量的操作。此外，就是上面提到的對函數(shù)傳 ref 和 pointer 的區(qū)別。
15.?什么時候需要 “ 引用 ” ？
流操作符 << 和 >> 、賦值操作符 = 的返回值、拷貝構(gòu)造函數(shù)的參數(shù)、賦值操作符 = 的參數(shù)、其它情況都推薦使用引用。以上 2-8 參考： http://develop.csai.cn/c/NO0000021.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)
＃ i nclude <stdio.h>
union
{
int i;
char x[2];
}a;
void?main()
{
a.x[0] = 10;?
a.x[1] = 1;
printf("%d",a.i);
}
答案： 266 ( 低位低地址，高位高地址，內(nèi)存占用情況是 Ox010A ）
b)
main()?
???? {?
????????? union{?????????????????? /* 定義一個聯(lián)合 */?
?????????????? int i;?
?????????????? struct{???????????? /* 在聯(lián)合中定義一個結(jié)構(gòu) */?
??????????????????? char first;?
??????????????????? char second;?
?????????????? }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 對應(yīng) 'A', 是低位； Ox42 對應(yīng) 'B', 是高位）
???????6261 (number.i 和 number.half 共用一塊地址空間）
18.?關(guān)聯(lián)、聚合 (Aggregation) 以及組合 (Composition) 的區(qū)別？
涉及到 UML 中的一些概念：關(guān)聯(lián)是表示兩個類的一般性聯(lián)系，比如 “ 學(xué)生 ” 和 “ 老師 ” 就是一種關(guān)聯(lián)關(guān)系；聚合表示 has-a 的關(guān)系，是一種相對松散的關(guān)系，聚合類不需要對被聚合類負責(zé)，如下圖所示，用空的菱形表示聚合關(guān)系：從實現(xiàn)的角度講，聚合可以表示為 :
class A {...}? class B { A* a; .....}
而組合表示 contains-a 的關(guān)系，關(guān)聯(lián)性強于聚合：組合類與被組合類有相同的生命周期，組合類要對被組合類負責(zé)，采用實心的菱形表示組合關(guān)系：實現(xiàn)的形式是 :
class A{...} class B{ A a; ...}
參考文章： http://www.cnitblog.com/Lily/archive/2006/02/23/6860.html
????????? http://www.vckbase.com/document/viewdoc/?id=422
19.?面向?qū)ο蟮娜齻€基本特征，并簡單敘述之？
1. 封裝：將客觀事物抽象成類，每個類對自身的數(shù)據(jù)和方法實行 protection(private, protected,public)
2. 繼承：廣義的繼承有三種實現(xiàn)形式：實現(xiàn)繼承（指使用基類的屬性和方法而無需額外編碼的能力）、可視繼承（子窗體使用父窗體的外觀和實現(xiàn)代碼）、接口繼承（僅使用屬性和方法，實現(xiàn)滯后到子類實現(xiàn)）。前兩種（類繼承）和后一種（對象組合 => 接口繼承以及純虛函數(shù)）構(gòu)成了功能復(fù)用的兩種方式。
3. 多態(tài)：是將父對象設(shè)置成為和一個或更多的他的子對象相等的技術(shù)，賦值之后，父對象就可以根據(jù)當(dāng)前賦值給它的子對象的特性以不同的方式運作。簡單的說，就是一句話：允許將子類類型的指針賦值給父類類型的指針。
20.?重載（ overload) 和重寫 (overried ，有的書也叫做 “ 覆蓋 ” ）的區(qū)別？
常考的題目。從定義上來說：
重載：是指允許存在多個同名函數(shù)，而這些函數(shù)的參數(shù)表不同（或許參數(shù)個數(shù)不同，或許參數(shù)類型不同，或許兩者都不同）。
重寫：是指子類重新定義父類虛函數(shù)的方法。
從實現(xiàn)原理上來說：
重載：編譯器根據(jù)函數(shù)不同的參數(shù)表，對同名函數(shù)的名稱做修飾，然后這些同名函數(shù)就成了不同的函數(shù)（至少對于編譯器來說是這樣的）。如，有兩個同名函數(shù)： function func(p:integer):integer; 和 function func(p:string):integer; 。 那么編譯器做過修飾后的函數(shù)名稱可能是這樣的： int_func 、 str_func 。對于這兩個函數(shù)的調(diào)用，在編譯器間就已經(jīng)確定了，是 靜態(tài) 的。也就是說， 它們的地址在編譯期就綁定了（早綁定）， 因此， 重載和多態(tài)無關(guān) ！
重寫：和多態(tài)真正相關(guān)。當(dāng)子類重新定義了父類的虛函數(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?與 Ado.net 的相同與不同？
除了“能夠讓應(yīng)用程序處理存儲于 DBMS 中的數(shù)據(jù)“這一基本相似點外，兩者沒有太多共同之處。但是 Ado 使用 OLE DB 接口并基于微軟的 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.New delete?與 malloc free 的聯(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.#define DOUBLE(x) x+x?， i = 5*DOUBLE(5) ； i 是多少？
答案： i 為 30 。
25.?有哪幾種情況只能用 intialization list 而不能用 assignment?
答案：當(dāng)類中含有 const 、 reference 成員變量；基類的構(gòu)造函數(shù)都需要初始化表。
26.?C++?是不是類型安全的？
答案：不是。兩個不同類型的指針之間可以強制轉(zhuǎn)換（用 reinterpret cast) 。 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)存，程序員自己負責(zé)在何時用 free 或 delete 釋放內(nèi)存。動態(tài)內(nèi)存的生存期由程序員決定，使用非常靈活，但問題也最多。
29.struct?和 class 的區(qū)別
答案： struct 的成員默認是公有的，而類的成員默認是私有的。 struct 和 class 在其他方面是功能相當(dāng)?shù)摹母星樯现v，大多數(shù)的開發(fā)者感到類和結(jié)構(gòu)有很大的差別。感覺上結(jié)構(gòu)僅僅象一堆缺乏封裝和功能的開放的內(nèi)存位，而類就象活的并且可靠的社會成員，它有智能服務(wù)，有牢固的封裝屏障和一個良好定義的接口。既然大多數(shù)人都這么認為，那么只有在你的類有很少的方法并且有公有數(shù)據(jù)（這種事情在良好設(shè)計的系統(tǒng)中是存在的 ! ）時，你也許應(yīng)該使用 struct 關(guān)鍵字，否則，你應(yīng)該使用 class 關(guān)鍵字。 ?
30.?當(dāng)一個類 A 中沒有任何成員變量與成員函數(shù) , 這時 sizeof(A) 的值是多少？
答案：如果不是零，請解釋一下編譯器為什么沒有讓它為零。（ Autodesk ）肯定不是零。舉個反例，如果是零的話，聲明一個 class A[10] 對象數(shù)組，而每一個對象占用的空間是零，這時就沒辦法區(qū)分 A[0],A[1] …了。
31.?在 8086 匯編下，邏輯地址和物理地址是怎樣轉(zhuǎn)換的？（ Intel ）
答案：通用寄存器給出的地址，是段內(nèi)偏移地址，相應(yīng)段寄存器地址 *10H+ 通用寄存器內(nèi)地址，就得到了真正要訪問的地址。
32.??比較 C++ 中的 4 種類型轉(zhuǎn)換方式？
請參考： http://blog.csdn.net/wfwd/archive/2006/05/30/763785.aspx ，重點是 static_cast, dynamic_cast 和 reinterpret_cast 的區(qū)別和應(yīng)用。
dynamic_casts 在幫助你瀏覽繼承層次上是有限制的。它不能被用于缺乏虛函數(shù)的類型上，它被用于安全地沿著類的繼承關(guān)系向下進行類型轉(zhuǎn)換。如你想在沒有繼承關(guān)系的類型中進行轉(zhuǎn)換，你可能想到 static_cast
33.?分別寫出 BOOL,int,float, 指針類型的變量 a 與“零”的比較語句。
答案：?
BOOL :??? if ( !a ) or if(a)
int :???? if ( a == 0)
float :???const EXPRESSION EXP = 0.000001
????????? if ( a < EXP && a >-EXP)
pointer : if ( a != NULL) or if(a == NULL)
?
34.?請說出 const 與 #define 相比，有何優(yōu)點？
答案：
Const?作用：定義常量、修飾函數(shù)參數(shù)、修飾函數(shù)返回值三個作用。被?Const?修飾的東西都受到強制保護，可以預(yù)防意外的變動，能提高程序的健壯性。
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)容上的差別?
char a[] = “ 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)存時記住它。 注意當(dāng)數(shù)組作為函數(shù)的參數(shù)進行傳遞時，該數(shù)組自動退化為同類型的指針。?
char a[] = "hello world";
char *p = a;
cout<< sizeof(a) << endl; // 12 字節(jié)?
cout<< sizeof(p) << endl; // 4 字節(jié)?
計算數(shù)組和指針的內(nèi)存容量?
void Func(char a[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ù)中的較大這
There are two int variables: a and b, don ’ t use “ if ” , “ ? : ” , “ switch ” or other judgement statements, find out the biggest one of the two numbers.
答案： ( ( a + b ) + abs( a - b ) ) / 2
38.?如何打印出當(dāng)前源文件的文件名以及源文件的當(dāng)前行號？
答案：?
cout << __FILE__ ;
cout<<__LINE__ ;
__FILE__ 和 __LINE__ 是系統(tǒng)預(yù)定義宏，這種宏并不是在某個文件中定義的，而是由編譯器定義的。
39. main?主函數(shù)執(zhí)行完畢后，是否可能會再執(zhí)行一段代碼，給出說明？
答案：可以，可以用 _onexit 注冊一個函數(shù)，它會在 main 之后執(zhí)行 int fn1(void), fn2(void), fn3(void), fn4 (void);
void main( void )
{
String str("zhanglin");
_onexit( fn1 );
_onexit( fn2 );
_onexit( fn3 );
_onexit( fn4 );
printf( "This is executed first.n" );
}
int fn1()
{
printf( "next.n" );
return 0;
}
int fn2()
{
printf( "executed " );
return 0;
}
int fn3()
{
printf( "is " );
return 0;
}
int fn4()
{
printf( "This " );
return 0;
}
The _onexit function is passed the address of a function (func) to be called when the program terminates normally. Successive calls to _onexit create a register of functions that are executed in LIFO (last-in-first-out) order. The functions passed to _onexit cannot take parameters.
40.?如何判斷一段程序是由 C 編譯程序還是由 C++ 編譯程序編譯的？
答案：?
#ifdef __cplusplus
cout<<"c++";
#else
cout<<"c";
#endif
41.?文件中有一組整數(shù)，要求排序后輸出到另一個文件中
答案：
＃ i nclude<iostream>
＃ i nclude<fstream>
using namespace std;
void Order(vector<int>& data) //bubble sort
{
int count = data.size() ;
int tag = false ; // 設(shè)置是否需要繼續(xù)冒泡的標志位?
for ( int i = 0 ; i < count ; i++)
{
for ( int j = 0 ; j < count - i - 1 ; j++)
{
if ( data[j] > data[j+1])
{
tag = true ;
int temp = data[j] ;
data[j] = data[j+1] ;
data[j+1] = temp ;
}
}
if ( !tag )
break ;
}
}
void main( void )
{
vector<int>data;
ifstream in("c:/data.txt");
if ( !in)
{
cout<<"file error!";
exit(1);
}
int temp;
while (!in.eof())
{
in>>temp;
data.push_back(temp);
}
in.close(); // 關(guān)閉輸入文件流?
Order(data);
ofstream out("c:/result.txt");
if ( !out)
{
cout<<"file error!";
exit(1);
}
for ( i = 0 ; i < data.size() ; i++)
out<<data[i]<<" ";
out.close(); // 關(guān)閉輸出文件流?
}
?
42.?鏈表題：一個鏈表的結(jié)點結(jié)構(gòu)
struct Node
{
int data ;
Node *next ;
};
typedef struct Node Node ;
(1) 已知鏈表的頭結(jié)點 head, 寫一個函數(shù)把這個鏈表逆序 ( Intel)
Node * ReverseList(Node *head) // 鏈表逆序?
{
if ( head == NULL || head->next == NULL )
return head;
Node *p1 = head ;
Node *p2 = p1->next ;
Node *p3 = p2->next ;
p1->next = NULL ;
while ( p3 != NULL )
{
p2->next = p1 ;
p1 = p2 ;
p2 = p3 ;
p3 = p3->next ;
}
p2->next = p1 ;
head = p2 ;
return head ;
}
(2) 已知兩個鏈表 head1 和 head2 各自有序，請把它們合并成一個鏈表依然有序。 ( 保留所有結(jié)點，即便大小相同）?
Node * Merge(Node *head1 , Node *head2)
{
if ( head1 == NULL)
return head2 ;
if ( head2 == NULL)
return head1 ;
Node *head = NULL ;
Node *p1 = NULL;
Node *p2 = NULL;
if ( head1->data < head2->data )
{
head = head1 ;
p1 = head1->next;
p2 = head2 ;
}
else
{
head = head2 ;
p2 = head2->next ;
p1 = head1 ;
}
Node *pcurrent = head ;
while ( p1 != NULL && p2 != NULL)
{
if ( p1->data <= p2->data )
{
pcurrent->next = p1 ;
pcurrent = p1 ;
p1 = p1->next ;
}
else
{
pcurrent->next = p2 ;
pcurrent = p2 ;
p2 = p2->next ;
}
}
if ( p1 != NULL )
pcurrent->next = p1 ;
if ( p2 != NULL )
pcurrent->next = p2 ;
return head ;
}
(3) 已知兩個鏈表 head1 和 head2 各自有序，請把它們合并成一個鏈表依然有序，這次要求用遞歸方法進行。 (Autodesk)
答案：?
Node * MergeRecursive(Node *head1 , Node *head2)
{
if ( head1 == NULL )
return head2 ;
if ( head2 == NULL)
return head1 ;
Node *head = NULL ;
if ( head1->data < head2->data )
{
head = head1 ;
head->next = MergeRecursive(head1->next,head2);
}
else
{
head = head2 ;
head->next = MergeRecursive(head1,head2->next);
}
return head ;
?
----------
41. 分析一下這段程序的輸出 (Autodesk)
class B
{
public:
B()
{
cout<<"default constructor"<<endl;
}
~B()
{
cout<<"destructed"<<endl;
}
B(int i):data(i)??? //B(int) works as a converter ( int -> instance of ?B)
{
cout<<"constructed by parameter " << data <<endl;
}
private:
int data;
};
B Play( B b)?
{
return b ;
}
(1)??????????????????????????????????????????? results:
int main(int argc, char* argv[])??????constructed by parameter 5
{???????????????????????????????????? destructed? B(5) 形參析構(gòu)?
B t1 = Play(5); B t2 = Play(t1);?? destructed? t1 形參析構(gòu)?
return 0; destructed? t2 注意順序！?
}?????????????????????????????????????destructed? t1
(2)???????????????????????????????????results:
int main(int argc, char* argv[])??????constructed by parameter 5
{???????????????????????????????????? destructed? B(5) 形參析構(gòu)?
B t1 = Play(5); B t2 = Play(10);?? constructed by parameter 10
return 0; destructed? B(10) 形參析構(gòu)?
}???????????????????????????????????? destructed? t2 注意順序！
????????????????????????????????????? destructed? t1
43.?寫一個函數(shù)找出一個整數(shù)數(shù)組中，第二大的數(shù) （ microsoft ）
答案：?
const int MINNUMBER = -32767 ;
int find_sec_max( int data[] , int count)
{
int maxnumber = data[0] ;
int sec_max = MINNUMBER ;
for ( int i = 1 ; i < count ; i++)
{
if ( data[i] > maxnumber )
{
sec_max = maxnumber ;
maxnumber = data[i] ;
}
else
{
if ( data[i] > sec_max )
sec_max = data[i] ;
}
}
return sec_max ;
}
44.?寫一個在一個字符串 (n) 中尋找一個子串 (m) 第一個位置的函數(shù)。
KMP?算法效率最好，時間復(fù)雜度是Ｏ (n+m), 詳見： http://www.zhanglihai.com/blog/c_335_kmp.html
46.?多重繼承的內(nèi)存分配問題：
比如有 class A : public class B, public class C {} 那么 A 的內(nèi)存結(jié)構(gòu)大致是怎么樣的？?
這個是 compiler-dependent 的 , 不同的實現(xiàn)其細節(jié)可能不同。如果不考慮有虛函數(shù)、虛繼承的話就相當(dāng)簡單；否則的話，相當(dāng)復(fù)雜。可以參考《深入探索 C++ 對象模型》，或者：?
http://blog.csdn.net/rainlight/archive/2006/03/03/614792.aspx
http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/dnarvc/html/jangrayhood.asp
47.?如何判斷一個單鏈表是有環(huán)的？（注意不能用標志位，最多只能用兩個額外指針）
struct node { char val; node* next;}
bool check(const node* head) {} //return?false : 無環(huán)； true: 有環(huán)一種 O （ n ）的辦法就是（搞兩個指針，一個每次遞增一步，一個每次遞增兩步，如果有環(huán)的話兩者必然重合，反之亦然）：?
bool check(const node* head)
{
??? if(head==NULL)? return false;
??? node *low=head, *fast=head->next;
??? while(fast!=NULL && fast->next!=NULL)
??? {
??????? low=low->next;
??????? fast=fast->next->next;
??????? if(low==fast) return true;
??? }
??? return false;
}
?
48.?指針找錯題
分析這些面試題，本身包含很強的趣味性 ; 而作為一名研發(fā)人員，通過對這些面試題的深入剖析則可進一步增強自身的內(nèi)功。?
2. 找錯題 試題 1 ：?
以下是引用片段：?
void test1()? // 數(shù)組越界?
{
char string[10];
char* str1 = "0123456789";
strcpy( string, str1 );
}
試題 2 ： ?
以下是引用片段：?
void test2()
{
char string[10], str1[10];?
int i;
for(i=0; i<10; i++)
{
str1= 'a';
}
strcpy( string, str1 );
}
試題 3 ： ?
以下是引用片段：?
void test3(char* str1)
{
char string[10];
if( strlen( str1 ) <= 10 )
{
strcpy( string, str1 );
}
}
解答：?
試題 1 字符串 str1 需要 11 個字節(jié)才能存放下 ( 包括末尾的 ’/0’) ，而 string 只有 10 個字節(jié)的空間， strcpy 會導(dǎo)致數(shù)組越界 ; 對試題 2 ，如果面試者指出字符數(shù)組 str1 不能在數(shù)組內(nèi)結(jié)束可以給 3 分 ; 如果面試者指出 strcpy(string,str1) 調(diào)用使得從 str1 內(nèi)存起復(fù)制到 string 內(nèi)存起所復(fù)制的字節(jié)數(shù)具有不確定性可以給 7 分，在此基礎(chǔ)上指出庫函數(shù) strcpy 工作方式的給 10 分 ;
對試題 3 ， if(strlen(str1) <= 10) 應(yīng)改為 if(strlen(str1) <10) ，因為 strlen 的結(jié)果未統(tǒng)計 ’/0’ 所占用的 1 個字節(jié)。剖析：考查對基本功的掌握?
(1) 字符串以 ’/0’ 結(jié)尾 ;
(2) 對數(shù)組越界把握的敏感度 ;
(3) 庫函數(shù) strcpy 的工作方式，
49.?如果編寫一個標準 strcpy 函數(shù)
總分值為 10 ，下面給出幾個不同得分的答案： 2 分 以下是引用片段：?
void strcpy( char *strDest, char *strSrc )
{
while( (*strDest++ = * strSrc++) != ‘/0’ );
}
4 分 以下是引用片段：?
void strcpy( char *strDest, const char *strSrc )
// 將源字符串加 const ，表明其為輸入?yún)?shù)，加 2 分?
{
while( (*strDest++ = * strSrc++) != ‘/0’ );
}
7 分 以下是引用片段：?
void strcpy(char *strDest, const char *strSrc)
{
// 對源地址和目的地址加非 0 斷言，加 3 分?
assert( (strDest != NULL) &&(strSrc != NULL) );
while( (*strDest++ = * strSrc++) != ‘/0’ );
}
10 分 以下是引用片段：?
// 為了實現(xiàn)鏈式操作，將目的地址返回，加 3 分 !
char * strcpy( char *strDest, const char *strSrc )
{
assert( (strDest != NULL) &&(strSrc != NULL) );?
char *address = strDest;
while( (*strDest++ = * strSrc++) != ‘/0’ );
return address;
}
從 2 分到 10 分的幾個答案我們可以清楚的看到，小小的 strcpy 竟然暗藏著這么多玄機，真不是蓋的 ! 需要多么扎實的基本功才能寫一個完美的 strcpy 啊 !
(4) 對 strlen 的掌握，它沒有包括字符串末尾的 '/0' 。?
讀者看了不同分值的 strcpy 版本，應(yīng)該也可以寫出一個 10 分的 strlen 函數(shù)了，完美的版本為： int strlen( const char *str ) // 輸入?yún)?shù) const 以下是引用片段：?
{
assert( strt != NULL ); // 斷言字符串地址非 0
int len=0; // 注，一定要初始化。?
while( (*str++) != '/0' )
{
len++;
}
return len;
}
試題 4 ：以下是引用片段：?
void GetMemory( char *p )
{
p = (char *) malloc( 100 );
}
void Test( void )
{
char *str = NULL;
GetMemory( str );
strcpy( str, "hello world" );
printf( str );
}?
試題 5 ： ?
以下是引用片段：?
char *GetMemory( void )
{
char p[] = "hello world";
return p;
}
void Test( void )
{
char *str = NULL;
str = GetMemory();
printf( str );
}
試題 6 ：以下是引用片段：?
void GetMemory( char **p, int num )
{
*p = (char *) malloc( num );
}
void Test( void )
{
char *str = NULL;
GetMemory( &str, 100 );
strcpy( str, "hello" );
printf( str );
}
試題 7 ：以下是引用片段：?
void Test( 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 中?
char p[] = "hello world";
return p;
的 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)存是否申請成功，應(yīng)加上：?
if ( *p == NULL )
{
...// 進行申請內(nèi)存失敗處理?
}
試題 7 存在與試題 6 同樣的問題，在執(zhí)行?
char *str = (char *) malloc(100);
后未進行內(nèi)存是否申請成功的判斷 ; 另外，在 free(str) 后未置 str 為空，導(dǎo)致可能變成一個 “ 野 ” 指針，應(yīng)加上：?
str = NULL;
試題 6 的 Test 函數(shù)中也未對 malloc 的內(nèi)存進行釋放。?
剖析：?
試題 4 ～ 7 考查面試者對內(nèi)存操作的理解程度，基本功扎實的面試者一般都能正確的回答其中 50~60 的錯誤。但是要完全解答正確，卻也絕非易事。
軟件開發(fā)網(wǎng) www.mscto.com
對內(nèi)存操作的考查主要集中在：?
(1) 指針的理解 ;
(2) 變量的生存期及作用范圍 ;
(3) 良好的動態(tài)內(nèi)存申請和釋放習(xí)慣。?
再看看下面的一段程序有什么錯誤： ?
以下是引用片段：?
swap( int* p1,int* p2 )
{
int *p;
*p = *p1;
*p1 = *p2;
*p2 = *p;
}
在 swap 函數(shù)中， p 是一個 “ 野 ” 指針，有可能指向系統(tǒng)區(qū)，導(dǎo)致程序運行的崩潰。在 VC++ 中 DEBUG 運行時提示錯誤 “Access Violation” 。該程序應(yīng)該改為?
以下是引用片段：?
swap( int* p1,int* p2 )
{
int p;
p = *p1;
*p1 = *p2;
*p2 = p;
}
50.String?的具體實現(xiàn)
?
已知 String 類定義如下：?
class String
{
public:
String(const char *str = NULL); // 通用構(gòu)造函數(shù)?
String(const String &another); // 拷貝構(gòu)造函數(shù)?
~ String(); // 析構(gòu)函數(shù)?
String & operater =(const String &rhs); // 賦值函數(shù)?
private:
char *m_data; // 用于保存字符串?
};
嘗試寫出類的成員函數(shù)實現(xiàn)。?
答案：?
String::String(const char *str)
{
if ( str == NULL ) //strlen 在參數(shù)為 NULL 時會拋異常才會有這步判斷?
{
m_data = new char[1] ;
m_data[0] = '/0' ;
}
else
{
m_data = new char[strlen(str) + 1];
strcpy(m_data,str);
}
}?
String::String(const String &another)
{
m_data = new char[strlen(another.m_data) + 1];
strcpy(m_data,other.m_data);
}
String& String::operator =(const String &rhs)
{
if ( this == &rhs)
return *this ;
delete []m_data; // 刪除原來的數(shù)據(jù)，新開一塊內(nèi)存?
m_data = new char[strlen(rhs.m_data) + 1];
strcpy(m_data,rhs.m_data);
return *this ;
}
String::~String()
{
delete []m_data ;
}
51.h?頭文件中的 ifndef/define/endif 的作用？
答：防止該頭文件被重復(fù)引用。
52.?＃ i nclude<file.h> 與 ＃ i nclude "file.h" 的區(qū)別？
答：前者是從 Standard Library 的路徑尋找和引用 file.h ，而后者是從當(dāng)前工作路徑搜尋并引用 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" 是連接申明 (linkage declaration), 被 extern "C" 修飾的變量和函數(shù)是按照 C 語言方式編譯和連接的 , 來看看 C++ 中對類似 C 的函數(shù)是怎樣編譯的：?
作為一種面向?qū)ο蟮恼Z言， C++ 支持函數(shù)重載，而過程式語言 C 則不支持。函數(shù)被 C++ 編譯后在符號庫中的名字與 C 語言的不同。例如，假設(shè)某個函數(shù)的原型為：?
void foo( int x, int y );
?
該函數(shù)被 C 編譯器編譯后在符號庫中的名字為 _foo ，而 C++ 編譯器則會產(chǎn)生像 _foo_int_int 之類的名字（不同的編譯器可能生成的名字不同，但是都采用了相同的機制，生成的新名字稱為 “mangled name” ）。?
_foo_int_int 這樣的名字包含了函數(shù)名、函數(shù)參數(shù)數(shù)量及類型信息， C++ 就是靠這種機制來實現(xiàn)函數(shù)重載的。例如，在 C++ 中，函數(shù) void foo( int x, int y ) 與 void foo( int x, float y ) 編譯生成的符號是不相同的，后者為 _foo_int_float 。?
同樣地， C++ 中的變量除支持局部變量外，還支持類成員變量和全局變量。用戶所編寫程序的類成員變量可能與全局變量同名，我們以 "." 來區(qū)分。而本質(zhì)上，編譯器在進行編譯時，與函數(shù)的處理相似，也為類中的變量取了一個獨一無二的名字，這個名字與用戶程序中同名的全局變量名字不同。?
未加 extern "C" 聲明時的連接方式?
假設(shè)在 C++ 中，模塊 A 的頭文件如下：?
// 模塊 A 頭文件 moduleA.h
#ifndef MODULE_A_H
#define MODULE_A_H
int foo( int x, int y );
#endif ?
在模塊 B 中引用該函數(shù)：?
// 模塊 B 實現(xiàn)文件 moduleB.cpp
＃ i nclude "moduleA.h"
foo(2,3);
加 extern "C" 聲明后的編譯和連接方式?
加 extern "C" 聲明后，模塊 A 的頭文件變?yōu)?#xff1a;?
// 模塊 A 頭文件 moduleA.h
#ifndef MODULE_A_H
#define MODULE_A_H
extern "C" int foo( int x, int y );
#endif ?
在模塊 B 的實現(xiàn)文件中仍然調(diào)用 foo( 2,3 ) ，其結(jié)果是：?
（ 1 ）模塊 A 編譯生成 foo 的目標代碼時，沒有對其名字進行特殊處理，采用了 C 語言的方式；?
（ 2 ）連接器在為模塊 B 的目標代碼尋找 foo(2,3) 調(diào)用時，尋找的是未經(jīng)修改的符號名 _foo 。?
如果在模塊 A 中函數(shù)聲明了 foo 為 extern "C" 類型，而模塊 B 中包含的是 extern int foo( int x, int y ) ，則模塊 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"
{
＃ i nclude "cExample.h"
}
而在 C 語言的頭文件中，對其外部函數(shù)只能指定為 extern 類型， C 語言中不支持 extern "C" 聲明，在 .c 文件中包含了 extern "C" 時會出現(xiàn)編譯語法錯誤。?
C++ 引用 C 函數(shù)例子工程中包含的三個文件的源代碼如下：?
/* c 語言頭文件： cExample.h */
#ifndef C_EXAMPLE_H
#define C_EXAMPLE_H
extern int add(int x,int y);
#endif
/* c 語言實現(xiàn)文件： cExample.c */
＃ i nclude "cExample.h"
int add( int x, int y )
{
return x + y;
}
// c++ 實現(xiàn)文件，調(diào)用 add ： cppFile.cpp
extern "C"
{
＃ i nclude "cExample.h"
}
int main(int argc, char* argv[])
{
add(2,3);
return 0;
}
如果 C++ 調(diào)用一個 C 語言編寫的 .DLL 時，當(dāng)包括 .DLL 的頭文件或聲明接口函數(shù)時，應(yīng)加 extern "C" { } 。?
（ 2 ）在 C 中引用 C++ 語言中的函數(shù)和變量時， C++ 的頭文件需添加 extern "C" ，但是在 C 語言中不能直接引用聲明了 extern "C" 的該頭文件，應(yīng)該僅將 C 文件中將 C++ 中定義的 extern "C" 函數(shù)聲明為 extern 類型。?
C 引用 C++ 函數(shù)例子工程中包含的三個文件的源代碼如下：?
//C++ 頭文件 cppExample.h
#ifndef CPP_EXAMPLE_H
#define CPP_EXAMPLE_H
extern "C" int add( int x, int y );
#endif
//C++ 實現(xiàn)文件 cppExample.cpp
＃ i nclude "cppExample.h"
int add( int x, int y )
{
return x + y;
}
/* C 實現(xiàn)文件 cFile.c
/* 這樣會編譯出錯：＃ i nclude "cExample.h" */
int main( int argc, char* argv[] )
{
add( 2, 3 );
return 0;
}
15 題目的解答請參考《 C++ 中 extern “C” 含義深層探索》注解：
幾道 c 筆試題 ( 含參考答案 )
1.?
What is displayed when f() is called given the code:
class Number {
public:
string type;?
Number(): type( “ void ” ) { }
explicit Number(short) : type( “ short ” ) { }?
Number(int) : type( “ int ” ) { }
};
void Show(const Number& n) { cout << n.type; }
void f()
{
short s = 42;
Show(s);?
}
a) void
b) short
c) int
d) None of the above
2. Which is the correct output for the following code
double dArray[2] = {4, 8}, *p, *q;
p = &dArray[0];
q = p + 1;
cout << q – p << endl;?
cout << (int)q - (int)p << endl;
a) 1 and 8
b) 8 and 4
c) 4 and 8
d) 8 and 1
第一個選 C ；?
雖然傳入的是 short 類型，但是 short 類型的構(gòu)造函數(shù)被生命被 explicit ，也就是只能顯示類型轉(zhuǎn)換，不能使用隱式類型轉(zhuǎn)換。?
第二個選 A ；?
第一個是指針加減，按照的是指向地址類型的加減，只跟類型位置有關(guān)， q 和 p 指向的數(shù)據(jù)類型以實際數(shù)據(jù)類型來算差一個位置，因此是 1 。而第二個加減是實際指針值得加減，在內(nèi)存中一個 double 類型占據(jù) 8 個字節(jié)，因此是 8
?
54.Sony?筆試題
1 ．完成下列程序?
*?
*.*.?
*..*..*..?
*...*...*...*...?
*....*....*....*....*....?
*.....*.....*.....*.....*.....*.....?
*......*......*......*......*......*......*......?
*.......*.......*.......*.......*.......*.......*.......*.......?
#include?
#define N 8?
int main()?
{?
int i;?
int j;?
int k;?
---------------------------------------------------------?
| |?
| |?
| |?
---------------------------------------------------------?
return 0;?
}?
2 ．完成程序，實現(xiàn)對數(shù)組的降序排序?
#include?
void sort( );?
int main()?
{?
int array[]={45 ， 56 ， 76 ， 234 ， 1 ， 34 ， 23 ， 2 ， 3} ； // 數(shù)字任 // 意給出?
sort( );?
return 0;?
}?
void sort( )?
{?
____________________________________?
| |?
| |?
|-----------------------------------------------------|?
}?
3 ．費波那其數(shù)列， 1 ， 1 ， 2 ， 3 ， 5 ……編寫程序求第十項。可以用遞歸，也可以用其?
他方法，但要說明你選擇的理由。?
#include?
int Pheponatch(int);?
int main()?
{?
printf("The 10th is %d",Pheponatch(10));?
return 0;?
}?
int Pheponatch(int N)?
{?
--------------------------------?
| |?
| |?
--------------------------------?
}?
4 ．下列程序運行時會崩潰，請找出錯誤并改正，并且說明原因。?
#include?
#include?
typedef struct{?
TNode* left;?
TNode* right;?
int value;?
} TNode;?
TNode* root=NULL;?
void append(int N);?
int main()?
{?
append(63);?
append(45);?
append(32);?
append(77);?
append(96);?
append(21);?
append(17); // Again, 數(shù)字任意給出?
}?
void append(int N)?
{?
TNode* NewNode=(TNode *)malloc(sizeof(TNode));?
NewNode->value=N;?
if(root==NULL)?
{?
root=NewNode;?
return;?
}?
else?
{?
TNode* temp;?
temp=root;?
while((N>=temp.value && temp.left!=NULL) || (N !=NULL?
))?
{?
while(N>=temp.value && temp.left!=NULL)?
temp=temp.left;?
while(N temp=temp.right;?
}?
if(N>=temp.value)?
temp.left=NewNode;?
else?
temp.right=NewNode;?
return;?
}?
}?
※ 來源 : ·哈工大紫丁香 http://bbs.hit.edu.cn · [FROM:219.217.233.47]?
────────────────────────────────────────?
mengfd (Icebreaker) 于 (Sun Oct 23 14:59:59 2005) 說道 :
55?請你分別畫出 OSI 的七層網(wǎng)絡(luò)結(jié)構(gòu)圖和 TCP/IP 的五層結(jié)構(gòu)圖。
應(yīng)用層：為應(yīng)用程序提供服務(wù)
表示層：處理在兩個通信系統(tǒng)中交換信息的表示方式
會話層：負責(zé)維護兩個結(jié)點間會話連接的建立、管理和終止，以及數(shù)據(jù)交換
傳輸層：向用戶提供可靠的端到端服務(wù)。 UDP TCP 協(xié)議。
網(wǎng)絡(luò)層：通過路由選擇算法為分組通過通信子網(wǎng)選擇最適當(dāng)?shù)穆窂?#xff0c;以及實現(xiàn)擁塞控制、網(wǎng)絡(luò)互聯(lián)等功能。數(shù)據(jù)傳輸單元是分組。 IP 地址，路由器， IP 協(xié)議。
數(shù)據(jù)鏈路層：在物理層提供的服務(wù)基礎(chǔ)上，數(shù)據(jù)鏈路層在通信的實體間建立數(shù)據(jù)鏈路連接，傳輸一幀為單位的數(shù)據(jù)包（，并采用差錯控制與流量控制方法，使有差錯的物理線路變成無差錯的數(shù)據(jù)鏈路。）
物理層：傳輸比特流。傳輸單元是比特。調(diào)制解調(diào)器。
?
?
?
?
?
56?請你詳細地解釋一下 IP 協(xié)議的定義，在哪個層上面？主要有什么作用？ TCP 與 UDP 呢 ？
網(wǎng)絡(luò)層。
57.?請問交換機和路由器各自的實現(xiàn)原理是什么？分別在哪個層次上面實現(xiàn)的？
交換機：數(shù)據(jù)鏈路層。路由器：網(wǎng)絡(luò)層。
58.?全局變量和局部變量有什么區(qū)別？是怎么實現(xiàn)的？操作系統(tǒng)和編譯器是怎么知道的 ？
?
59.8086?是多少位的系統(tǒng)？在數(shù)據(jù)總線上是怎么實現(xiàn)的？?
8086 微處理器共有 4 個 16 位的段寄存器，在尋址內(nèi)存單元時，用它們直接或間接地存放段地址。
代碼段寄存器 CS ：存放當(dāng)前執(zhí)行的程序的段地址。
數(shù)據(jù)段寄存器 DS ：存放當(dāng)前執(zhí)行的程序所用操作數(shù)的段地址。
堆棧段寄存器 SS ：存放當(dāng)前執(zhí)行的程序所用堆棧的段地址。
附加段寄存器 ES ：存放當(dāng)前執(zhí)行程序中一個輔助數(shù)據(jù)段的段地址。
由 cs:ip 構(gòu)成指令地址， ss:sp 構(gòu)成堆棧的棧頂?shù)刂分羔槨?DS 和 ES 用作數(shù)據(jù)段和附加段的段地址（段起始地址或段值）
?
8086 ／ 8088 微處理器的存儲器管理
?? 1. 地址線（碼）與尋址范圍： N 條地址線 ???? 尋址范圍 =2N
?? 2.8086 有 20 地址線 ???? 尋址范圍為 1MB? 由 00000H ～ FFFFFH
?? 3. 8086 微處理器是一個 16 位結(jié)構(gòu)，用戶可用的寄存器均為 16 位：尋址 64KB
?? 4. 8086 ／ 8088 采用分段的方法對存儲器進行管理。具體做法是：把 1MB 的存儲器空間分成若干段，每段容量為 64KB ，每段存儲器的起始地址必須是一個能被 16 整除的地址碼，即在 20 位的二進制地址碼中最低 4 位必須是 “0” 。每個段首地址的高 16 位二進制代碼就是該段的段號 ( 稱段基地址 ) 或簡稱段地址，段號保存在段寄存器中。我們可對段寄存器設(shè)置不同的值來使微處理器的存儲器訪問指向不同的段。
?? 5. 段內(nèi)的某個存儲單元相對于該段段首地址的差值，稱為段內(nèi)偏移地址 ( 也叫偏移量 ) 用 16 位二進制代碼表示。
?? 6. 物理地址是由 8086 ／ 8088 芯片地址引線送出的 20 位地址碼，它用來參加存儲器的地址譯碼，最終讀／寫所訪問的一個特定的存儲單元。
?? 7. 邏輯地址由某段的段地址和段內(nèi)偏移地址 ( 也叫偏移量 ) 兩部分所組成。寫成：
???? 段地址：偏移地址 ( 例如， 1234H ： 0088H) 。
?? 8. 在硬件上起作用的是物理地址，物理地址＝段基地址 ×10H 十偏移地址
聯(lián)想筆試題?
1 ．設(shè)計函數(shù) int atoi(char *s) 。?
2 ． int i=(j=4,k=8,l=16,m=32); printf( “ %d ” , i); 輸出是多少？?
60.?解釋局部變量、全局變量和靜態(tài)變量的含義。
4 ．解釋堆和棧的區(qū)別。
61.?論述含參數(shù)的宏與函數(shù)的優(yōu)缺點。?
普天 C++ 筆試題?
1 ．實現(xiàn)雙向鏈表刪除一個節(jié)點 P ，在節(jié)點 P 后插入一個節(jié)點，寫出這兩個函數(shù)。?
2 ．寫一個函數(shù)，將其中的 /t 都轉(zhuǎn)換成 4 個空格。
?
61.Windows?程序的入口是哪里？寫出 Windows 消息機制的流程。?
4 ．如何定義和實現(xiàn)一個類的成員函數(shù)為回調(diào)函數(shù)？
?
62.C++?里面是不是所有的動作都是 main() 引起的？如果不是，請舉例。?
6 ． C++ 里面如何聲明 const void f(void) 函數(shù)為 C 程序中的庫函數(shù)？?
7 ．下列哪兩個是等同的?
int b;?
A const int* a = &b;?
B const* int a = &b;?
C const int* const a = &b;?
D int const* const a = &b;?
8 ．內(nèi)聯(lián)函數(shù)在編譯時是否做參數(shù)類型檢查？?
void g(base & b){?
b.play;?
}?
void main(){?
son s;?
g(s);?
return;?
}?
※ 來源 : ·哈工大紫丁香 http://bbs.hit.edu.cn · [FROM:219.217.233.47]?
────────────────────────────────────────?
mengfd (Icebreaker) 于 (Sun Oct 23 15:00:14 2005) 說道 :?
大唐電信?
DTT 筆試題?
考試時間一小時，第一部分是填空和選擇：?
1 ．數(shù)列 6 ， 10 ， 18 ， 32 ，“？”，問“？”是幾？?
2 ．某人出 70 買進一個 x ， 80 賣出， 90 買回， 100 賣出，這樁買賣怎么樣？?
3 ．月球繞地球一圈，至少要多少時間？?
4 ． 7 個人用 7 小時挖了 7 米 的溝，以同樣的速度在 50 小時挖 50 米 的溝要多少人？?
5 ．魚頭長 9 ，魚尾等于魚頭加半個魚身，魚身等于魚頭加魚尾，問魚全長多少？?
6 ．一個小姐買了一塊手表，回家發(fā)現(xiàn)手表比她家的表慢了兩分鐘，晚上看新聞的時候?
又發(fā)現(xiàn)她家的表比新聞里的時間慢了兩分鐘，則 。?
A 手表和新聞里的時間一樣?
B 手表比新聞里的時間慢?
C 手表比新聞里的時間快?
7 ．王先生看到一則招聘啟事，發(fā)現(xiàn)兩個公司除了以下條件不同外，其他條件都相同?
A 半年年薪 50 萬，每半年漲 5 萬?
B 一年年薪 100 萬，每一年漲 20 萬?
王先生想去一家待遇比較優(yōu)厚的公司，他會去哪家？?
10 ．問哪個袋子里有金子？?
A 袋子上的標簽是這樣寫的： B 袋子上的話是對的，金子在 A 袋子。?
B 袋子上的標簽是這樣寫的： A 袋子上的話是錯的，金子在 A 袋子里。?
11 ． 3 個人住酒店 30 塊錢，經(jīng)理找回 5 塊錢，服務(wù)生從中藏了 2 塊錢，找給每人 1 塊錢，?
3 ×（ 10?1 ） +2=29 ，問這是怎么回事？?
12 ．三篇寫作，均為書信形式。?
（ 1 ）一片中文的祝賀信，祝賀某男當(dāng)了某公司 xx?
（ 2 ）兩篇英文的，一是說有事不能應(yīng)邀，派別人去；另一篇是討債的， 7 天不給錢就?
走人（主要考 business letter 格式）。?
大唐面試試題?
1 ．什么是中斷？中斷發(fā)生時 CPU 做什么工作？?
2 ． CPU 在上電后，進入操作系統(tǒng)的 main() 之前必須做什么工作？?
3 ．簡述 ISO OSI 的物理層 Layer1 ，鏈路層 Layer2 ，網(wǎng)絡(luò)層 Layer3 的任務(wù)。?
4 ．有線電話和無線電話有何區(qū)別？無線電話特別需要注意的是什么？?
63.?軟件開發(fā)五個主要 step 是什么？
6 ．你在開發(fā)軟件的時候，這 5 個 step 分別占用的時間百分比是多少？?
7 ． makefile 文件的作用是什么？?
8 ． UNIX 顯示文件夾中，文件名的命令是什么？能使文件內(nèi)容顯示在屏幕的命令是什么?
？?
9 ．（選做）手機用戶在從一個基站漫游到另一個基站的過程中，都會發(fā)生什么 ??
※ 來源 : ·哈工大紫丁香 http://bbs.hit.edu.cn · [FROM:219.217.233.47]?
────────────────────────────────────────?
mengfd (Icebreaker) 于 (Sun Oct 23 15:01:22 2005) 說道 :?
網(wǎng)通筆試題?
選擇題（每題 5 分，只有一個正確答案）?
1 ．中國 1 號信令協(xié)議屬于 的協(xié)議。?
A ccs B cas C ip D atm?
2 ． isdnpri 協(xié)議全稱是 。?
A 綜合業(yè)務(wù)模擬網(wǎng)基速協(xié)議?
B 綜合業(yè)務(wù)模擬網(wǎng)模擬協(xié)議?
C 綜合業(yè)務(wù)數(shù)字網(wǎng)基率協(xié)議?
D 綜合業(yè)務(wù)數(shù)字網(wǎng)基次協(xié)議?
3 ．路由協(xié)議中， 協(xié)議是用距離作為向量的。?
A ospf B bgp C is-is D rip?
4 ．中國智能網(wǎng)中， ssp 與 scp 間最上層的 ss7 協(xié)議是 。?
A incs B is41b C is41c D inap?
5 ． dtmf 全稱是 。?
A 雙音多頻 B 多音雙頻 C 多音三頻 D 三音多頻?
6 ．計算機的基本組成部分中，不包含下面設(shè)備的是 。?
A cpu B 輸入設(shè)備 C 存儲器 D 接口?
7 ．脈沖編碼調(diào)制的簡稱是 。?
A pcm B pam C (delta)M D atm?
8 ．普通電話線接口專業(yè)稱呼是 。?
A rj11 B rj45 C rs232 D bnc?
9 ．現(xiàn)有的公共數(shù)據(jù)網(wǎng)都采用 。?
A 電路交換技術(shù) B 報文交換技術(shù)?
C 語音插空 D 分組交換?
10 ． ss7 協(xié)議中的制止市忙消息簡寫為 。?
A stb B slb C sub D spb?
簡答題（每題 10 分）?
1 ．簡述普通電話與 IP 電話的區(qū)別。?
2 ．簡述隨路信令與公路信令的根本區(qū)別。?
3 ．說明掩碼的主要作用。?
4 ． ss7 協(xié)議中，有三大要素決定其具體定位，哪三大要素？?
5 ．描述 ss7 的基本通話過程。?
6 ．簡述通信網(wǎng)的組成結(jié)構(gòu)。?
7 ．面向連接與面向非連接各有何利弊？?
8 ．寫出愛爾蘭的基本計算公式。?
9 ．數(shù)據(jù)網(wǎng)主要有哪些設(shè)備？?
10 ．中國一號協(xié)議是如何在被叫號碼中插入主叫號碼的？?
東信筆試題目?
筆試： 30 分鐘。?
1 ．壓控振蕩器的英文縮寫。?
2 ．動態(tài)隨機存儲器的英文縮寫。?
3 ．選擇電阻時要考慮什么？?
4 ．單片機上電后沒有運轉(zhuǎn)，首先要檢查什么？?
5 ．計算機的基本組成部分及其各自的作用。?
6 ．怎樣用 D 觸發(fā)器、與或非門組成二分頻電路？
?
64.static?有什么用途？（請至少說明兩種）
答 、 1. 限制變量的作用域 ( 文件級的 ) 。
? 2. 設(shè)置變量的存儲域 ( 全局數(shù)據(jù)區(qū) ) 。
?
?
65.?引用與指針有什么區(qū)別？
答 、 1) 引用必須被初始化，指針不必。
2) 引用初始化以后不能被改變，指針可以改變所指的對象。
3) 不存在指向空值的引用，但是存在指向空值的指針。
66.?描述實時系統(tǒng)的基本特性
答 、在特定時間內(nèi)完成特定的任務(wù)，實時性與可靠性。
?
?
67.?全局變量和局部變量在內(nèi)存中是否有區(qū)別？如果有，是什么區(qū)別？
答 、全局變量儲存在靜態(tài)數(shù)據(jù)區(qū)，局部變量在堆棧中。
?
?
68.?什么是平衡二叉樹？
答 、左右子樹都是平衡二叉樹 且左右子樹的深度差值的絕對值不大于 1 。
?
?
69.?堆棧溢出一般是由什么原因?qū)е碌?#xff1f;
答 、 1. 沒有回收垃圾資源
???????? 2.?層次太深的遞歸調(diào)用??????
?
?
70.?什么函數(shù)不能聲明為虛函數(shù)？
答 、 constructor
???????Deconstructor?可以聲明為虛函數(shù)。
?????? 系統(tǒng)為一個空類創(chuàng)建的成員函數(shù)有那些。
?
71.?冒泡排序算法的時間復(fù)雜度是什么？
答 、 O(n^2)
?
?
72.?寫出 float x 與“零值”比較的 if 語句。
答 、 if(x>0.000001&&x<-0.000001)
?
?
73.Internet?采用哪種網(wǎng)絡(luò)協(xié)議？該協(xié)議的主要層次結(jié)構(gòu)？
?
答 、 tcp/ip?應(yīng)用層?/?傳輸層?/?網(wǎng)絡(luò)層?/?數(shù)據(jù)鏈路層?/?物理層
?
?
74.Internet?物理地址和 IP 地址轉(zhuǎn)換采用什么協(xié)議？
答 、 ARP (Address Resolution Protocol) （地址解析協(xié)議）
?
?
75.IP?地址的編碼分為哪倆部分？
答 、 IP 地址由兩部分組成，網(wǎng)絡(luò)號和主機號。不過是要和“子網(wǎng)掩碼”按位與之后才能區(qū)分哪些是網(wǎng)絡(luò)位哪些是主機位。
?
76.?用戶輸入 M,N 值，從 1 至 N 開始順序循環(huán)數(shù)數(shù)，每數(shù)到 M 輸出該數(shù)值，直至全部輸出。寫出 C 程序。
答 、循環(huán)鏈表，用取余操作做
?
?
77.?不能做 switch() 的參數(shù)類型是：
答 、 switch 的參數(shù)不能為實型。
華為
78.?局部變量能否和全局變量重名？
答、能，局部會屏蔽全局。要用全局變量，需要使用 "::"
局部變量可以與全局變量同名，在函數(shù)內(nèi)引用這個變量時，會用到同名的局部變量，而不會用到全局變量。對于有些編譯器而言，在同一個函數(shù)內(nèi)可以定義多個同名的局部變量，比如在兩個循環(huán)體內(nèi)都定義一個同名的局部變量，而那個局部變量的作用域就在那個循環(huán)體內(nèi)
?
?
79.?如何引用一個已經(jīng)定義過的全局變量？
答 、可以用引用頭文件的方式，也可以用 extern 關(guān)鍵字，如果用引用頭文件方式來引用某個在頭文件中聲明的全局變理，假定你將那個變寫錯了，那么在編譯期間會報錯，如果你用 extern 方式引用時，假定你犯了同樣的錯誤，那么在編譯期間不會報錯，而在連接期間報錯
?
?
80.?全局變量可不可以定義在可被多個 .C 文件包含的頭文件中？為什么？
答 、可以，在不同的 C 文件中以 static 形式來聲明同名全局變量。
可以在不同的 C 文件中聲明同名的全局變量，前提是其中只能有一個 C 文件中對此變量賦初值，此時連接不會出錯
?
?
81.?語句 for( ； 1 ； ) 有什么問題？它是什么意思？
答 、和 while(1) 相同。
?
?
82.do?…… while 和 while …… do 有什么區(qū)別？
答 、前一個循環(huán)一遍再判斷，后一個判斷以后再循環(huán)
?
?
83.?請寫出下列代碼的輸出內(nèi)容
#i nclude
main()
{
int a,b,c,d;
a=10;
b=a++;
c=++a;
d=10*a++;
printf("b ， c ， d ： %d ， %d ， %d" ， b ， c ， d ） ;
return 0;
}
答 、 10 ， 12 ， 120
84.statac?全局變量、局部變量、函數(shù)與普通全局變量、局部變量、函數(shù)
static 全局變量與普通的全局變量有什么區(qū)別？ static 局部變量和普通局部變量有什么區(qū)別？ static 函數(shù)與普通函數(shù)有什么區(qū)別？
答 、全局變量 ( 外部變量 ) 的說明之前再冠以 static 就構(gòu)成了靜態(tài)的全局變量。全局變量本身就是靜態(tài)存儲方式， 靜態(tài)全局變量當(dāng)然也是靜態(tài)存儲方式。 這兩者在存儲方式上并無不同。這兩者的區(qū)別雖在于非靜態(tài)全局變量的作用域是整個源程序， 當(dāng)一個源程序由多個源文件組成時，非靜態(tài)的全局變量在各個源文件中都是有效的。 而靜態(tài)全局變量則限制了其作用域， 即只在定義該變量的源文件內(nèi)有效， 在同一源程序的其它源文件中不能使用它。由于靜態(tài)全局變量的作用域局限于一個源文件內(nèi)，只能為該源文件內(nèi)的函數(shù)公用， 因此可以避免在其它源文件中引起錯誤。
從以上分析可以看出， 把局部變量改變?yōu)殪o態(tài)變量后是改變了它的存儲方式即改變了它的生存期。把全局變量改變?yōu)殪o態(tài)變量后是改變了它的作用域， 限制了它的使用范圍。
static 函數(shù)與普通函數(shù)作用域不同。僅在本文件。只在當(dāng)前源文件中使用的函數(shù)應(yīng)該說明為內(nèi)部函數(shù) (static) ，內(nèi)部函數(shù)應(yīng)該在當(dāng)前源文件中說明和定義。對于可在當(dāng)前源文件以外使用的函數(shù)，應(yīng)該在一個頭文件中說明，要使用這些函數(shù)的源文件要包含這個頭文件
static 全局變量與普通的全局變量有什么區(qū)別： static 全局變量只初使化一次，防止在其他文件單元中被引用 ;
static 局部變量和普通局部變量有什么區(qū)別： static 局部變量只被初始化一次，下一次依據(jù)上一次結(jié)果值；
static 函數(shù)與普通函數(shù)有什么區(qū)別： static 函數(shù)在內(nèi)存中只有一份，普通函數(shù)在每個被調(diào)用中維持一份拷貝
程序的局部變量存在于（堆棧）中，全局變量存在于（靜態(tài)區(qū) ）中，動態(tài)申請數(shù)據(jù)存在于（ 堆）中。
85.?設(shè)有以下說明和定義：
typedef union {long i; int k[5]; char c;} DATE;
struct data { int cat; DATE cow; double dog;} too;
DATE max;
則語句 printf("%d",sizeof(struct date)+sizeof(max)); 的執(zhí)行結(jié)果是？
答 、結(jié)果是： ___52____ 。 DATE 是一個 union, 變量公用空間 . 里面最大的變量類型是 int[5], 占用 20 個字節(jié) . 所以它的大小是 20
data 是一個 struct, 每個變量分開占用空間 . 依次為 int4 + DATE20 + double8 = 32.
所以結(jié)果是 20 + 32 = 52.
當(dāng)然 ... 在某些 16 位編輯器下 , int 可能是 2 字節(jié) , 那么結(jié)果是 int2 + DATE10 + double8 = 20
86.-1,2,7,28,,126?請問 28 和 126 中間那個數(shù)是什么？為什么？
答 、應(yīng)該是 4^3-1=63
規(guī)律是 n^3-1( 當(dāng) n 為偶數(shù) 0 ， 2 ， 4)
n^3+1( 當(dāng) n 為奇數(shù) 1 ， 3 ， 5)
?
87.?用兩個棧實現(xiàn)一個隊列的功能？要求給出算法和思路！
答 、設(shè) 2 個棧為 A,B, 一開始均為空 .
入隊 :
將新元素 push 入棧 A;
出隊 :
(1) 判斷棧 B 是否為空；
(2) 如果不為空，則將棧 A 中所有元素依次 pop 出并 push 到棧 B ；
(3) 將棧 B 的棧頂元素 pop 出；
這樣實現(xiàn)的隊列入隊和出隊的平攤復(fù)雜度都還是 O(1), 比上面的幾種方法要好。
?
88.?在 c 語言庫函數(shù)中將一個字符轉(zhuǎn)換成整型的函數(shù)是 atool() 嗎，這個函數(shù)的原型是什么？
答 、函數(shù)名 : atol
功 能 : 把字符串轉(zhuǎn)換成長整型數(shù)
用 法 : long atol(const char *nptr);
程序例 :
＃ include
＃ include
int main(void)
{
??? long l;
??? char *str = "98765432";
??? l = atol(lstr);
??? printf("string = %s integer = %ld/n", str, l);
??? return(0);
}
?
?
89.?對于一個頻繁使用的短小函數(shù) , 在 C 語言中應(yīng)用什么實現(xiàn) , 在 C++ 中應(yīng)用什么實現(xiàn) ?
答 、 c 用宏定義， c++ 用 inline
?
90.?用預(yù)處理指令 #define 聲明一個常數(shù)，用以表明 1 年中有多少秒（忽略閏年問題）
?
#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL
我在這想看到幾件事情：
1). #define 語法的基本知識（例如：不能以分號結(jié)束，括號的使用，等等）
2). 懂得預(yù)處理器將為你計算常數(shù)表達式的值，因此，直接寫出你是如何計算一年中有多少秒而不是計算出實際的值，是更清晰而沒有代價的。
3). 意識到這個表達式將使一個 16 位機的整型數(shù)溢出 - 因此要用到長整型符號 L, 告訴編譯器這個常數(shù)是的長整型數(shù)。
4). 如果你在你的表達式中用到 UL （表示無符號長整型），那么你有了一個好的起點。記住，第一印象很重要。
?
91.?寫一個“標準”宏 MIN ，這個宏輸入兩個參數(shù)并返回較小的一個。
?
#define MIN(A,B) ((A) <= (B) (A) : (B))
這個測試是為下面的目的而設(shè)的：
1). 標識 #define 在宏中應(yīng)用的基本知識。這是很重要的，因為直到嵌入 (inline) 操作符變?yōu)闃藴?C 的一部分，宏是方便產(chǎn)生嵌入代碼的唯一方法，
對于嵌入式系統(tǒng)來說，為了能達到要求的性能，嵌入代碼經(jīng)常是必須的方法。
2). 三重條件操作符的知識。這個操作符存在 C 語言中的原因是它使得編譯器能產(chǎn)生比 if-then-else 更優(yōu)化的代碼，了解這個用法是很重要的。
3). 懂得在宏中小心地把參數(shù)用括號括起來
4). 我也用這個問題開始討論宏的副作用，例如：當(dāng)你寫下面的代碼時會發(fā)生什么事？
least = MIN(*p++, b);
?
92.?預(yù)處理器標識 #error 的目的是什么？
?
如果你不知道答案，請看參考文獻 1 。這問題對區(qū)分一個正常的伙計和一個書呆子是很有用的。只有書呆子才會讀 C 語言課本的附錄去找出象這種
問題的答案。當(dāng)然如果你不是在找一個書呆子，那么應(yīng)試者最好希望自己不要知道答案。
?
死循環(huán)（ Infinite loops ）
?
93.?嵌入式系統(tǒng)中經(jīng)常要用到無限循環(huán)，你怎么樣用 C 編寫死循環(huán)呢？
?
這個問題用幾個解決方案。我首選的方案是：
while(1)
{
}
一些程序員更喜歡如下方案：
for(;;)
{
}
這個實現(xiàn)方式讓我為難，因為這個語法沒有確切表達到底怎么回事。如果一個應(yīng)試者給出這個作為方案，我將用這個作為一個機會去探究他們這樣做的
基本原理。如果他們的基本答案是：“我被教著這樣做，但從沒有想到過為什么。”這會給我留下一個壞印象。
第三個方案是用 goto
Loop :
...
goto Loop;
應(yīng)試者如給出上面的方案，這說明或者他是一個匯編語言程序員（這也許是好事）或者他是一個想進入新領(lǐng)域的 BASIC/FORTRAN 程序員。
?
數(shù)據(jù)聲明（ Data declarations ）
?
94.?用變量 a 給出下面的定義
a) 一個整型數(shù)（ An integer ）
b) 一個指向整型數(shù)的指針（ A pointer to an integer ）
c) 一個指向指針的的指針，它指向的指針是指向一個整型數(shù)（ A pointer to a pointer to an integer ）
d) 一個有 10 個整型數(shù)的數(shù)組（ An array of 10 integers ）
e) 一個有 10 個指針的數(shù)組，該指針是指向一個整型數(shù)的（ An array of 10 pointers to integers ）
f) 一個指向有 10 個整型數(shù)數(shù)組的指針（ A pointer to an array of 10 integers ）
g) 一個指向函數(shù)的指針，該函數(shù)有一個整型參數(shù)并返回一個整型數(shù)（ A pointer to a function that takes an integer as an argument and returns an integer ）
h) 一個有 10 個指針的數(shù)組，該指針指向一個函數(shù)，該函數(shù)有一個整型參數(shù)并返回一個整型數(shù)（ An array of ten pointers to functions that take an integer
argument and return an integer ）
?
答案是：
a) int a; // An integer
b) int *a; // A pointer to an integer
c) int **a; // A pointer to a pointer to an integer
d) int a[10]; // An array of 10 integers
e) int *a[10]; // An array of 10 pointers to integers
f) int (*a)[10]; // A pointer to an array of 10 integers
g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer
h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer
?
人們經(jīng)常聲稱這里有幾個問題是那種要翻一下書才能回答的問題，我同意這種說法。當(dāng)我寫這篇文章時，為了確定語法的正確性，我的確查了一下書。
但是當(dāng)我被面試的時候，我期望被問到這個問題（或者相近的問題）。因為在被面試的這段時間里，我確定我知道這個問題的答案。應(yīng)試者如果不知道
所有的答案（或至少大部分答案），那么也就沒有為這次面試做準備，如果該面試者沒有為這次面試做準備，那么他又能為什么出準備呢？
?
Static
?
95.?關(guān)鍵字 static 的作用是什么？
?
這個簡單的問題很少有人能回答完全。在 C 語言中，關(guān)鍵字 static 有三個明顯的作用：
1). 在函數(shù)體，一個被聲明為靜態(tài)的變量在這一函數(shù)被調(diào)用過程中維持其值不變。
2). 在模塊內(nèi)（但在函數(shù)體外），一個被聲明為靜態(tài)的變量可以被模塊內(nèi)所用函數(shù)訪問，但不能被模塊外其它函數(shù)訪問。它是一個本地的全局變量。
3). 在模塊內(nèi)，一個被聲明為靜態(tài)的函數(shù)只可被這一模塊內(nèi)的其它函數(shù)調(diào)用。那就是，這個函數(shù)被限制在聲明它的模塊的本地范圍內(nèi)使用。
大多數(shù)應(yīng)試者能正確回答第一部分，一部分能正確回答第二部分，同是很少的人能懂得第三部分。這是一個應(yīng)試者的嚴重的缺點，因為他顯然不懂得本地化數(shù)
據(jù)和代碼范圍的好處和重要性。
?
Const
?
96.?關(guān)鍵字 const 是什么含意？
我只要一聽到被面試者說：“ const 意味著常數(shù)”，我就知道我正在和一個業(yè)余者打交道。去年 Dan Saks 已經(jīng)在他的文章里完全概括了 const 的所有用法，因此 ESP( 譯者： Embedded Systems Programming) 的每一位讀者應(yīng)該非常熟悉 const 能做什么和不能做什么 . 如果你從沒有讀到那篇文章，只要能說出 const 意味著“只讀”就可以了。盡管這個答案不是完全的答案，但我接受它作為一個正確的答案。（如果你想知道更詳細的答案，仔細讀一下 Saks 的文章吧。）如果應(yīng)試者能正確回答這個問題，我將問他一個附加的問題：下面的聲明都是什么意思？
?
const int a;
int const a;
const int *a;
int * const a;
int const * a const;
?
前兩個的作用是一樣， a 是一個常整型數(shù)。第三個意味著 a 是一個指向常整型數(shù)的指針（也就是，整型數(shù)是不可修改的，但指針可以）。第四個意思 a 是一個指向整型數(shù)的常指針（也就是說，指針指向的整型數(shù)是可以修改的，但指針是不可修改的）。最后一個意味著 a 是一個指向常整型數(shù)的常指針（也就是說，指針指向的整型數(shù)是不可修改的，同時指針也是不可修改的）。如果應(yīng)試者能正確回答這些問題，那么他就給我留下了一個好印象。順帶提一句，也許你可能會問，即使不用關(guān)鍵字 const ，也還是能很容易寫出功能正確的程序，那么我為什么還要如此看重關(guān)鍵字 const 呢？我也如下的幾下理由：
1). 關(guān)鍵字 const 的作用是為給讀你代碼的人傳達非常有用的信息，實際上，聲明一個參數(shù)為常量是為了告訴了用戶這個參數(shù)的應(yīng)用目的。如果你曾花很多時間清理其它人留下的垃圾，你就會很快學(xué)會感謝這點多余的信息。（當(dāng)然，懂得用 const 的程序員很少會留下的垃圾讓別人來清理的。）
2). 通過給優(yōu)化器一些附加的信息，使用關(guān)鍵字 const 也許能產(chǎn)生更緊湊的代碼。
3). 合理地使用關(guān)鍵字 const 可以使編譯器很自然地保護那些不希望被改變的參數(shù)，防止其被無意的代碼修改。簡而言之，這樣可以減少 bug 的出現(xiàn)。
?
Volatile
?
97.?關(guān)鍵字 volatile 有什么含意 并給出三個不同的例子。
?
一個定義為 volatile 的變量是說這變量可能會被意想不到地改變，這樣，編譯器就不會去假設(shè)這個變量的值了。精確地說就是，優(yōu)化器在用到這個變量時必須每次都小心地重新讀取這個變量的值，而不是使用保存在寄存器里的備份。下面是 volatile 變量的幾個例子：
1). 并行設(shè)備的硬件寄存器（如：狀態(tài)寄存器）
2). 一個中斷服務(wù)子程序中會訪問到的非自動變量 (Non-automatic variables)
3). 多線程應(yīng)用中被幾個任務(wù)共享的變量
回答不出這個問題的人是不會被雇傭的。我認為這是區(qū)分 C 程序員和嵌入式系統(tǒng)程序員的最基本的問題。嵌入式系統(tǒng)程序員經(jīng)常同硬件、中斷、 RTOS 等等打交道，所用這些都要求 volatile 變量。不懂得 volatile 內(nèi)容將會帶來災(zāi)難。
假設(shè)被面試者正確地回答了這是問題（嗯，懷疑這否會是這樣），我將稍微深究一下，看一下這家伙是不是直正懂得 volatile 完全的重要性。
1). 一個參數(shù)既可以是 const 還可以是 volatile 嗎？解釋為什么。
2). 一個指針可以是 volatile 嗎？解釋為什么。
3). 下面的函數(shù)有什么錯誤：
int square(volatile int *ptr)
{
return *ptr * *ptr;
}
下面是答案：
1). 是的。一個例子是只讀的狀態(tài)寄存器。它是 volatile 因為它可能被意想不到地改變。它是 const 因為程序不應(yīng)該試圖去修改它。
2). 是的。盡管這并不很常見。一個例子是當(dāng)一個中服務(wù)子程序修該一個指向一個 buffer 的指針時。
3). 這段代碼的有個惡作劇。這段代碼的目的是用來返指針 *ptr 指向值的平方，但是，由于 *ptr 指向一個 volatile 型參數(shù)，編譯器將產(chǎn)生類似下面的代碼：
int square(volatile int *ptr)
{
int a,b;
a = *ptr;
b = *ptr;
return a * b;
}
由于 *ptr 的值可能被意想不到地該變，因此 a 和 b 可能是不同的。結(jié)果，這段代碼可能返不是你所期望的平方值！正確的代碼如下：
long square(volatile int *ptr)
{
int a;
a = *ptr;
return a * a;
}
?
位操作（ Bit manipulation ）
?
?
98.?下面的代碼輸出是什么，為什么？
?
void foo(void)
{
unsigned int a = 6;
int b = -20;
(a+b > 6) puts("> 6") : puts("<= 6");
}
?
?
這個問題測試你是否懂得 C 語言中的整數(shù)自動轉(zhuǎn)換原則，我發(fā)現(xiàn)有些開發(fā)者懂得極少這些東西。不管如何，這無符號整型問題的答案是輸出是“ >6 ”。原因是當(dāng)表達式中存在有符號類型和無符號類型時所有的操作數(shù)都自動轉(zhuǎn)換為無符號類型。因此 -20 變成了一個非常大的正整數(shù)，所以該表達式計算出的結(jié)果大于 6 。這一點對于應(yīng)當(dāng)頻繁用到無符號數(shù)據(jù)類型的嵌入式系統(tǒng)來說是豐常重要的。如果你答錯了這個問題，你也就到了得不到這份工作的邊緣。
?
?
99.C?語言同意一些令人震驚的結(jié)構(gòu) , 下面的結(jié)構(gòu)是合法的嗎，如果是它做些什么？
int a = 5, b = 7, c;
c = a+++b;
?
這個問題將做為這個測驗的一個愉快的結(jié)尾。不管你相不相信，上面的例子是完全合乎語法的。問題是編譯器如何處理它？水平不高的編譯作者實際上會爭論這個問題，根據(jù)最處理原則，編譯器應(yīng)當(dāng)能處理盡可能所有合法的用法。因此，上面的代碼被處理成：
c = a++ + b;
因此 , 這段代碼持行后 a = 6, b = 7, c = 12 。
如果你知道答案，或猜出正確答案，做得好。如果你不知道答案，我也不把這個當(dāng)作問題。我發(fā)現(xiàn)這個問題的最大好處是 : 這是一個關(guān)于代碼編寫風(fēng)格，代碼的可讀性，代碼的可修改性的好的話題
?
?
?
?
今天早上的面試題 9 道，比較難，
100.?線形表 a 、 b 為兩個有序升序的線形表，編寫一程序，使兩個有序線形表合并成一個有序升序線形表 h ；
?
?
答案在 請化大學(xué) 嚴銳敏《數(shù)據(jù)結(jié)構(gòu)第二版》第二章例題，數(shù)據(jù)結(jié)構(gòu)當(dāng)中，這個叫做：兩路歸并排序
Linklist *unio(Linklist *p,Linklist *q){
linklist *R,*pa,*qa,*ra;
pa=p;
qa=q;
R=ra=p;
while(pa->next!=NULL&&qa->next!=NULL){
if(pa->data>qa->data){
ra->next=qa;
qa=qa->next;
}
else{
ra->next=pa;
pa=pa->next;
}
}
if(pa->next!=NULL)
ra->next=pa;
if(qa->next!=NULL)
ra->next==qa;
return R;
}
101.?用遞歸算法判斷數(shù)組 a[N] 是否為一個遞增數(shù)組。
遞歸的方法，記錄當(dāng)前最大的，并且判斷當(dāng)前的是否比這個還大，大則繼續(xù)，否則返回 false 結(jié)束：
bool fun( int a[], int n )
{
if( n= =1 )
return true;
if( n= =2 )
return a[n-1] >= a[n-2];
return fun( a,n-1) && ( a[n-1] >= a[n-2] );
}
102.?編寫算法，從 10 億個浮點數(shù)當(dāng)中，選出其中最大的 10000 個。
用外部排序，在《數(shù)據(jù)結(jié)構(gòu)》書上有《計算方法導(dǎo)論》在找到第 n 大的數(shù)的算法上加工
103.?編寫一 unix 程序，防止僵尸進程的出現(xiàn) .
同學(xué)的 4 道面試題，應(yīng)聘的職位是搜索引擎工程師，后兩道超級難，（希望大家多給一些算發(fā)）
1. 給兩個數(shù)組和他們的大小，還有一動態(tài)開辟的內(nèi)存，求交集，把交集放到動態(tài)內(nèi)存 dongtai ，并且返回交集個數(shù)
long jiaoji(long* a[],long b[],long* alength,long blength,long* dongtai[])
2. 單連表的建立，把 'a'--'z'26 個字母插入到連表中，并且倒敘，還要打印！
方法 1 ：
typedef struct val
{?? int date_1;
??? struct val *next;
}*p;
?
void main(void)
{?? char c;
????
??? for(c=122;c>=97;c--)
?????? { p.date=c;
? ??????? p=p->next;
??????? }
?
??? p.next=NULL;
}
}
方法 2 ：
node *p = NULL;
node *q = NULL;
?
node *head = (node*)malloc(sizeof(node));
head->data = ' ';head->next=NULL;
?
node *first = (node*)malloc(sizeof(node));
first->data = 'a';first->next=NULL;head->next = first;
p = first;
?
int longth = 'z' - 'b';
int i=0;
while ( i<=longth )
{
node *temp = (node*)malloc(sizeof(node));
temp->data = 'b'+i;temp->next=NULL;q=temp;
?
head->next = temp; temp->next=p;p=q;
i++;
}
?
print(head);
?
104.?可怕的題目終于來了
象搜索的輸入信息是一個字符串，統(tǒng)計 300 萬輸入信息中的最熱門的前十條，我們每次輸入的一個字符串為不超過 255byte, 內(nèi)存使用只有 1G ,
請描述思想，寫出算發(fā)（ c 語言），空間和時間復(fù)雜度，
7. 國內(nèi)的一些帖吧，如 baidu, 有幾十萬個主題，假設(shè)每一個主題都有上億的跟帖子，怎么樣設(shè)計這個系統(tǒng)速度最好，請描述思想，寫出算發(fā)（ c 語言），空間和時間復(fù)雜度，
?
?
#include?? string.h
main(void)
{?? char?? *src="hello,world";
??? char?? *dest=NULL;
??? dest=(char ?? *)malloc(strlen(src));
??? int?? len=strlen(str);
??? char?? *d=dest;
??? char?? *s=src[len];
??? while(len--!=0)
????? d++=s--;
??? printf("%s",dest);
}
找出錯誤！！
#include?? "string.h"
#include "stdio.h"
#include "malloc.h"
main(void)
{??
char?? *src="hello,world";
??? char?? *dest=NULL;
??? dest=(char?? *)malloc(sizeof(char)*(strlen(src)+1));
??? int?? len=strlen(src);
??? char?? *d=dest;
??? char?? *s=src+len-1;
??? while(len--!=0)
????? *d++=*s--;
*d='/0';
??? printf("%s",dest);
}
105.?判斷字符串是否為回文
bool?IsSymmetry(const?char?* p)
???? {
???????? assert(p!=NULL);
?????????const?char?* q=p;??????
?????????int?len=0;
?????????while?(*q++!='/0'?)
???????? {
????????????? len++;
???????? }???????
?????????bool?bSign=true?;
???????? q=p+len-1;
?????????if?(0<len)
???????? {
??????????????for?(int?i=0;i<len/2;i++)
????????????? {
???????????????????if?(*p++!=*q--){ bSign=false?;break?;};
????????????? }
???????? }
?????????if?(bSign==true?)
???????? {
????????????? printf("Yes!/n"?);
???????? }
?????????else
???????? {
????????????? printf("No!/n"?);
???????? }
?????????return?bSign;
???? }
107.ASDL?使用的是什么協(xié)議？并進行簡單描述？
?
108.Static?作用是什么
首先 static 的最主要功能是隱藏，其次因為 static 變量存放在靜態(tài)存儲區(qū)，所以它具備持久性和默認值 0 。
109.?什么是預(yù)編譯 , 何時需要預(yù)編譯 ?
預(yù)編譯又稱為預(yù)處理 , 是做些代碼文本的替換工作。處理 # 開頭的指令 , 比如拷貝 #include 包含的文件代碼， #define 宏定義的替換 , 條件編譯等，就是為編譯做的預(yù)備工作的階段，主要處理 # 開始的預(yù)編譯指令，預(yù)編譯指令指示了在程序正式編譯前就由編譯器進行的操作，可以放在程序中的任何位置。
?
c 編譯系統(tǒng)在對程序進行通常的編譯之前，先進行預(yù)處理。 c 提供的預(yù)處理功能主要有以下三種： 1 ）宏定義 2 ）文件包含 3 ）條件編譯
?
１、總是使用不經(jīng)常改動的大型代碼體。?
２、程序由多個模塊組成，所有模塊都使用一組標準的包含文件和相同的編譯選項。在這種情況下，可以將所有包含文件預(yù)編譯為一個預(yù)編譯頭。
?
110.?進程和線程的區(qū)別
什么是進程（ Process ）：普通的解釋就是，進程是程序的一次執(zhí)行，而什么是線程（ Thread ），線程可以理解為進程中的執(zhí)行的一段程序片段。在一個多任務(wù)環(huán)境中下面的概念可以幫助我們理解兩者間的差別：?
進程間是獨立的，這表現(xiàn)在內(nèi)存空間，上下文環(huán)境；線程運行在進程空間內(nèi)。 一般來講（不使用特殊技術(shù)）進程是無法突破進程邊界存取其他進程內(nèi)的存儲空間；而線程由于處于進程空間內(nèi)，所以同一進程所產(chǎn)生的線程共享同一內(nèi)存空間。 同一進程中的兩段代碼不能夠同時執(zhí)行，除非引入線程。線程是屬于進程的，當(dāng)進程退出時該進程所產(chǎn)生的線程都會被強制退出并清除。線程占用的資源要少于進程所占用的資源。 進程和線程都可以有優(yōu)先級。在線程系統(tǒng)中進程也是一個線程。可以將進程理解為一個程序的第一個線程。
?
線程是指進程內(nèi)的一個執(zhí)行單元 , 也是進程內(nèi)的可調(diào)度實體 . 與進程的區(qū)別 :
(1) 地址空間 : 進程內(nèi)的一個執(zhí)行單元 ; 進程至少有一個線程 ; 它們共享進程的地址空間 ; 而進程有自己獨立的地址空間 ;
(2) 進程是資源分配和擁有的單位 , 同一個進程內(nèi)的線程共享進程的資源?
(3) 線程是處理器調(diào)度的基本單位 , 但進程不是 .
(4) 二者均可并發(fā)執(zhí)行 .
111.?插入排序和
插入排序基本思想：（假定從大到小排序）依次從后面拿一個數(shù)和前面已經(jīng)排好序的數(shù)進行比較，比較的過程是從已經(jīng)排好序的數(shù)中最后一個數(shù)開始比較，如果比這個數(shù)，繼續(xù)往前面比較，直到找到比它大的數(shù)，然后就放在它的后面，如果一直沒有找到，肯定這個數(shù)已經(jīng)比較到了第一個數(shù)，那就放到第一個數(shù)的前面。那么一般情況下，對于采用插入排序法去排序的一組數(shù)，可以先選 取第一個數(shù)做為已經(jīng)排好序的一組數(shù)。然后把第二個放到正確位置。
?
選擇排序 (Selection Sort) 是一種簡單直觀的排序算法。它的工作原理如下。首先在未排序序列中找到最小元素 , 存放到排序序列的起始位置 , 然后 , 再從剩余未排序元素中繼續(xù)尋找最小元素 , 然后放到排序序列末尾。以此類推 , 直到所有元素均排序完畢。
112.?運算符優(yōu)先級問題
能正確表示 a 和 b 同時為正或同時為負的邏輯表達式是 (D ) 。
sssA 、 (a>=0||b>=0) ＆＆ (a<0||b<0)?
B 、 (a>=0 ＆＆ b>=0)&&(a<0& ＆ b<0)?
C 、 (a+b>0) ＆＆ (a+b<=0)?
D 、 a*b>0
?
以下關(guān)于運算符優(yōu)先順序的描述中正確的是 (C) 。?
A 、關(guān)系運算符 < 算術(shù)運算符 < 賦值運算符 < 邏輯與運算符?
B 、邏輯與運算符 < 關(guān)系運算符 < 算術(shù)運算符 < 賦值運算符?
C 、賦值運算符 < 邏輯與運算符 < 關(guān)系運算符 < 算術(shù)運算符?
D 、算術(shù)運算符 < 關(guān)系運算符 < 賦值運算符 < 邏輯與運算符
?
113. 字符串倒序
?
寫一個函數(shù)將 "tom is cat" 倒序打印出來，即 "cat is tom"
//a.ch
#define SPACE ' '
#define ENDL '/0'
char* str = "Tom is cat"; // 字符串?
char* p1 = str+strlen(str)-1;
char* p2 = p1; // 開始時， p1,p2 都指向字符串結(jié)尾處?
char t=0; // 臨時變量，用來保存被臨時替換為 ENDL 的字符
while(str!=p1--)
{
??if(SPACE!=*p1){
?????for(p2=p1+1;SPACE!=*p1; p1--, t=*p2, *p2=ENDL);
?????// p1+1 指向單詞的第一個字母 ,p2 指向單詞的結(jié)尾 , 此時輸出這個單詞?
??????????????? printf("%s ",p1+1);
??????????????? *p2=t;
??????????????? p2=p1;
???????? }
}
Output:
cat is Tom
----------------------------------------------------------------------
1) 寫一個遞歸函數(shù)將內(nèi)存中的字符串翻轉(zhuǎn) "abc"->"cba"
2) 寫一個函數(shù)將 "tom is cat" 將內(nèi)存中的字符串翻轉(zhuǎn)，即 "cat is tomm"?
#include <stdio.h>
#define SPACE ' '
#define ENDL '/0'
char* s = "The quick brown fox jumps over the lazy dog";
void str_reverse(char* p1,char* p2){
????? if(p1==p2)return;
????*p1 = (*p1)+(*p2);
????*p2 = (*p1)-(*p2);
????*p1 = (*p1)-(*p2);
????? if(p1==p2-1)return;
????? else str_reverse(++p1,--p2);
}
void str_word_reverse(char* str){
????? char *q1=str, *q2=str, *t;
????? while(*q1==SPACE)q1++;
????? if(*q1==ENDL)return; //!
????? else q2=q1+1;
????? while( (*q2!=SPACE) && (*q2!=ENDL) )q2++;
????
?????t=q2--;?
????str_reverse(q1,q2);
????? if(*t==ENDL)return;
????? else str_word_reverse(t);
}
int
main(int a ,char** b)
{
????printf("%s/n",s);
????str_reverse(s,s+strlen(s)-1);
????printf("%s/n",s);
????str_word_reverse(s);
????printf("%s/n",s);
?????????? return 0;
}
Output:
The quick brown fox jumps over the lazy dog
god yzal eht revo spmuj xof nworb kciuq ehT
dog lazy the over jumps fox brown quick The
----------------------------------------------------------------------
今天同學(xué)又問一道題 , 和上面有些類似，但是要求更嚴格了一些：?
寫一個遞歸函數(shù)將內(nèi)存中的字符串翻轉(zhuǎn) "abc"->"cba", 并且函數(shù)原型已確定： void reverse(char* p)
其實，要求越多，思路越確定，我的解如下：?
#include <stdio.h>
#include <string.h>
char* s = "0123456789";
#define ENDL '/0'
void reverse(char* p){
?????? // 這是這種方法的關(guān)鍵，使用 static 為的是能用 str_reverse 的思路，但是不好?
?????? static char* x=0;
?????? if(x==0)x=p;
?????? char* q = x+strlen(p)-1;?
?????? if(p==q)return;
?????? *q=(*p)^(*q);
?????? *p=(*p)^(*q);
?????? *q =(*p)^(*q);
?????? if(q==p+1)return;
?????? reverse(++p);
}
// 這種方法就直觀多了，但是當(dāng)字符串很長的時候就很低效?
void reverse2(char* p){
?????? if(*(p+1)==ENDL)return;
?????? for(char* o=p+strlen(p)-1,char t=*o;o!=p;o--)
????????? *o=*(o-1);
?????? *p=t;
?????? reverse2(p+1);
}
int main(int c,char** argv){
?????? reverse2(s);
?????? printf("%s/n",s);
?????? return 0;
}
?
114. 交換兩個數(shù)的宏定義
?
交換兩個參數(shù)值的?宏定義?為：?. #define?SWAP?(a,b) (a)=(a)+(b);(b)=(a)-(b);(a)=(a)-(b);
?
115.Itearator 各指針的區(qū)別
?
游標和指針
我說過游標是指針，但不僅僅是指針。游標和指針很像，功能很像指針，但是實際上，游標是通過重載一元的 ”*” 和 ”->” 來從容器中間接地返回一個值。將這些值存儲在容器中并不是一個好主意，因為每當(dāng)一個新值添加到容器中或者有一個值從容器中刪除，這些值就會失效。在某種程度上，游標可以看作是句柄（ handle ）。通常情況下游標（ iterator ）的類型可以有所變化，這樣容器也會有幾種不同方式的轉(zhuǎn)變：
iterator——?對于除了 vector 以外的其他任何容器，你可以通過這種游標在一次操作中在容器中朝向前的方向走一步。這意味著對于這種游標你只能使用 “++” 操作符。而不能使用 “--” 或 “+=” 操作符。而對于 vector 這一種容器，你可以使用 “+=” 、 “—” 、 “++” 、 “-=” 中的任何一種操作符和 “<” 、 “<=” 、 “>” 、 “>=” 、 “==” 、 “!=” 等比較運算符。
?
116. C++ 中的 class 和 struct 的區(qū)別
從語法上，在 C++ 中（只討論 C++ 中）。 class 和 struct 做類型定義時只有兩點區(qū)別：?
（一）默認繼承權(quán)限。如果不明確指定，來自 class 的繼承按照 private 繼承處理，來自 struct 的繼承按照 public 繼承處理；?
（二）成員的默認訪問權(quán)限。 class 的成員默認是 private 權(quán)限， struct 默認是 public 權(quán)限。?
除了這兩點， class 和 struct 基本就是一個東西。語法上沒有任何其它區(qū)別。
不能因為學(xué)過 C 就總覺得連 C++ 中 struct 和 class 都區(qū)別很大，下面列舉的說明可能比較無聊，因為 struct 和 class 本來就是基本一樣的東西，無需多說。但這些說明可能有助于澄清一些常見的關(guān)于 struct 和 class 的錯誤認識：?
（ 1 ）都可以有成員函數(shù)；包括各類構(gòu)造函數(shù)，析構(gòu)函數(shù)，重載的運算符，友元類，友元結(jié)構(gòu)，友元函數(shù)，虛函數(shù)，純虛函數(shù)，靜態(tài)函數(shù)；?
（ 2 ）都可以有一大堆 public/private/protected 修飾符在里邊；?
（ 3 ）雖然這種風(fēng)格不再被提倡，但語法上二者都可以使用大括號的方式初始化：
A a = {1, 2, 3}; 不管 A 是個 struct 還是個 class ，前提是這個類 / 結(jié)構(gòu)足夠簡單，比如所有的成員都是 public 的，所有的成員都是簡單類型，沒有顯式聲明的構(gòu)造函數(shù)。?
（ 4 ）都可以進行復(fù)雜的繼承甚至多重繼承，一個 struct 可以繼承自一個 class ，反之亦可；一個 struct 可以同時繼承 5 個 class 和 5 個 struct ，雖然這樣做不太好。?
（ 5 ）如果說 class 的設(shè)計需要注意 OO 的原則和風(fēng)格，那么沒任何理由說設(shè)計 struct 就不需要注意。?
（ 6 ）再次說明，以上所有說法都是指在 C++ 語言中，至于在 C 里的情況， C 里是根本沒有 “class” ，而 C 的 struct 從根本上也只是個包裝數(shù)據(jù)的語法機制。?
---------------------------------------------------------------
最后，作為語言的兩個關(guān)鍵字，除去定義類型時有上述區(qū)別之外，另外還有一點點： “class” 這個關(guān)鍵字還用于定義模板參數(shù)，就像 “typename” 。但關(guān)鍵字 “struct” 不用于定義模板參數(shù)。
?
關(guān)于使用大括號初始化
class 和 struct 如果定義了構(gòu)造函數(shù)的話，都不能用大括號進行初始化
如果沒有定義構(gòu)造函數(shù)， struct 可以用大括號初始化。
如果沒有定義構(gòu)造函數(shù)，且所有成員變量全是 public 的話，可以用大括號初始化。
關(guān)于默認訪問權(quán)限
class 中默認的成員訪問權(quán)限是 private 的，而 struct 中則是 public 的。
關(guān)于繼承方式
class 繼承默認是 private 繼承，而 struct 繼承默認是 public 繼承。
關(guān)于模版
?
在模版中，類型參數(shù)前面可以使用 class 或 typename ，如果使用 struct ，則含義不同， struct 后面跟的是 “non-type template parameter” ，而 class 或 typename 后面跟的是類型參數(shù)。
?
class 中有個默認的 this 指針， struct 沒有?
不同點：構(gòu)造函數(shù)，析構(gòu)函數(shù) ?this? 指針
?
117. 有關(guān)重載函數(shù)
?
返回值類型不同構(gòu)不成重載?
參數(shù)參數(shù)順序不同能構(gòu)成重載
c++ 函數(shù)同名不同返回值不算重載！函數(shù)重載是忽略返回值類型的。?
---------------------------------------------?
成員函數(shù)被重載的特征有：?
1) 相同的范圍（在同一個類中）；?
2) 函數(shù)名字相同；?
3) 參數(shù)不同；?
4) virtual 關(guān)鍵字可有可無。
5) 成員函數(shù)中 有無 const ( 函數(shù)后面 ) 也可判斷是否重載
?
118. 數(shù)據(jù)庫與 T-SQL 語言?
???
關(guān)系數(shù)據(jù)庫是表的集合，它是由一個或多個關(guān)系模式定義。 SQL 語言中的數(shù)據(jù)定義功能包括對數(shù)據(jù)庫、基本表、視圖、索引的定義。
?
119. 關(guān)系模型的基本概念?
? 關(guān)系數(shù)據(jù)庫以關(guān)系模型為基礎(chǔ)，它有以下三部分組成：?
??? ● 數(shù)據(jù)結(jié)構(gòu) —— 模型所操作的對象、類型的集合?
??? ● 完整性規(guī)則 —— 保證數(shù)據(jù)有效、正確的約束條件?
??? ● 數(shù)據(jù)操作 —— 對模型對象所允許執(zhí)行的操作方式?
??? 關(guān)系（ Relation ）是一個由行和列組成的二維表格，表中的每一行是一條記錄（ Record ），每一列是記錄的一個字段（ Field ）。表中的每一條記錄必須是互斥的，字段的值必須具有原子性。?
120.SQL 語言概述
????SQL （結(jié)構(gòu)化查詢語言）是關(guān)系數(shù)據(jù)庫語言的一種國際標準，它是一種非過程化的語言。通過編寫 SQL ，我們可以實現(xiàn)對關(guān)系數(shù)據(jù)庫的全部操作。?
??? ● 數(shù)據(jù)定義語言（ DDL ） —— 建立和管理數(shù)據(jù)庫對象?
??? ● 數(shù)據(jù)操縱語言（ DML ） —— 用來查詢與更新數(shù)據(jù)?
??? ● 數(shù)據(jù)控制語言（ DCL ） —— 控制數(shù)據(jù)的安全性
?
起來是一個很簡單的問題，每一個使用過 RDBMS 的人都會有一個概念。
事務(wù)處理系統(tǒng)的典型特點是具備 ACID 特征。 ACID 指的是 Atomic （原子的）、 Consistent （一致的）、 Isolated （隔離的）以及 Durable （持續(xù)的），它們代表著事務(wù)處理應(yīng)該具備的四個特征：
原子性：組成事務(wù)處理的語句形成了一個邏輯單元，不能只執(zhí)行其中的一部分
一致性：在事務(wù)處理執(zhí)行之前和之后，數(shù)據(jù)是一致的。
隔離性：一個事務(wù)處理對另一個事務(wù)處理沒有影響。
持續(xù)性：當(dāng)事務(wù)處理成功執(zhí)行到結(jié)束的時候，其效果在數(shù)據(jù)庫中被永久紀錄下來。
?
121.C 語言中結(jié)構(gòu)化程序設(shè)計的三種基本控制結(jié)構(gòu)
?
順序結(jié)構(gòu)?
選擇結(jié)構(gòu)?
循環(huán)結(jié)構(gòu)
?
122.CVS 是什么
?
cvs （ Concurrent Version System ） 是一個版本控制系統(tǒng)。使用它，可以記錄下你的源文件的歷史。?
例如，修改軟件時可能會不知不覺混進一些 bug ，而且可能過了很久你才會察覺到它們的存在。有了 cvs ，你可以很容易地恢復(fù)舊版本，并從中看出到底是哪個修改導(dǎo)致了這個 bug 。有時這是很有用的。?
CVS 服務(wù)器端對每個文件維護著一個修訂號 , 每次對文件的更新，都會使得文件的修訂號加 1 。在客戶端中也對每個文件維護著一個修訂號 ,CVS 通過這兩個修訂號的關(guān)系，來進行 Update,Commit 和發(fā)現(xiàn)沖突等操作操作
?
123. 三種基本的數(shù)據(jù)模型
?
按照數(shù)據(jù)結(jié)構(gòu)類型的不同，將數(shù)據(jù)模型劃分為層次模型、網(wǎng)狀模型和關(guān)系模型。
總結(jié)
以上是生活随笔為你收集整理的C++笔试题目大全(笔试宝典)的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 网站监控程序uptime-kuma，宝塔
- 下一篇： c/C++笔试题总结