來自 http://bbs.firnow.com/dview65t53914.html
C++筆試題目大全(筆試寶典)(不斷完善中) 收藏 (轉)
1.new 、 delete 、 malloc 、 free
關係
delete 會調用對象的析構函數 , 和 new 對應 free 只會釋放內存， new 調用構造函數。 malloc 與
free 是 C++/C 語言的標準庫函數， new/delete 是 C++
的運算符。它們都可用於申請動態內存和釋放內存。對於非內部數據類型的對象而言，光用 maloc/free
無法滿足動態對象的要求。對象在創建的同時要自動執行構造函數，對象在消亡之前要自動執行析構函數。由於 malloc/free
是庫函數而不是運算符，不在編譯器控制權限之內，不能夠把執行構造函數和析構函數的任務強加於 malloc/free 。因此 C++
語言需要一個能完成動態內存分配和初始化工作的運算符 new ，以及一個能完成清理與釋放內存工作的運算符 delete 。注意
new/delete 不是庫函數。
總結：new和delete會自動調用對象的構造與析構函數而malloc與free不會；
new和delete式C++運算符，而malloc和free是C/C++標準庫函數。
2.delete
與 delete [] 區別
delete 只會調用一次析構函數，而 delete[] 會調用每一個成員的析構函數。在 More
Effective C++ 中有更爲詳細的解釋：“當 delete 操作符用於數組時，它爲每個數組元素調用析構函數，然後調用
operatordelete 來釋放內存。” 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- 處報錯。
這就說明：對於內建簡單數據類型， delete 和 delete[] 功能是相同的。對於自定義的複雜數據類型， delete 和
delete[] 不能互用。 delete[] 刪除一個數組， delete 刪除一個指針簡單來說，用 new 分配的內存用 delete
刪除用 new[] 分配的內存用 delete[] 刪除 delete[]
會調用數組元素的析構函數。內部數據類型沒有析構函數，所以問題不大。如果你在用 delete 時沒用括號， delete
就會認爲指向的是單個對象，否則，它就會認爲指向的是一個數組。
總結： delete 只會調用一次析構函數，而 delete[]
會調用每一個成員的析構函數。
3.C C++ JAVA 共同點，不同之處？
4. 繼承優缺點。
類
繼承是在編譯時刻靜態定義的，且可直接使用，類繼承可以較方便地改變父類的實現。但是類繼承也有一些不足之處。首先，因爲繼承在編譯時刻就定義了，所以無
法在運行時刻改變從父類繼承的實現。更糟的是，父類通常至少定義了子類的部分行爲，父類的任何改變都可能影響子類的行爲。如果繼承下來的實現不適合解決新
的問題，則父類必須重寫或被其他更適合的類替換。這種依賴關係限制了靈活性並最終限制了複用性。
（待補充）
5.C++
有哪些性質（面向對象特點）
封裝，繼承和多態。
在面向對象程序設計語言中，封裝是利用可重用成分構造軟件系統的特性，它不
僅支持系統的可重用性，而且還有利於提高系統的可擴充性；消息傳遞可以實現發送一個通用的消息而調用不同的方法；封裝是實現信息隱蔽的一種技術，其目的是
使類的定義和實現分離。
6. 子類析構時要調用父類的析構函數嗎？
析構函數調用的次序是先派生類的析構後基類的析構，也就是
說在基類的的析構調用的時候 ,
派生類的信息已經全部銷燬了定義一個對象時先調用基類的構造函數、然後調用派生類的構造函數；析構的時候恰好相反：先調用派生類的析構函數、然後調用基類
的析構函數 JAVA 無析構函數深拷貝和淺拷貝
7. 多態，虛函數，純虛函數
8.
求下面函數的返回值（微軟）
int func(x)
{
int countx = 0;
while(x)
{
countx ++;
x =
x&(x-1);
}
return countx;
}
假定 x =
9999 。 答案： 8
思路：將 x 轉化爲 2 進制，看含有的 1 的個數。
9. 什麼是 “ 引用 ”
？申明和使用 “ 引用 ” 要注意哪些問題？
答：引用就是某個目標變量的 “ 別名 ”(alias)
，對應用的操作與對變量直接操作效果完全相同。申明一個引用的時候，切記要對其進行初始化。引用聲明完畢後，相當於目標變量名有兩個名稱，即該目標原名稱
和引用名，不能再把該引用名作爲其他變量名的別名。聲明一個引用，不是新定義了一個變量，它只表示該引用名是目標變量名的一個別名，它本身不是一種數據類
型，因此引用本身不佔存儲單元，系統也不給引用分配存儲單元。不能建立數組的引用。
10. 將 “ 引用 ”
作爲函數參數有哪些特點？
（ 1
）傳遞引用給函數與傳遞指針的效果是一樣的。這時，被調函數的形參就成爲原來主調函數中的實參變量或對象的一個別名來使用，所以在被調函數中對形參變量的
操作就是對其相應的目標對象（在主調函數中）的操作。
（ 2
）使用引用傳遞函數的參數，在內存中並沒有產生實參的副本，它是直接對實參操作；而使用一般變量傳遞函數的參數，當發生函數調用時，需要給形參分配存儲單
元，形參變量是實參變量的副本；如果傳遞的是對象，還將調用拷貝構造函數。因此，當參數傳遞的數據較大時，用引用比用一般變量傳遞參數的效率和所佔空間都
好。
（ 3 ）使用指針作爲函數的參數雖然也能達到與使用引用的效果，但是，在被調函數中同樣要給形參分配存儲單元，且需要重複使用
"* 指針變量名 "
的形式進行運算，這很容易產生錯誤且程序的閱讀性較差；另一方面，在主調函數的調用點處，必須用變量的地址作爲實參。而引用更容易使用，更清晰。
11.
在什麼時候需要使用 “ 常引用 ” ？
如果既要利用引用提高程序的效率，又要保護傳遞給函數的數據不在函數中被改變，就應使用常引用。
常引用聲明方式： 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"
串都會產生一個臨時對象，而在 C++ 中，這些臨時對象都是 const 類型的。因此上面的表達式就是試圖將一個 const 類型的對象轉換爲非
const 類型，這是非法的。引用型參數應該在能被定義爲 const 的情況下，儘量定義爲 const 。
12. 將 “ 引用
” 作爲函數返回值類型的格式、好處和需要遵守的規則 ?
格式：類型標識符 & 函數名（形參列表及類型說明） { // 函數體 }
好處：在內存中不產生被返回值的副本；（注意：正是因爲這點原因，所以返回一個局部變量的引用是不可取的。因爲隨着該局部變量生存期的
結束，相應的引用也會失效，產生 runtime error! 注意事項：
（ 1 ）不能返回局部變量的引用。這條可以參照
Effective C++[1] 的 Item 31 。主要原因是局部變量會在函數返回後被銷燬，因此被返回的引用就成爲了 " 無所指 "
的引用，程序會進入未知狀態。
（ 2 ）不能返回函數內部 new 分配的內存的引用。這條可以參照 Effective
C++[1] 的 Item 31 。雖然不存在局部變量的被動銷燬問題，可對於這種情況（返回函數內部 new
分配內存的引用），又面臨其它尷尬局面。例如，被函數返回的引用只是作爲一個臨時變量出現，而沒有被賦予一個實際的變量，那麼這個引用所指向的空間（由
new 分配）就無法釋放，造成 memory leak 。
（ 3 ）可以返回類成員的引用，但最好是 const
。這條原則可以參照 Effective C++[1] 的 Item 30 。主要原因是當對象的屬性是與某種業務規則（ business rule
）相關聯的時候，其賦值常常與某些其它屬性或者對象的狀態有關，因此有必要將賦值操作封裝在一個業務規則當中。如果其它對象可以獲得該屬性的非常量引用
（或指針），那麼對該屬性的單純賦值就會破壞業務規則的完整性。
（ 4 ）流操作符重載返回值申明爲 “ 引用 ” 的作用：
流
操作符 << 和 >> ，這兩個操作符常常希望被連續使用，例如： cout << "hello"
<< endl;
因此這兩個操作符的返回值應該是一個仍然支持這兩個操作符的流引用。可選的其它方案包括：返回一個流對象和返回一個流對象指針。但是對於返回一個流對
象，程序必須重新（拷貝）構造一個新的流對象，也就是說，連續的兩個 <<
操作符實際上是針對不同對象的！這無法讓人接受。對於返回一個流指針則不能連續使用 <<
操作符。因此，返回一個流對象引用是惟一選擇。這個唯一選擇很關鍵，它說明了引用的重要性以及無可替代性，也許這就是 C++
語言中引入引用這個概念的原因吧。 賦值操作符 = 。這個操作符象流操作符一樣，是可以連續使用的，例如： x = j = 10; 或者
(x=10)=100; 賦值操作符的返回值必須是一個左值，以便可以被繼續賦值。因此引用成了這個操作符的惟一返回值選擇。
例 3
＃
i nclude <iostream.h>
int &put(int n);
int vals[10];
int
error=-1;
void main()
{
put(0)=10; // 以 put(0) 函數值作爲左值，等價於
vals[0]=10;
put(9)=20; // 以 put(9) 函數值作爲左值，等價於 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
，因此，它們必須構造一個對象作爲返回值，可選的方案包括：返回一個對象、返回一個局部變量的引用，返回一個 new
分配的對象的引用、返回一個靜態對象引用。根據前面提到的引用作爲返回值的三個規則，第 2 、 3 兩個方案都被否決了。靜態對象的引用又因爲
((a+b) == (c+d)) 會永遠爲 true 而導致錯誤。所以可選的只剩下返回一個對象了。
13.“ 引用 ”
與多態的關係？
引用是除指針外另一個可以產生多態效果的手段。這意味着，一個基類的引用可以指向它的派生類實例。例 4
Class
A; Class B : Class A{...}; B b; A& ref = b;
14.“ 引用 ”
與指針的區別是什麼？
指針通過某個指針變量指向一個對象後，對它所指向的變量間接操作。程序中使用指針，程序的可讀性差；而引用本身就是目標變
量的別名，對引用的操作就是對目標變量的操作。此外，就是上面提到的對函數傳 ref 和 pointer 的區別。
15.
什麼時候需要 “ 引用 ” ？
流操作符 << 和 >> 、賦值操作符 =
的返回值、拷貝構造函數的參數、賦值操作符 = 的參數、其它情況都推薦使用引用。以上 2-8 參考： http://develop.csai.cn/c/NO0000021.htm
16. 結構與聯合有和區別？
(1). 結構和聯合都是由多個不同的數據類型成員組成 , 但在任何同一時刻 ,
聯合中只存放了一個被選中的成員（所有成員共用一塊地址空間） , 而結構的所有成員都存在（不同成員的存放地址不同）。
(2).
對於聯合的不同成員賦值 , 將會對其它成員重寫 , 原來成員的值就不存在了 , 而對於結構的不同成員賦值是互不影響的。
17.
面關於 “ 聯合 ” 的題目的輸出？
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 ( 低位低地址，高位高地址，內存佔用情況是 Ox010A ）
b)
main()
{
union{
/* 定義一個聯合 */
int i;
struct{
/* 在聯合中定義一個結構 */
char first;
char second;
}half;
}number;
number.i=0x4241; /* 聯合成員賦值 */
printf("%c%cn", number.half.first, mumber.half.second);
number.half.first='a'; /* 聯合中結構成員賦值 */
number.half.second='b';
printf("%xn", number.i);
getch();
}
答案： AB (0x41 對應 'A', 是低位； Ox42 對應 'B',
是高位）
6261 (number.i 和 number.half 共用一塊地址空間）
18.
關聯、聚合 (Aggregation) 以及組合 (Composition) 的區別？
涉及到 UML
中的一些概念：關聯是表示兩個類的一般性聯繫，比如 “ 學生 ” 和 “ 老師 ” 就是一種關聯關係；聚合表示 has-a
的關係，是一種相對鬆散的關係，聚合類不需要對被聚合類負責，如下圖所示，用空的菱形表示聚合關係：從實現的角度講，聚合可以表示爲 :
class
A {...} class B { A* a; .....}
而組合表示 contains-a
的關係，關聯性強於聚合：組合類與被組合類有相同的生命週期，組合類要對被組合類負責，採用實心的菱形表示組合關係：實現的形式是 :
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. 面向對象的三個基本特徵，並簡單敘述之？
1. 封裝：將客觀事物抽象成類，每個類對自身的數據和方法實行
protection(private, protected,public)
2.
繼承：廣義的繼承有三種實現形式：實現繼承（指使用基類的屬性和方法而無需額外編碼的能力）、可視繼承（子窗體使用父窗體的外觀和實現代碼）、接口繼承
（僅使用屬性和方法，實現滯後到子類實現）。前兩種（類繼承）和後一種（對象組合 => 接口繼承以及純虛函數）構成了功能複用的兩種方式。
3.
多態：是將父對象設置成爲和一個或更多的他的子對象相等的技術，賦值之後，父對象就可以根據當前賦值給它的子對象的特性以不同的方式運作。簡單的說，就是
一句話：允許將子類類型的指針賦值給父類類型的指針。
20. 重載（ overload) 和重寫 (overried
，有的書也叫做 “ 覆蓋 ” ）的區別？
常考的題目。從定義上來說：
重載：是指允許存在多個同名函數，而這些函數的參數表
不同（或許參數個數不同，或許參數類型不同，或許兩者都不同）。
重寫：是指子類重新定義父類虛函數的方法。
從實現原
理上來說：
重載：編譯器根據函數不同的參數表，對同名函數的名稱做修飾，然後這些同名函數就成了不同的函數（至少對於編譯器來說是這樣
的）。如，有兩個同名函數： function func(p:integer):integer; 和 function
func(p:string):integer; 。 那麼編譯器做過修飾後的函數名稱可能是這樣的： int_func 、 str_func
。對於這兩個函數的調用，在編譯器間就已經確定了，是 靜態 的。也就是說， 它們的地址在編譯期就綁定了（早綁定）， 因此， 重載和多態無關 ！
重
寫：和多態真正相關。當子類重新定義了父類的虛函數後，父類指針根據賦給它的不同的子類指針， 動態的調用 屬於子類的該函數，這樣的函
數調用在編譯期間是無法確定的 （調用的子類的虛函數的地址無法給出）。因此， 這樣的函數地址是在運行期綁定的（晚綁定）。
21.
多態的作用？
主要是兩個：
1. 隱藏實現細節，使得代碼能夠模塊化；擴展代碼模塊，實現代碼重用；
2.
接口重用：爲了類在繼承和派生的時候 ，保證使用家族中任一類的實例的某一屬性時的正確調用 。
22.Ado 與 Ado.net
的相同與不同？
除了“能夠讓應用程序處理存儲於 DBMS 中的數據“這一基本相似點外，兩者沒有太多共同之處。但是 Ado 使用 OLE
DB 接口並基於微軟的 COM 技術，而 ADO.NET 擁有自己的 ADO.NET 接口並且基於微軟的 .NET 體系架構。衆所周知 .NET
體系不同於 COM 體系， ADO.NET 接口也就完全不同於 ADO 和 OLE DB 接口，這也就是說 ADO.NET 和 ADO
是兩種數據訪問方式。 ADO.net 提供對 XML 的支持。
23.New delete 與 malloc free
的聯繫與區別 ?
答案：都是在堆 (heap) 上進行動態的內存操作。用 malloc 函數需要指定內存分配的字節數並且不能初始化對象，
new 會自動調用對象的構造函數。 delete 會調用對象的 destructor ，而 free 不會調用對象的 destructor.
24.#define
DOUBLE(x) x+x ， i = 5*DOUBLE(5) ； i 是多少？
答案： i 爲 30 。
25.
有哪幾種情況只能用 intialization list 而不能用 assignment?
答案：當類中含有 const 、
reference 成員變量；基類的構造函數都需要初始化表。
26. C++ 是不是類型安全的？
答案：不是。兩個不同類
型的指針之間可以強制轉換（用 reinterpret cast) 。 C# 是類型安全的。
27. main
函數執行以前，還會執行什麼代碼？
答案：全局對象的構造函數會在 main 函數之前執行。
28.
描述內存分配方式以及它們的區別 ?
1 ） 從靜態存儲區域分配
。內存在程序編譯的時候就已經分配好，這塊內存在程序的整個運行期間都存在。例如 全局變量， static 變量 。
2 ） 在棧上創建
。在執行函數時， 函數內局部變量的存儲單元都可以在棧上創建 ，函數執行結束時這些存儲單元自動被釋放。棧內存分配運算內置於處理器的指令集。
3
） 從堆上分配 ， 亦稱動態內存分配 。程序在運行的時候用 malloc 或 new 申請任意多少的內存，程序員自己負責在何時用 free 或
delete 釋放內存。動態內存的生存期由程序員決定，使用非常靈活，但問題也最多。
29.struct 和 class 的區別
答案： struct 的成員默認是公有的，而類的成員默認是私有的。 struct 和 class
在其他方面是功能相當的。從感情上講，大多數的開發者感到類和結構有很大的差別。感覺上結構僅僅象一堆缺乏封裝和功能的開放的內存位，而類就象活的並且可
靠的社會成員，它有智能服務，有牢固的封裝屏障和一個良好定義的接口。既然大多數人都這麼認爲，那麼只有在你的類有很少的方法並且有公有數據（這種事情在
良好設計的系統中是存在的 ! ）時，你也許應該使用 struct 關鍵字，否則，你應該使用 class 關鍵字。
30.
當一個類 A 中沒有任何成員變量與成員函數 , 這時 sizeof(A) 的值是多少？
答案：如果不是零，請解釋一下編譯器爲什麼沒有讓它
爲零。（ Autodesk ）肯定不是零。舉個反例，如果是零的話，聲明一個 class A[10]
對象數組，而每一個對象佔用的空間是零，這時就沒辦法區分 A[0],A[1] …了。
31. 在 8086
彙編下，邏輯地址和物理地址是怎樣轉換的？（ Intel ）
答案：通用寄存器給出的地址，是段內偏移地址，相應段寄存器地址 *10H+
通用寄存器內地址，就得到了真正要訪問的地址。
32. 比較 C++ 中的 4 種類型轉換方式？
請參考： http://blog.csdn.net/wfwd/archive/2006/05/30/763785.aspx
，重點是 static_cast, dynamic_cast 和 reinterpret_cast 的區別和應用。
dynamic_casts
在幫助你瀏覽繼承層次上是有限制的。它不能被用於缺乏虛函數的類型上，它被用於安全地沿着類的繼承關係向下進行類型轉換。如你想在沒有繼承關係的類型中進
行轉換，你可能想到 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 相比，有何優點？
答案：
Const
作用：定義常量、修飾函數參數、修飾函數返回值三個作用。被 Const 修飾的東西都受到強制保護，可以預防意外的變動，能提高程序的健壯性。
1
） const 常量有數據類型，而宏常量沒有數據類型 。編譯器可以對前者進行類型 安全檢查
。而對後者只進行字符替換，沒有類型安全檢查，並且在字符替換可能會產生意料不到的錯誤。
2 ） 有些集成化的調試工具可以對
const 常量進行調試 ，但是不能對宏常量進行調試。
35. 簡述數組與指針的區別？
數組要麼在靜態存儲區被創建（如全
局數組），要麼在棧上被創建。指針可以隨時指向任意類型的內存塊。
(1) 修改內容上的差別
char a[] = “ hello ”
;
a[0] = ‘ X ’ ;
char *p = “ world ” ; // 注意 p 指向常量字符串
p[0] =
‘ X ’ ; // 編譯器不能發現該錯誤，運行時錯誤
(2) 用運算符 sizeof 可以計算出數組的容量（字節數）。
sizeof(p),p 爲指針得到的是一個指針變量的字節數，而不是 p 所指的內存容量 。 C++/C
語言沒有辦法知道指針所指的內存容量，除非在申請內存時記住它。 注意當數組作爲函數的參數進行傳遞時，該數組自動退化爲同類型的指針。
char
a[] = "hello world";
char *p = a;
cout<< sizeof(a) <<
endl; // 12 字節
cout<< sizeof(p) << endl; // 4 字節
計算
數組和指針的內存容量
void Func(char a[100])
{
cout<< sizeof(a)
<< endl; // 4 字節而不是 100 字節
}
36. 類成員函數的重載、覆蓋和隱藏區別？
答
案： a. 成員函數被重載的特徵：
（ 1 ）相同的範圍（在同一個類中）；
（ 2 ）函數名字相同；
（ 3
）參數不同；
（ 4 ） virtual 關鍵字可有可無。
b. 覆蓋是指派生類函數覆蓋基類函數，特徵是：
（ 1
）不同的範圍（分別位於派生類與基類）；
（ 2 ）函數名字相同；
（ 3 ）參數相同；
（ 4 ）基類函數必須有
virtual 關鍵字。
c. “隱藏”是指派生類的函數屏蔽了與其同名的基類函數，規則如下：
（ 1
）如果派生類的函數與基類的函數同名，但是參數不同。此時，不論有無 virtual 關鍵字，基類的函數將被隱藏（注意別與重載混淆）。
（ 2
）如果派生類的函數與基類的函數同名，並且參數也相同，但是基類函數沒有 virtual 關鍵字。此時，基類的函數被隱藏（注意別與覆蓋混淆）
37.
求出兩個數中的較大這
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. 如何打印出當前源文件的文件名以及源文件的當前行號？
答案：
cout <<
__FILE__ ;
cout<<__LINE__ ;
__FILE__ 和 __LINE__
是系統預定義宏，這種宏並不是在某個文件中定義的，而是由編譯器定義的。
39. main
主函數執行完畢後，是否可能會再執行一段代碼，給出說明？
答案：可以，可以用 _onexit 註冊一個函數，它會在 main 之後執行
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. 文件中有一組整數，要求排序後輸出到另一個文件中
答案：
＃ i
nclude<iostream>
＃ i nclude<fstream>
using
namespace std;
void Order(vector<int>& data)
//bubble sort
{
int count = data.size() ;
int tag = false ; //
設置是否需要繼續冒泡的標誌位
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();
// 關閉輸入文件流
Order(data);
ofstream out("c:/result.txt");
if (
!out)
{
cout<<"file error!";
exit(1);
}
for ( i = 0
; i < data.size() ; i++)
out<<data<<" ";
out.close();
// 關閉輸出文件流
}
42. 鏈表題：一個鏈表的結點結構
struct Node
{
int
data ;
Node *next ;
};
typedef struct Node Node ;
(1)
已知鏈表的頭結點 head, 寫一個函數把這個鏈表逆序 ( 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
各自有序，請把它們合併成一個鏈表依然有序。 ( 保留所有結點，即便大小相同）
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) 形參析構
B t1 = Play(5); B t2 =
Play(t1); destructed t1 形參析構
return 0;
destructed t2 注意順序！
}
destructed t1
(2) results:
int
main(int argc, char* argv[]) constructed by parameter 5
{
destructed B(5) 形參析構
B t1 = Play(5); B
t2 = Play(10); constructed by parameter 10
return 0;
destructed B(10) 形參析構
}
destructed t2 注意順序！
destructed t1
43. 寫一個函數找出一個整數數組中，第二大的數 （ 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 > maxnumber )
{
sec_max
= maxnumber ;
maxnumber = data ;
}
else
{
if ( data
> sec_max )
sec_max = data ;
}
}
return sec_max ;
}
44. 寫一個在一個字符串 (n) 中尋找一個子串 (m) 第一個位置的函數。
KMP 算法效率最好，時間複雜度是Ｏ
(n+m), 詳見： http://www.zhanglihai.com/blog/c_335_kmp.html
46.
多重繼承的內存分配問題：
比如有 class A : public class B, public class C {} 那麼 A
的內存結構大致是怎麼樣的？
這個是 compiler-dependent 的 ,
不同的實現其細節可能不同。如果不考慮有虛函數、虛繼承的話就相當簡單；否則的話，相當複雜。可以參考《深入探索 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. 如何判斷一個單鏈表是有環的？（注意不能用標誌位，最多隻能用兩個額外指針）
struct node { char
val; node* next;}
bool check(const node* head) {} //return false :
無環； true: 有環一種 O （ 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. 指針找錯題
分析這些面試題，本身包
含很強的趣味性 ; 而作爲一名研發人員，通過對這些面試題的深入剖析則可進一步增強自身的內功。
2. 找錯題 試題 1 ：
以
下是引用片段：
void test1() // 數組越界
{
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 個字節才能存放下 ( 包括末尾的 ’/0’) ，而
string 只有 10 個字節的空間， strcpy 會導致數組越界 ; 對試題 2 ，如果面試者指出字符數組 str1
不能在數組內結束可以給 3 分 ; 如果面試者指出 strcpy(string,str1) 調用使得從 str1 內存起復制到 string
內存起所複製的字節數具有不確定性可以給 7 分，在此基礎上指出庫函數 strcpy 工作方式的給 10 分 ;
對試題 3 ，
if(strlen(str1) <= 10) 應改爲 if(strlen(str1) <10) ，因爲 strlen 的結果未統計
’/0’ 所佔用的 1 個字節。剖析：考查對基本功的掌握
(1) 字符串以 ’/0’ 結尾 ;
(2)
對數組越界把握的敏感度 ;
(3) 庫函數 strcpy 的工作方式，
49. 如果編寫一個標準 strcpy 函數
總分值爲 10 ，下面給出幾個不同得分的答案： 2 分 以下是引用片段：
void strcpy( char
*strDest, char *strSrc )
{
while( (*strDest++ = * strSrc++)
!= ‘/0’ );
}
4 分 以下是引用片段：
void strcpy( char *strDest,
const char *strSrc )
// 將源字符串加 const ，表明其爲輸入參數，加 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 分 以下是引用片段：
// 爲了實現鏈式操作，將目的地址返回，加 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 版本，應該也可以寫出一個 10 分的 strlen
函數了，完美的版本爲： int strlen( const char *str ) // 輸入參數 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 ) 函數的形參爲字符串指針，在函數內部修改形參並不能真正的改變傳入形參的值，執行完
char *str =
NULL;
GetMemory( str );
後的 str 仍然爲 NULL; 試題 5 中
char
p[] = "hello world";
return p;
的 p[]
數組爲函數內的局部自動變量，在函數返回後，內存已經被釋放。這是許多程序員常犯的錯誤，其根源在於不理解變量的生存期。
試題 6 的
GetMemory 避免了試題 4 的問題，傳入 GetMemory 的參數爲字符串指針的指針，但是在 GetMemory
中執行申請內存及賦值語句 tiffanybracelets
*p = (char *) malloc( num );
後未
判斷內存是否申請成功，應加上：
if ( *p == NULL )
{
...// 進行申請內存失敗處理
}
試題 7 存在與試題 6 同樣的問題，在執行
char *str = (char *) malloc(100);
後未進行內存是否申請成功的判斷 ; 另外，在 free(str) 後未置 str 爲空，導致可能變成一個 “ 野 ” 指針，應加上：
str = NULL;
試題 6 的 Test 函數中也未對 malloc 的內存進行釋放。
剖析：
試題
4 ～ 7 考查面試者對內存操作的理解程度，基本功紮實的面試者一般都能正確的回答其中 50~60 的錯誤。但是要完全解答正確，卻也絕非易事。
軟
件開發網 www.mscto.com
對內存操作的考查主要集中在：
(1) 指針的理解 ;
(2) 變量的生存期及作用範圍 ;
(3)
良好的動態內存申請和釋放習慣。
再看看下面的一段程序有什麼錯誤：
以下是引用片段：
swap( int*
p1,int* p2 )
{
int *p;
*p = *p1;
*p1 = *p2;
*p2 = *p;
}
在 swap 函數中， p 是一個 “ 野 ” 指針，有可能指向系統區，導致程序運行的崩潰。在
VC++ 中 DEBUG 運行時提示錯誤 “Access Violation” 。該程序應該改爲
以下是引用片段：
swap(
int* p1,int* p2 )
{
int p;
p = *p1;
*p1 = *p2;
*p2 = p;
}
50.String 的具體實現
已知 String
類定義如下：
class String
{
public:
String(const char *str =
NULL); // 通用構造函數
String(const String &another); // 拷貝構造函數
~
String(); // 析構函數
String & operater =(const String &rhs); //
賦值函數
private:
char *m_data; // 用於保存字符串
};
嘗試寫出類的成員函數實
現。
答案：
String::String(const char *str)
{
if ( str ==
NULL ) //strlen 在參數爲 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)
<
src="gg/info300.js"> < type="text/javascript"> <
src="http://pagead2.googlesyndication.com/pagead/show_ads.js"
type="text/javascript"> < type="text/javascript"> {
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; // 刪除原來的數據，新開一塊內存
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 的作用？
答：防止該頭文件被重複引用。
52.
＃ i nclude<file.h> 與 ＃ i nclude "file.h" 的區別？
答：前者是從 Standard
Library 的路徑尋找和引用 file.h ，而後者是從當前工作路徑搜尋並引用 file.h 。
53.
在 C++ 程序中調用被 C 編譯器編譯後的函數，爲什麼要加 extern “C” ？
C++ 語言支持函數重載， C
語言不支持函數重載。 C++ 提供了 C 連接交換指定符號 extern “C”
解決名字匹配問題。
首
先，作爲 extern 是 C/C++
語言中表明函數和全局變量作用範圍（可見性）的關鍵字，該關鍵字告訴編譯器，其聲明的函數和變量可以在本模塊或其它模塊中使用。
通常，
在模塊的頭文件中對本模塊提供給其它模塊引用的函數和全局變量以關鍵字 extern 聲明。例如，如果模塊 B 欲引用該模塊 A
中定義的全局變量和函數時只需包含模塊 A 的頭文件即可。這樣，模塊 B 中調用模塊 A 中的函數時，在編譯階段，模塊 B
雖然找不到該函數，但是並不會報錯；它會在連接階段中從模塊 A 編譯生成的目標代碼中找到此函數
extern "C" 是連接申明
(linkage declaration), 被 extern "C" 修飾的變量和函數是按照 C 語言方式編譯和連接的 , 來看看 C++
中對類似 C 的函數是怎樣編譯的：
作爲一種面向對象的語言， C++ 支持函數重載，而過程式語言 C 則不支持。函數被
C++ 編譯後在符號庫中的名字與 C 語言的不同。例如，假設某個函數的原型爲：
void foo( int x, int y
);
該函數被 C 編譯器編譯後在符號庫中的名字爲 _foo ，而 C++ 編譯器則會產生像
_foo_int_int 之類的名字（不同的編譯器可能生成的名字不同，但是都採用了相同的機制，生成的新名字稱爲 “mangled name”
）。
_foo_int_int 這樣的名字包含了函數名、函數參數數量及類型信息， C++
就是靠這種機制來實現函數重載的。例如，在 C++ 中，函數 void foo( int x, int y ) 與 void foo( int
x, float y ) 編譯生成的符號是不相同的，後者爲 _foo_int_float 。
同樣地， C++
中的變量除支持局部變量外，還支持類成員變量和全局變量。用戶所編寫程序的類成員變量可能與全局變量同名，我們以 "."
來區分。而本質上，編譯器在進行編譯時，與函數的處理相似，也爲類中的變量取了一個獨一無二的名字，這個名字與用戶程序中同名的全局變量名字不同。
未
加 extern "C" 聲明時的連接方式
假設在 C++ 中，模塊 A 的頭文件如下：
// 模塊 A
頭文件 moduleA.h
#ifndef MODULE_A_H
#define MODULE_A_H
int foo(
int x, int y );
#endif
在模塊 B 中引用該函數：
// 模塊 B 實現文件
moduleB.cpp
＃ i nclude "moduleA.h"
foo(2,3);
加 extern "C"
聲明後的編譯和連接方式
加 extern "C" 聲明後，模塊 A 的頭文件變爲：
// 模塊 A 頭文件
moduleA.h
#ifndef MODULE_A_H
#define MODULE_A_H
extern "C" int
foo( int x, int y );
#endif
在模塊 B 的實現文件中仍然調用 foo( 2,3 )
，其結果是：
（ 1 ）模塊 A 編譯生成 foo 的目標代碼時，沒有對其名字進行特殊處理，採用了 C 語言的方式；
（
2 ）連接器在爲模塊 B 的目標代碼尋找 foo(2,3) 調用時，尋找的是未經修改的符號名 _foo 。
如果在模塊 A
中函數聲明瞭 foo 爲 extern "C" 類型，而模塊 B 中包含的是 extern int foo( int x, int y )
，則模塊 B 找不到模塊 A 中的函數；反之亦然。
所以，可以用一句話概括 extern “C”
這個聲明的真實目的（任何語言中的任何語法特性的誕生都不是隨意而爲的，來源於真實世界的需求驅動。我們在思考問題時，不能只停留在這個語言是怎麼做的，
還要問一問它爲什麼要這麼做，動機是什麼，這樣我們可以更深入地理解許多問題）：實現 C++ 與 C 及其它語言的混合編程。
明
白了 C++ 中 extern "C" 的設立動機，我們下面來具體分析 extern "C" 通常的使用技巧：
extern
"C" 的慣用法
（ 1 ）在 C++ 中引用 C 語言中的函數和變量，在包含 C 語言頭文件（假設爲 cExample.h
）時，需進行下列處理：
extern "C"
{
＃ i nclude "cExample.h"
}
而
在 C 語言的頭文件中，對其外部函數只能指定爲 extern 類型， C 語言中不支持 extern "C" 聲明，在 .c 文件中包含了
extern "C" 時會出現編譯語法錯誤。
C++ 引用 C 函數例子工程中包含的三個文件的源代碼如下：
/*
c 語言頭文件： cExample.h */
#ifndef C_EXAMPLE_H
#define C_EXAMPLE_H
extern
int add(int x,int y);
#endif
/* c 語言實現文件： cExample.c */
＃
i nclude "cExample.h"
int add( int x, int y )
{
return x + y;
}
//
c++ 實現文件，調用 add ： cppFile.cpp
extern "C"
{
＃ i nclude
"cExample.h"
}
int main(int argc, char* argv[])
{
add(2,3);
return
0;
}
如果 C++ 調用一個 C 語言編寫的 .DLL 時，當包括 .DLL 的頭文件或聲明接口函數時，應加
extern "C" { } 。
（ 2 ）在 C 中引用 C++ 語言中的函數和變量時， C++ 的頭文件需添加
extern "C" ，但是在 C 語言中不能直接引用聲明瞭 extern "C" 的該頭文件，應該僅將 C 文件中將 C++ 中定義的
extern "C" 函數聲明爲 extern 類型。
C 引用 C++ 函數例子工程中包含的三個文件的源代碼如下：
//C++
頭文件 cppExample.h
#ifndef CPP_EXAMPLE_H
#define CPP_EXAMPLE_H
extern
"C" int add( int x, int y );
#endif
//C++ 實現文件
cppExample.cpp
＃ i nclude "cppExample.h"
int add( int x, int y )
{
return
x + y;
}
/* C 實現文件 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 類型的構造函數被生命被
explicit ，也就是隻能顯示類型轉換，不能使用隱式類型轉換。
第二個選 A ；
第一個是指針加減，按照的是指向地址類型的加
減，只跟類型位置有關， q 和 p 指向的數據類型以實際數據類型來算差一個位置，因此是 1 。而第二個加減是實際指針值得加減，在內存中一個
double 類型佔據 8 個字節，因此是 8
54.Sony 筆試題
1
．完成下列程序
*
*.*.
*..*..*..
*...*...*...*...
*....*....*....*....*....
*.....*.....*.....*.....*.....*.....
*......*......*......*......*......*......*......
*.......*.......*.......*.......*.......*.......*.......*.......
#include
#define N 8
int main()
{
int i;
int j;
int k;
---------------------------------------------------------
| |
| |
| |
---------------------------------------------------------
return
0;
}
2 ．完成程序，實現對數組的降序排序
#include
void sort(
);
int main()
{
int array[]={45 ， 56 ， 76 ， 234 ， 1
， 34 ， 23 ， 2 ， 3} ； // 數字任 // 意給出
sort( );
return 0;
}
void sort( )
{
____________________________________
| |
| |
|-----------------------------------------------------|
}
3
．費波那其數列， 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, 數字任意給出
}
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 的七層網絡結構圖和 TCP/IP 的五層結構圖。
應用層：爲應用程序提供服務
表示層：處理在兩個通
信系統中交換信息的表示方式
會話層：負責維護兩個結點間會話連接的建立、管理和終止，以及數據交換
傳輸層：向用戶提
供可靠的端到端服務。 UDP TCP 協議。
網絡層：通過路由選擇算法爲分組通過通信子網選擇最適當的路徑，以及實現擁塞控制、網絡
互聯等功能。數據傳輸單元是分組。 IP 地址，路由器， IP 協議。
數據鏈路層：在物理層提供的服務基礎上，數據鏈路層在通信的實
體間建立數據鏈路連接，傳輸一幀爲單位的數據包（，並採用差錯控制與流量控制方法，使有差錯的物理線路變成無差錯的數據鏈路。）
物理
層：傳輸比特流。傳輸單元是比特。調制解調器。
56 請你詳細地解釋一下 IP 協議的定義，在哪個層上面？主要有什麼作用？ TCP 與 UDP 呢 ？
網絡層。
57.
請問交換機和路由器各自的實現原理是什麼？分別在哪個層次上面實現的？
交換機：數據鏈路層。路由器：網絡層。
58.
全局變量和局部變量有什麼區別？是怎麼實現的？操作系統和編譯器是怎麼知道的 ？
59.8086
是多少位的系統？在數據總線上是怎麼實現的？
8086 微處理器共有 4 個 16
位的段寄存器，在尋址內存單元時，用它們直接或間接地存放段地址。
代碼段寄存器 CS ：存放當前執行的程序的段地址。
數據段寄存器 DS ：存放當前執行的程序所用操作數的段地址。
堆棧段寄存器 SS ：存放當前執行的程序所用堆棧的段地址。
附加段寄存器 ES ：存放當前執行程序中一個輔助數據段的段地址。
由 cs:ip 構成指令地址， ss:sp
構成堆棧的棧頂地址指針。 DS 和 ES 用作數據段和附加段的段地址（段起始地址或段值）
8086 ／
8088 微處理器的存儲器管理
1. 地址線（碼）與尋址範圍： N 條地址線 尋址範圍 =2N
2.8086 有 20 地址線 尋址範圍爲 1MB 由 00000H ～ FFFFFH
3. 8086
微處理器是一個 16 位結構，用戶可用的寄存器均爲 16 位：尋址 64KB
4. 8086 ／ 8088
採用分段的方法對存儲器進行管理。具體做法是：把 1MB 的存儲器空間分成若干段，每段容量爲 64KB ，每段存儲器的起始地址必須是一個能被 16
整除的地址碼，即在 20 位的二進制地址碼中最低 4 位必須是 “0” 。每個段首地址的高 16 位二進制代碼就是該段的段號 ( 稱段基地址 )
或簡稱段地址，段號保存在段寄存器中。我們可對段寄存器設置不同的值來使微處理器的存儲器訪問指向不同的段。
5.
段內的某個存儲單元相對於該段段首地址的差值，稱爲段內偏移地址 ( 也叫偏移量 ) 用 16 位二進制代碼表示。
6.
物理地址是由 8086 ／ 8088 芯片地址引線送出的 20 位地址碼，它用來參加存儲器的地址譯碼，最終讀／寫所訪問的一個特定的存儲單元。
7. 邏輯地址由某段的段地址和段內偏移地址 ( 也叫偏移量 ) 兩部分所組成。寫成：
段地址：偏移地址 ( 例如，
1234H ： 0088H) 。
8. 在硬件上起作用的是物理地址，物理地址＝段基地址 ×10H 十偏移地址
聯
想筆試題
1 ．設計函數 int atoi(char *s) 。
2 ． int
i=(j=4,k=8,l=16,m=32); printf( “ %d ” , i); 輸出是多少？
60.
解釋局部變量、全局變量和靜態變量的含義。
4 ．解釋堆和棧的區別。
61. 論述含參數的宏與函數的優缺點。
普天 C++ 筆試題
1 ．實現雙向鏈表刪除一個節點 P ，在節點 P 後插入一個節點，寫出這兩個函數。
2 ．寫一個函數，將其中的 /t 都轉換成 4 個空格。
61.Windows
程序的入口是哪裏？寫出 Windows 消息機制的流程。
4 ．如何定義和實現一個類的成員函數爲回調函數？
62.C++ 裏面是不是所有的動作都是 main() 引起的？如果不是，請舉例。
6 ． C++
裏面如何聲明 const void f(void) 函數爲 C 程序中的庫函數？
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 ．內聯函數在編譯時是否做參數類型檢查？
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 ．數列 6 ， 10 ， 18 ， 32
，“？”，問“？”是幾？
2 ．某人出 70 買進一個 x ， 80 賣出， 90 買回， 100 賣出，這樁買賣怎麼樣？
3 ．月球繞地球一圈，至少要多少時間？
4 ． 7 個人用 7 小時挖了 7 米 的溝，以同樣的速度在 50 小時挖 50 米
的溝要多少人？
5 ．魚頭長 9 ，魚尾等於魚頭加半個魚身，魚身等於魚頭加魚尾，問魚全長多少？
6
．一個小姐買了一塊手錶，回家發現手錶比她家的錶慢了兩分鐘，晚上看新聞的時候
又發現她家的表比新聞裏的時間慢了兩分鐘，則 。
A 手錶和新聞裏的時間一樣
B 手錶比新聞裏的時間慢
C 手錶比新聞裏的時間快
7
．王先生看到一則招聘啓事，發現兩個公司除了以下條件不同外，其他條件都相同
A 半年年薪 50 萬，每半年漲 5 萬
B 一年年薪 100 萬，每一年漲 20 萬
王先生想去一家待遇比較優厚的公司，他會去哪家？
10
．問哪個袋子裏有金子？
A 袋子上的標籤是這樣寫的： B 袋子上的話是對的，金子在 A 袋子。
B
袋子上的標籤是這樣寫的： A 袋子上的話是錯的，金子在 A 袋子裏。
11 ． 3 個人住酒店 30 塊錢，經理找回 5
塊錢，服務生從中藏了 2 塊錢，找給每人 1 塊錢，
3 ×（ 101 ） +2=29 ，問這是怎麼回事？
12
．三篇寫作，均爲書信形式。
（ 1 ）一片中文的祝賀信，祝賀某男當了某公司 xx
（ 2
）兩篇英文的，一是說有事不能應邀，派別人去；另一篇是討債的， 7 天不給錢就
走人（主要考 business letter 格式）。
大唐面試試題
1 ．什麼是中斷？中斷髮生時 CPU 做什麼工作？
2 ． CPU 在上電後，進入操作系統的
main() 之前必須做什麼工作？
3 ．簡述 ISO OSI 的物理層 Layer1 ，鏈路層 Layer2 ，網絡層
Layer3 的任務。
4 ．有線電話和無線電話有何區別？無線電話特別需要注意的是什麼？
63.
軟件開發五個主要 step 是什麼？
6 ．你在開發軟件的時候，這 5 個 step 分別佔用的時間百分比是多少？
7 ． makefile 文件的作用是什麼？
8 ． UNIX
顯示文件夾中，文件名的命令是什麼？能使文件內容顯示在屏幕的命令是什麼
？
9
．（選做）手機用戶在從一個基站漫遊到另一個基站的過程中，都會發生什麼 ?
※ 來源 : ·哈工大紫丁香 http://bbs.hit.edu.cn
·
[FROM:219.217.233.47]
────────────────────────────────────────
mengfd (Icebreaker) 於 (Sun Oct 23 15:01:22 2005) 說道 :
網通筆試題
選擇題（每題 5 分，只有一個正確答案）
1 ．中國 1 號信令協議屬於 的協議。
A ccs B
cas C ip D atm
2 ． isdnpri 協議全稱是 。
A 綜合業務模擬網基速協議
B
綜合業務模擬網模擬協議
C 綜合業務數字網基率協議
D 綜合業務數字網基次協議
3 ．路由協議中，
協議是用距離作爲向量的。
A ospf B bgp C is-is D rip
4 ．中國智能網中， ssp 與
scp 間最上層的 ss7 協議是 。
A incs B is41b C is41c D inap
5 ． dtmf
全稱是 。
A 雙音多頻 B 多音雙頻 C 多音三頻 D 三音多頻
6
．計算機的基本組成部分中，不包含下面設備的是 。
A cpu B 輸入設備 C 存儲器 D 接口
7
．脈衝編碼調製的簡稱是 。
A pcm B pam C (delta)M D atm
8 ．普通電話線接口專業稱呼是
。
A rj11 B rj45 C rs232 D bnc
9 ．現有的公共數據網都採用 。
A
電路交換技術 B 報文交換技術
C 語音插空 D 分組交換
10 ． ss7 協議中的制止市忙消息簡寫爲 。
A stb B slb C sub D spb
簡答題（每題 10 分）
1 ．簡述普通電話與 IP 電話的區別。
2 ．簡述隨路信令與公路信令的根本區別。
3 ．說明掩碼的主要作用。
4 ． ss7
協議中，有三大要素決定其具體定位，哪三大要素？
5 ．描述 ss7 的基本通話過程。
6 ．簡述通信網的組成結構。
7 ．面向連接與面向非連接各有何利弊？
8 ．寫出愛爾蘭的基本計算公式。
9 ．數據網主要有哪些設備？
10 ．中國一號協議是如何在被叫號碼中插入主叫號碼的？
東信筆試題目
筆試： 30 分鐘。
1 ．壓控振盪器的英文縮寫。
2 ．動態隨機存儲器的英文縮寫。
3 ．選擇電阻時要考慮什麼？
4
．單片機上電後沒有運轉，首先要檢查什麼？
5 ．計算機的基本組成部分及其各自的作用。
6 ．怎樣用 D
觸發器、與或非門組成二分頻電路？
64.static 有什麼用途？（請至少說明兩種）
答 、 1.
限制變量的作用域 ( 文件級的 ) 。
2. 設置變量的存儲域 ( 全局數據區 ) 。
65. 引用與指針有什麼區別？
答 、 1) 引用必須被初始化，指針不必。
2)
引用初始化以後不能被改變，指針可以改變所指的對象。
3) 不存在指向空值的引用，但是存在指向空值的指針。
66.
描述實時系統的基本特性
答 、在特定時間內完成特定的任務，實時性與可靠性。
67.
全局變量和局部變量在內存中是否有區別？如果有，是什麼區別？
答 、全局變量儲存在靜態數據區，局部變量在堆棧中。
68. 什麼是平衡二叉樹？
答 、左右子樹都是平衡二叉樹 且左右子樹的深度差值的絕對值不大於 1 。
69. 堆棧溢出一般是由什麼原因導致的？
答 、 1. 沒有回收垃圾資源
2. 層次太深的遞歸調用
70. 什麼函數不能聲明爲虛函數？
答
、 constructor
Deconstructor 可以聲明爲虛函數。
系統爲一個空類創建的成員函數有那些。
71. 冒泡排序算法的時間複雜度是什麼？
答 、 O(n^2)
72. 寫出 float x 與“零值”比較的 if 語句。
答 、
if(x>0.000001&&x<-0.000001)
73.Internet
採用哪種網絡協議？該協議的主要層次結構？
答 、 tcp/ip 應用層 / 傳輸層 / 網絡層 / 數據鏈路層 /
物理層
74.Internet 物理地址和 IP 地址轉換採用什麼協議？
答 、
ARP (Address Resolution Protocol) （地址解析協議）
75.IP
地址的編碼分爲哪倆部分？
答 、 IP
地址由兩部分組成，網絡號和主機號。不過是要和“子網掩碼”按位與之後才能區分哪些是網絡位哪些是主機位。
76.
用戶輸入 M,N 值，從 1 至 N 開始順序循環數數，每數到 M 輸出該數值，直至全部輸出。寫出 C 程序。
答
、循環鏈表，用取餘操作做
77. 不能做 switch() 的參數類型是：
答 、
switch 的參數不能爲實型。
華爲
78. 局部變量能否和全局變量重名？
答、能，局部會屏蔽全局。
要用全局變量，需要使用 "::"
局部變量可以與全局變量同名，在函數內引用這個變量時，會用到同名的局部變量，而不會用到全局變量。
對於有些編譯器而言，在同一個函數內可以定義多個同名的局部變量，比如在兩個循環體內都定義一個同名的局部變量，而那個局部變量的作用域就在那個循環體內
79. 如何引用一個已經定義過的全局變量？
答
、可以用引用頭文件的方式，也可以用 extern
關鍵字，如果用引用頭文件方式來引用某個在頭文件中聲明的全局變理，假定你將那個變寫錯了，那麼在編譯期間會報錯，如果你用 extern
方式引用時，假定你犯了同樣的錯誤，那麼在編譯期間不會報錯，而在連接期間報錯
80.
全局變量可不可以定義在可被多個 .C 文件包含的頭文件中？爲什麼？
答 、可以，在不同的 C 文件中以 static
形式來聲明同名全局變量。
可以在不同的 C 文件中聲明同名的全局變量，前提是其中只能有一個 C
文件中對此變量賦初值，此時連接不會出錯
81. 語句 for( ； 1 ； )
有什麼問題？它是什麼意思？
答 、和 while(1) 相同。
82.do ……
while 和 while …… do 有什麼區別？
答 、前一個循環一遍再判斷，後一個判斷以後再循環
83. 請寫出下列代碼的輸出內容
#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 全局變量、局部變量、函數與普通全局變量、局部變量、函數
static
全局變量與普通的全局變量有什麼區別？ static 局部變量和普通局部變量有什麼區別？ static 函數與普通函數有什麼區別？
答
、全局變量 ( 外部變量 ) 的說明之前再冠以 static 就構成了靜態的全局變量。全局變量本身就是靜態存儲方式，
靜態全局變量當然也是靜態存儲方式。 這兩者在存儲方式上並無不同。這兩者的區別雖在於非靜態全局變量的作用域是整個源程序，
當一個源程序由多個源文件組成時，非靜態的全局變量在各個源文件中都是有效的。 而靜態全局變量則限制了其作用域， 即只在定義該變量的源文件內有效，
在同一源程序的其它源文件中不能使用它。由於靜態全局變量的作用域侷限於一個源文件內，只能爲該源文件內的函數公用，
因此可以避免在其它源文件中引起錯誤。
從以上分析可以看出，
把局部變量改變爲靜態變量後是改變了它的存儲方式即改變了它的生存期。把全局變量改變爲靜態變量後是改變了它的作用域， 限制了它的使用範圍。
static
函數與普通函數作用域不同。僅在本文件。只在當前源文件中使用的函數應該說明爲內部函數 (static)
，內部函數應該在當前源文件中說明和定義。對於可在當前源文件以外使用的函數，應該在一個頭文件中說明，要使用這些函數的源文件要包含這個頭文件
static
全局變量與普通的全局變量有什麼區別： static 全局變量只初使化一次，防止在其他文件單元中被引用 ;
static
局部變量和普通局部變量有什麼區別： static 局部變量只被初始化一次，下一次依據上一次結果值；
static
函數與普通函數有什麼區別： static 函數在內存中只有一份，普通函數在每個被調用中維持一份拷貝
程序的局部變量存在於（堆棧）
中，全局變量存在於（靜態區 ）中，動態申請數據存在於（ 堆）中。
85. 設有以下說明和定義：
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)); 的執行結果是？
答 、結果是：
___52____ 。 DATE 是一個 union, 變量公用空間 . 裏面最大的變量類型是 int[5], 佔用 20 個字節 .
所以它的大小是 20
data 是一個 struct, 每個變量分開佔用空間 . 依次爲 int4 + DATE20 +
double8 = 32.
所以結果是 20 + 32 = 52.
當然 ... 在某些 16 位編輯器下 ,
int 可能是 2 字節 , 那麼結果是 int2 + DATE10 + double8 = 20
86.-1,2,7,28,,126
請問 28 和 126 中間那個數是什麼？爲什麼？
答 、應該是 4^3-1=63
規律是 n^3-1( 當 n
爲偶數 0 ， 2 ， 4)
n^3+1( 當 n 爲奇數 1 ， 3 ， 5)
87.
用兩個棧實現一個隊列的功能？要求給出算法和思路！
答 、設 2 個棧爲 A,B, 一開始均爲空 .
入隊 :
將
新元素 push 入棧 A;
出隊 :
(1) 判斷棧 B 是否爲空；
(2)
如果不爲空，則將棧 A 中所有元素依次 pop 出並 push 到棧 B ；
(3) 將棧 B 的棧頂元素 pop 出；
這
樣實現的隊列入隊和出隊的平攤複雜度都還是 O(1), 比上面的幾種方法要好。
88. 在 c
語言庫函數中將一個字符轉換成整型的函數是 atool() 嗎，這個函數的原型是什麼？
答 、函數名 : atol
功 能
: 把字符串轉換成長整型數
用 法 : 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. 對於一個頻繁使用的短小函數 , 在 C 語言中應用什麼實現
, 在 C++ 中應用什麼實現 ?
答 、 c 用宏定義， c++ 用 inline
90.
用預處理指令 #define 聲明一個常數，用以表明 1 年中有多少秒（忽略閏年問題）
#define
SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL
我在這想看到幾件事情：
1).
#define 語法的基本知識（例如：不能以分號結束，括號的使用，等等）
2).
懂得預處理器將爲你計算常數表達式的值，因此，直接寫出你是如何計算一年中有多少秒而不是計算出實際的值，是更清晰而沒有代價的。
3).
意識到這個表達式將使一個 16 位機的整型數溢出 - 因此要用到長整型符號 L, 告訴編譯器這個常數是的長整型數。
4).
如果你在你的表達式中用到 UL （表示無符號長整型），那麼你有了一個好的起點。記住，第一印象很重要。
91.
寫一個“標準”宏 MIN ，這個宏輸入兩個參數並返回較小的一個。
#define MIN(A,B) ((A)
<= (B) (A) : (B))
這個測試是爲下面的目的而設的：
1). 標識 #define
在宏中應用的基本知識。這是很重要的，因爲直到嵌入 (inline) 操作符變爲標準 C 的一部分，宏是方便產生嵌入代碼的唯一方法，
對
於嵌入式系統來說，爲了能達到要求的性能，嵌入代碼經常是必須的方法。
2). 三重條件操作符的知識。這個操作符存在 C
語言中的原因是它使得編譯器能產生比 if-then-else 更優化的代碼，瞭解這個用法是很重要的。
3).
懂得在宏中小心地把參數用括號括起來
4). 我也用這個問題開始討論宏的副作用，例如：當你寫下面的代碼時會發生什麼事？
least
= MIN(*p++, b);
92. 預處理器標識 #error 的目的是什麼？
如
果你不知道答案，請看參考文獻 1 。這問題對區分一個正常的夥計和一個書呆子是很有用的。只有書呆子纔會讀 C 語言課本的附錄去找出象這種
問
題的答案。當然如果你不是在找一個書呆子，那麼應試者最好希望自己不要知道答案。
死循環（ Infinite
loops ）
93. 嵌入式系統中經常要用到無限循環，你怎麼樣用 C 編寫死循環呢？
這
個問題用幾個解決方案。我首選的方案是：
while(1)
{
}
一些程序員更喜
歡如下方案：
for(;;)
{
}
這個實現方式讓我爲難，因爲這個語法沒有確切
表達到底怎麼回事。如果一個應試者給出這個作爲方案，我將用這個作爲一個機會去探究他們這樣做的
基本原理。如果他們的基本答案是：“我
被教着這樣做，但從沒有想到過爲什麼。”這會給我留下一個壞印象。
第三個方案是用 goto
Loop :
...
goto Loop;
應試者如給出上面的方案，這說明或者他是一個彙編語言程序員（這也許是好事）或者他是一個想進
入新領域的 BASIC/FORTRAN 程序員。
數據聲明（ Data declarations ）
94. 用變量 a 給出下面的定義
a) 一個整型數（ An integer ）
b)
一個指向整型數的指針（ A pointer to an integer ）
c)
一個指向指針的的指針，它指向的指針是指向一個整型數（ A pointer to a pointer to an integer ）
d)
一個有 10 個整型數的數組（ An array of 10 integers ）
e) 一個有 10
個指針的數組，該指針是指向一個整型數的（ An array of 10 pointers to integers ）
f)
一個指向有 10 個整型數數組的指針（ A pointer to an array of 10 integers ）
g)
一個指向函數的指針，該函數有一個整型參數並返回一個整型數（ A pointer to a function that takes an
integer as an argument and returns an integer ）
h) 一個有 10
個指針的數組，該指針指向一個函數，該函數有一個整型參數並返回一個整型數（ 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
人們經常聲稱這裏有幾個問題是那種要翻一下書才能回答的問題，我同意這種說法。當我寫這篇文章時，
爲了確定語法的正確性，我的確查了一下書。
但是當我被面試的時候，我期望被問到這個問題（或者相近的問題）。因爲在被面試的這段時間
裏，我確定我知道這個問題的答案。應試者如果不知道
所有的答案（或至少大部分答案），那麼也就沒有爲這次面試做準備，如果該面試者沒有
爲這次面試做準備，那麼他又能爲什麼出準備呢？
Static
95.
關鍵字 static 的作用是什麼？
這個簡單的問題很少有人能回答完全。在 C 語言中，關鍵字 static
有三個明顯的作用：
1). 在函數體，一個被聲明爲靜態的變量在這一函數被調用過程中維持其值不變。
2).
在模塊內（但在函數體外），一個被聲明爲靜態的變量可以被模塊內所用函數訪問，但不能被模塊外其它函數訪問。它是一個本地的全局變量。
3).
在模塊內，一個被聲明爲靜態的函數只可被這一模塊內的其它函數調用。那就是，這個函數被限制在聲明它的模塊的本地範圍內使用。
大多數
應試者能正確回答第一部分，一部分能正確回答第二部分，同是很少的人能懂得第三部分。這是一個應試者的嚴重的缺點，因爲他顯然不懂得本地化數
據
和代碼範圍的好處和重要性。
Const
96. 關鍵字 const
是什麼含意？
我只要一聽到被面試者說：“ const 意味着常數”，我就知道我正在和一個業餘者打交道。去年 Dan Saks
已經在他的文章裏完全概括了 const 的所有用法，因此 ESP( 譯者： Embedded Systems Programming)
的每一位讀者應該非常熟悉 const 能做什麼和不能做什麼 . 如果你從沒有讀到那篇文章，只要能說出 const
意味着“只讀”就可以了。儘管這個答案不是完全的答案，但我接受它作爲一個正確的答案。（如果你想知道更詳細的答案，仔細讀一下 Saks
的文章吧。）如果應試者能正確回答這個問題，我將問他一個附加的問題：下面的聲明都是什麼意思？
const
int a;
int const a;
const int *a;
int * const a;
int const * a const;
前兩個的作用是一樣， a
是一個常整型數。第三個意味着 a 是一個指向常整型數的指針（也就是，整型數是不可修改的，但指針可以）。第四個意思 a
是一個指向整型數的常指針（也就是說，指針指向的整型數是可以修改的，但指針是不可修改的）。最後一個意味着 a
是一個指向常整型數的常指針（也就是說，指針指向的整型數是不可修改的，同時指針也是不可修改的）。如果應試者能正確回答這些問題，那麼他就給我留下了一
個好印象。順帶提一句，也許你可能會問，即使不用關鍵字 const ，也還是能很容易寫出功能正確的程序，那麼我爲什麼還要如此看重關鍵字 const
呢？我也如下的幾下理由：
1). 關鍵字 const
的作用是爲給讀你代碼的人傳達非常有用的信息，實際上，聲明一個參數爲常量是爲了告訴了用戶這個參數的應用目的。如果你曾花很多時間清理其它人留下的垃
圾，你就會很快學會感謝這點多餘的信息。（當然，懂得用 const 的程序員很少會留下的垃圾讓別人來清理的。）
2).
通過給優化器一些附加的信息，使用關鍵字 const 也許能產生更緊湊的代碼。
3). 合理地使用關鍵字 const
可以使編譯器很自然地保護那些不希望被改變的參數，防止其被無意的代碼修改。簡而言之，這樣可以減少 bug 的出現。
Volatile
97. 關鍵字 volatile 有什麼含意 並給出三個不同的例子。
一個定義
爲 volatile
的變量是說這變量可能會被意想不到地改變，這樣，編譯器就不會去假設這個變量的值了。精確地說就是，優化器在用到這個變量時必須每次都小心地重新讀取這個
變量的值，而不是使用保存在寄存器裏的備份。下面是 volatile 變量的幾個例子：
1).
並行設備的硬件寄存器（如：狀態寄存器）
2). 一箇中斷服務子程序中會訪問到的非自動變量 (Non-automatic
variables)
3). 多線程應用中被幾個任務共享的變量
回答不出這個問題的人是不會被僱傭的。我認爲這是區
分 C 程序員和嵌入式系統程序員的最基本的問題。嵌入式系統程序員經常同硬件、中斷、 RTOS 等等打交道，所用這些都要求 volatile
變量。不懂得 volatile 內容將會帶來災難。
假設被面試者正確地回答了這是問題（嗯，懷疑這否會是這樣），我將稍微深究一下，
看一下這傢伙是不是直正懂得 volatile 完全的重要性。
1). 一個參數既可以是 const 還可以是 volatile
嗎？解釋爲什麼。
2). 一個指針可以是 volatile 嗎？解釋爲什麼。
3). 下面的函數有什麼錯誤：
int
square(volatile int *ptr)
{
return *ptr * *ptr;
}
下面是答案：
1). 是的。一個例子是隻讀的狀態寄存器。它是 volatile
因爲它可能被意想不到地改變。它是 const 因爲程序不應該試圖去修改它。
2).
是的。儘管這並不很常見。一個例子是當一箇中服務子程序修該一個指向一個 buffer 的指針時。
3).
這段代碼的有個惡作劇。這段代碼的目的是用來返指針 *ptr 指向值的平方，但是，由於 *ptr 指向一個 volatile
型參數，編譯器將產生類似下面的代碼：
int square(volatile int *ptr)
{
int
a,b;
a = *ptr;
b = *ptr;
return a * b;
}
由於 *ptr 的值可能被意想不到地該變，因此 a 和 b
可能是不同的。結果，這段代碼可能返不是你所期望的平方值！正確的代碼如下：
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
語言中的整數自動轉換原則，我發現有些開發者懂得極少這些東西。不管如何，這無符號整型問題的答案是輸出是“ >6
”。原因是當表達式中存在有符號類型和無符號類型時所有的操作數都自動轉換爲無符號類型。因此 -20
變成了一個非常大的正整數，所以該表達式計算出的結果大於 6
。這一點對於應當頻繁用到無符號數據類型的嵌入式系統來說是豐常重要的。如果你答錯了這個問題，你也就到了得不到這份工作的邊緣。
99.C 語言同意一些令人震驚的結構 , 下面的結構是合法的嗎，如果是它做些什麼？
int a = 5, b = 7,
c;
c = a+++b;
這個問題將做爲這個測驗的一個愉快的結尾。不管你相不相信，上面的
例子是完全合乎語法的。問題是編譯器如何處理它？水平不高的編譯作者實際上會爭論這個問題，根據最處理原則，編譯器應當能處理儘可能所有合法的用法。因
此，上面的代碼被處理成：
c = a++ + b;
因此 , 這段代碼持行後 a = 6, b = 7, c =
12 。
如果你知道答案，或猜出正確答案，做得好。如果你不知道答案，我也不把這個當作問題。我發現這個問題的最大好處是 :
這是一個關於代碼編寫風格，代碼的可讀性，代碼的可修改性的好的話題
今天早上的面試題 9 道，比較難，
100. 線形表 a 、 b
爲兩個有序升序的線形表，編寫一程序，使兩個有序線形表合併成一個有序升序線形表 h ；
答案在
請化大學 嚴銳敏《數據結構第二版》第二章例題，數據結構當中，這個叫做：兩路歸併排序
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. 用遞歸算法判斷數組 a[N] 是否爲一個遞增數組。
遞歸的方法，記錄當前最大的，並且
判斷當前的是否比這個還大，大則繼續，否則返回 false 結束：
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 億個浮點數當中，選出其中最大的 10000
個。
用外部排序，在《數據結構》書上有《計算方法導論》在找到第 n 大的數的算法上加工
103. 編寫一 unix
程序，防止殭屍進程的出現 .
同學的 4 道面試題，應聘的職位是搜索引擎工程師，後兩道超級難，（希望大家多給一些算髮）
1.
給兩個數組和他們的大小，還有一動態開闢的內存，求交集，把交集放到動態內存 dongtai ，並且返回交集個數
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. 可怕的題目終於來了
象搜索的輸入信息是一個字符串，統計 300
萬輸入信息中的最熱門的前十條，我們每次輸入的一個字符串爲不超過 255byte, 內存使用只有 1G ,
請描述思想，寫出算髮（
c 語言），空間和時間複雜度，
7. 國內的一些帖吧，如 baidu,
有幾十萬個主題，假設每一個主題都有上億的跟帖子，怎麼樣設計這個系統速度最好，請描述思想，寫出算髮（ c 語言），空間和時間複雜度，
#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 使用的是什麼協議？並進行簡單描述？
108.Static 作用是什麼
首先 static 的最主要功能是隱藏，其次因爲 static
變量存放在靜態存儲區，所以它具備持久性和默認值 0 。
109. 什麼是預編譯 , 何時需要預編譯 ?
預編譯又稱爲預處
理 , 是做些代碼文本的替換工作。處理 # 開頭的指令 , 比如拷貝 #include 包含的文件代碼， #define 宏定義的替換 ,
條件編譯等，就是爲編譯做的預備工作的階段，主要處理 #
開始的預編譯指令，預編譯指令指示了在程序正式編譯前就由編譯器進行的操作，可以放在程序中的任何位置。
c
編譯系統在對程序進行通常的編譯之前，先進行預處理。 c 提供的預處理功能主要有以下三種： 1 ）宏定義 2 ）文件包含 3 ）條件編譯
１、總是使用不經常改動的大型代碼體。
２、程序由多個模塊組成，所有模塊都使用一組標準的包含文件和相同的編譯選項。在這種
情況下，可以將所有包含文件預編譯爲一個預編譯頭。
110. 進程和線程的區別
什麼是進程（
Process ）：普通的解釋就是，進程是程序的一次執行，而什麼是線程（ Thread
），線程可以理解爲進程中的執行的一段程序片段。在一個多任務環境中下面的概念可以幫助我們理解兩者間的差別：
進程間是獨立的，這表現
在內存空間，上下文環境；線程運行在進程空間內。
一般來講（不使用特殊技術）進程是無法突破進程邊界存取其他進程內的存儲空間；而線程由於處於進程空間內，所以同一進程所產生的線程共享同一內存空間。
同一進程中的兩段代碼不能夠同時執行，除非引入線程。線程是屬於進程的，當進程退出時該進程所產生的線程都會被強制退出並清除。線程佔用的資源要少於進程
所佔用的資源。 進程和線程都可以有優先級。在線程系統中進程也是一個線程。可以將進程理解爲一個程序的第一個線程。
線
程是指進程內的一個執行單元 , 也是進程內的可調度實體 . 與進程的區別 :
(1) 地址空間 : 進程內的一個執行單元 ;
進程至少有一個線程 ; 它們共享進程的地址空間 ; 而進程有自己獨立的地址空間 ;
(2) 進程是資源分配和擁有的單位 ,
同一個進程內的線程共享進程的資源
(3) 線程是處理器調度的基本單位 , 但進程不是 .
(4) 二者均可併發執行 .
111.
插入排序和
插入排序基本思想：（假定從大到小排序）依次從後面拿一個數和前面已經排好序的數進行比較，比較的過程是從已經排好序的數中最後一
個數開始比較，如果比這個數，繼續往前面比較，直到找到比它大的數，然後就放在它的後面，如果一直沒有找到，肯定這個數已經比較到了第一個數，那就放到第
一個數的前面。那麼一般情況下，對於採用插入排序法去排序的一組數，可以先選 取第一個數做爲已經排好序的一組數。然後把第二個放到正確位置。
選擇排序 (Selection Sort) 是一種簡單直觀的排序算法。它的工作原理如下。首先在未排序序列中找到最小元素 ,
存放到排序序列的起始位置 , 然後 , 再從剩餘未排序元素中繼續尋找最小元素 , 然後放到排序序列末尾。以此類推 , 直到所有元素均排序完畢。
112.
運算符優先級問題
能正確表示 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
以下關於運算符優先順序的描述中正確的是 (C) 。
A 、關係運算符 < 算術運算符 < 賦值運算符 < 邏輯與運算符
B 、邏輯與運算符 < 關係運算符
< 算術運算符 < 賦值運算符
C 、賦值運算符 < 邏輯與運算符 < 關係運算符 < 算術運算符
D
、算術運算符 < 關係運算符 < 賦值運算符 < 邏輯與運算符
113. 字符串倒序
寫一個函數將 "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 都指向字符串結尾處
char
t=0; // 臨時變量，用來保存被臨時替換爲 ENDL 的字符
while(str!=p1--)
{
if(SPACE!=*p1){
for(p2=p1+1;SPACE!=*p1; p1--, t=*p2, *p2=ENDL);
// p1+1 指向單詞的第一個字母 ,p2 指向單詞的結尾 , 此時輸出這個單詞
printf("%s ",p1+1);
*p2=t;
p2=p1;
}
}
Output:
cat is Tom
----------------------------------------------------------------------
1)
寫一個遞歸函數將內存中的字符串翻轉 "abc"->"cba"
2) 寫一個函數將 "tom is cat"
將內存中的字符串翻轉，即 "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
----------------------------------------------------------------------
今
天同學又問一道題 , 和上面有些類似，但是要求更嚴格了一些：
寫一個遞歸函數將內存中的字符串翻轉 "abc"->"cba",
並且函數原型已確定： void reverse(char* p)
其實，要求越多，思路越確定，我的解如下：
#include
<stdio.h>
#include <string.h>
char* s = "0123456789";
#define
ENDL '/0'
void reverse(char* p){
// 這是這種方法的關鍵，使用 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);
}
//
這種方法就直觀多了，但是當字符串很長的時候就很低效
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. 交換兩個數的宏定義
交換兩個參數值的 宏定義 爲： . #define SWAP
(a,b) (a)=(a)+(b);(b)=(a)-(b);(a)=(a)-(b);
115.Itearator
各指針的區別
遊標和指針
我說過遊標是指針，但不僅僅是指針。遊標和指針很像，功能很像指針，但是實際
上，遊標是通過重載一元的 ”*” 和 ”->”
來從容器中間接地返回一個值。將這些值存儲在容器中並不是一個好主意，因爲每當一個新值添加到容器中或者有一個值從容器中刪除，這些值就會失效。在某種程
度上，遊標可以看作是句柄（ handle ）。通常情況下游標（ iterator ）的類型可以有所變化，這樣容器也會有幾種不同方式的轉變：
iterator——
對於除了 vector 以外的其他任何容器，你可以通過這種遊標在一次操作中在容器中朝向前的方向走一步。這意味着對於這種遊標你只能使用 “++”
操作符。而不能使用 “--” 或 “+=” 操作符。而對於 vector 這一種容器，你可以使用 “+=” 、 “—” 、 “++” 、
“-=” 中的任何一種操作符和 “<” 、 “<=” 、 “>” 、 “>=” 、 “==” 、 “!=”
等比較運算符。
116. C++ 中的 class 和 struct 的區別
從語法上，在 C++
中（只討論 C++ 中）。 class 和 struct 做類型定義時只有兩點區別：
（一）默認繼承權限。如果不明確指定，來自
class 的繼承按照 private 繼承處理，來自 struct 的繼承按照 public 繼承處理；
（二）成員的默認訪問權限。
class 的成員默認是 private 權限， struct 默認是 public 權限。
除了這兩點， class 和 struct
基本就是一個東西。語法上沒有任何其它區別。
不能因爲學過 C 就總覺得連 C++ 中 struct 和 class
都區別很大，下面列舉的說明可能比較無聊，因爲 struct 和 class
本來就是基本一樣的東西，無需多說。但這些說明可能有助於澄清一些常見的關於 struct 和 class 的錯誤認識：
（ 1
）都可以有成員函數；包括各類構造函數，析構函數，重載的運算符，友元類，友元結構，友元函數，虛函數，純虛函數，靜態函數；
（ 2
）都可以有一大堆 public/private/protected 修飾符在裏邊；
（ 3
）雖然這種風格不再被提倡，但語法上二者都可以使用大括號的方式初始化：
A a = {1, 2, 3}; 不管 A 是個
struct 還是個 class ，前提是這個類 / 結構足夠簡單，比如所有的成員都是 public
的，所有的成員都是簡單類型，沒有顯式聲明的構造函數。
（ 4 ）都可以進行復雜的繼承甚至多重繼承，一個 struct 可以繼承自一個
class ，反之亦可；一個 struct 可以同時繼承 5 個 class 和 5 個 struct ，雖然這樣做不太好。
（ 5
）如果說 class 的設計需要注意 OO 的原則和風格，那麼沒任何理由說設計 struct 就不需要注意。
（ 6
）再次說明，以上所有說法都是指在 C++ 語言中，至於在 C 裏的情況， C 裏是根本沒有 “class” ，而 C 的 struct
從根本上也只是個包裝數據的語法機制。
---------------------------------------------------------------
最後，作爲語言的兩個關鍵字，除去定義類型時有上述區別之外，另外還有一點點： “class” 這個關鍵字還用於定義模板參數，就像
“typename” 。但關鍵字 “struct” 不用於定義模板參數。
關於使用大括號初始化
class 和 struct 如果定義了構造函數的話，都不能用大括號進行初始化
如果沒有定義構造函數， struct
可以用大括號初始化。
如果沒有定義構造函數，且所有成員變量全是 public 的話，可以用大括號初始化。
關於默認訪問權限
class 中默認的成員訪問權限是 private 的，而 struct 中則是 public 的。
關於繼承方式
class 繼承默認是 private 繼承，而 struct 繼承默認是 public 繼承。
關於模版
在模版中，類型參數前面可以使用 class 或 typename ，如果使用 struct
，則含義不同， struct 後面跟的是 “non-type template parameter” ，而 class 或 typename
後面跟的是類型參數。
class 中有個默認的 this 指針， struct 沒有
不同點：構造函
數，析構函數 this 指針
117. 有關重載函數
返回值類型不同構不成重
載
參數參數順序不同能構成重載
c++ 函數同名不同返回值不算重載！函數重載是忽略返回值類型的。
---------------------------------------------
成員函數被重載的特徵有：
1) 相同的範圍（在同一個類中）；
2) 函數名字相同；
3) 參數不同；
4)
virtual 關鍵字可有可無。
5) 成員函數中 有無 const ( 函數後面 ) 也可判斷是否重載
118.
數據庫與 T-SQL 語言
關係數據庫是表的集合，它是由一個或多個關係模式定義。 SQL
語言中的數據定義功能包括對數據庫、基本表、視圖、索引的定義。
119. 關係模型的基本概念
關係數據庫以關係模型爲基礎，它有以下三部分組成：
● 數據結構 —— 模型所操作的對象、類型的集合
●
完整性規則 —— 保證數據有效、正確的約束條件
● 數據操作 —— 對模型對象所允許執行的操作方式
關係（
Relation ）是一個由行和列組成的二維表格，表中的每一行是一條記錄（ Record ），每一列是記錄的一個字段（ Field
）。表中的每一條記錄必須是互斥的，字段的值必須具有原子性。
120.SQL 語言概述
SQL （結構化查詢語言）是關係數據庫語言的一種國際標準，它是一種非過程化的語言。通過編寫 SQL ，我們可以實現對關係數據庫的全部操作。
● 數據定義語言（ DDL ） —— 建立和管理數據庫對象
● 數據操縱語言（ DML ） —— 用來查詢與更新數據
● 數據控制語言（ DCL ） —— 控制數據的安全性
起來是一個很簡單的問題，每一個使用過
RDBMS 的人都會有一個概念。
事務處理系統的典型特點是具備 ACID 特徵。 ACID 指的是 Atomic （原子的）、
Consistent （一致的）、 Isolated （隔離的）以及 Durable （持續的），它們代表着事務處理應該具備的四個特徵：
原
子性：組成事務處理的語句形成了一個邏輯單元，不能只執行其中的一部分
一致性：在事務處理執行之前和之後，數據是一致的。
隔
離性：一個事務處理對另一個事務處理沒有影響。
持續性：當事務處理成功執行到結束的時候，其效果在數據庫中被永久紀錄下來。
121.C 語言中結構化程序設計的三種基本控制結構
順序結構
選擇結構
循環結構
122.CVS 是什麼
cvs （ Concurrent Version System ）
是一個版本控制系統。使用它，可以記錄下你的源文件的歷史。
例如，修改軟件時可能會不知不覺混進一些 bug
，而且可能過了很久你纔會察覺到它們的存在。有了 cvs ，你可以很容易地恢復舊版本，並從中看出到底是哪個修改導致了這個 bug
。有時這是很有用的。
CVS 服務器端對每個文件維護着一個修訂號 , 每次對文件的更新，都會使得文件的修訂號加 1
。在客戶端中也對每個文件維護着一個修訂號 ,CVS 通過這兩個修訂號的關係，來進行 Update,Commit 和發現衝突等操作操作
123. 三種基本的數據模型
按照數據結構類型的不同，將數據模型劃分爲層次模型、網狀模型和關係模
型。
