轉自http://blog.csdn.net/jingxuewang110/article/details/6789557/
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不是庫函數。
2.delete與 delete []區別
delete只會調用一次析構函數，而delete[]會調用每一個成員的析構函數。在More Effective C++中有更為詳細的解釋：“當delete操作符用於數組時，它為每個數組元素調用析構函數，然后調用operatordelete來釋放內存。”delete與New配套，delete []與new []配套
MemTest* mTest1=new MemTest[10];
MemTest* mTest2=new MemTest;
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就會認為指向的是單個對象，否則，它就會認為指向的是一個數組。
3.C和C++ 的共同點？不同之處？
4.繼承的優缺點。
類繼承是在編譯時刻靜態定義的，且可直接使用，類繼承可以較方便地改變父類的實現。但是類繼承也有一些不足之處。首先，因為繼承在編譯時刻就定義了，所以無法在運行時刻改變從父類繼承的實現。更糟的是，父類通常至少定義了子類的部分行為，父類的任何改變都可能影響子類的行為。如果繼承下來的實現不適合解決新的問題，則父類必須重寫或被其他更適合的類替換。這種依賴關系限制了靈活性並最終限制了復用性。
（待補充）
5.C++有哪些性質（面向對象特點）
封裝，繼承和多態。
在面向對象程序設計語言中，封裝是利用可重用成分構造軟件系統的特性，它不僅支持系統的可重用性，而且還有利於提高系統的可擴充性；消息傳遞可以實現發送一個通用的消息而調用不同的方法；封裝是實現信息隱蔽的一種技術，其目的是使類的定義和實現分離。
6.子類析構時要調用父類的析構函數嗎？
析構函數調用的次序是先派生類的析構后基類的析構，也就是說在基類的的析構調用的時候,派生類的信息已經全部銷毀了定義一個對象時先調用基類的構造函數、然后調用派生類的構造函數；析構的時候恰好相反：先調用派生類的析構函數、然后調用基類的析構函數JAVA無析構函數深拷貝和淺拷貝
7.多態，虛函數，純虛函數
多態：是對於不同對象接收相同消息時產生不同的動作。C++的多態性具體體現在運行和編譯兩個方面：
a.編譯時多態性：通過重載函數和運算符的重載實現
b 運行時多態性：通過虛函數實現。
虛函數：在基類中冠以關鍵字 virtual 的成員函數。 它提供了一種接口界面。允許在派生類中對基類的虛函數重新定義。也允許在基類中定義虛函數的實現。
純虛函數：是在基類中聲明的虛函數，它在基類中沒有定義，但要求任何派生類都要定義自己的實現方法。在基類中實現純虛函數的方法是在函數原型后加"=0"
virtual void funtion1()=0
純虛函數的作用：在基類中為其派生類保留一個函數的名字，以便派生類根據需要對它進行定義。作為接口而存在 純虛函數不具備函數的功能，一般不能直接被調用。
從基類繼承來的純虛函數，在派生類中仍是虛函數。如果一個類中至少有一個純虛函數，那么這個類被稱為抽象類（abstract class）。
抽象類中不僅包括純虛函數，也可包括虛函數。l抽象類必須用作派生其他類的基類，而不能用於直接創建對象實例。但仍可使用指向抽象類的指針支持運行時多態性。
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; ...}
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]…了。
32. 比較C++中的4種類型轉換方式？
重點是static_cast, dynamic_cast和reinterpret_cast的區別和應用。
dynamic_casts在幫助你瀏覽繼承層次上是有限制的。它不能被用於缺乏虛函數的類型上，它被用於安全地沿着類的繼承關系向下進行類型轉換。如你想在沒有繼承關系的類型中進行轉換，你可能想到static_cast
在類層次間進行上行轉換時，dynamic_cast和static_cast的效果是一樣的；
class B{
void func(B *pb){
在上面的代碼段中，如果pb指向一個D類型的對象，pd1和pd2是一樣的，並且對這兩個指針執行D類型的任何操作都是安全的；
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
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中include的是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編譯成C語言方式的目標代碼）
// c++實現文件，調用add：cppFile.cpp
extern "C"
{
＃i nclude "cExample.h"
}
int main(int argc, char* argv[])
{
add(2,3);
return 0;
}
（這里的extern "C" 聲明用於告訴連接器，連接到add函數的C語言方式的目標代碼）
如果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;
}
（如果沒有i nclude "cppExample.h"，因為這是cpp文件，編譯器就會將此處add編譯成C++語言方式的目標代碼，cppExample.cpp也可以寫成這樣：
//C++實現文件 cppExample.cpp
extern "C" int add( int x, int y )
{
return x + y;
}
而不i nclude "cppExample.h"，同樣實現將add編譯成C語言方式的目標代碼）
/* C實現文件 cFile.c
/* 這樣會編譯出錯：＃i nclude "cExample.h" */
extern int add( int x, int y )；
int main( int argc, char* argv[] )
{
add( 2, 3 );
return 0;
}
58.全局變量和局部變量有什么區別？是怎么實現的？操作系統和編譯器是怎么知道的 ？
全局變量的生命周期是整個程序運行的時間，而局部變量的生命周期則是局部函數或過程調用的時間段。其實現是由編譯器在編譯時采用不同內存分配方法。全局變量在main函數調用后，就開始分配，如果是靜態變量則是在main函數前就已經初始化了。而局部變量則是在用戶棧中動態分配的（還是建議看編譯原理中的活動記錄這一塊）
61.論述含參數的宏與函數的優缺點。
62.C++里面是不是所有的動作都是main()引起的？如果不是，請舉例。
4．如何定義和實現一個類的成員函數為回調函數？
5．解釋堆和棧的區別。
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;
}
64.static有什么用途？（請至少說明兩種）
答 、1.限制變量的作用域(文件級的)。
2.設置變量的存儲域(全局數據區)。
65.引用與指針有什么區別？
答 、1) 引用必須被初始化，指針不必。
2) 引用初始化以后不能被改變，指針可以改變所指的對象。
3) 不存在指向空值的引用，但是存在指向空值的指針。
67.全局變量和局部變量在內存中是否有區別？如果有，是什么區別？
答 、全局變量儲存在靜態數據區，局部變量在堆棧中。
69.堆棧溢出一般是由什么原因導致的？
答 、1.沒有回收垃圾資源
2.層次太深的遞歸調用
70.什么函數不能聲明為虛函數？
答 、constructor
Deconstructor 可以聲明為虛函數。
系統為一個空類創建的成員函數有那些。
72.寫出float x 與“零值”比較的if語句。
答 、if(x>0.000001&&x<-0.000001)
78.局部變量能否和全局變量重名？
答、能，局部會屏蔽全局。要用全局變量，需要使用"::"
局部變量可以與全局變量同名，在函數內引用這個變量時，會用到同名的局部變量，而不會用到全局變量。對於有些編譯器而言，在同一個函數內可以定義多個同名的局部變量，比如在兩個循環體內都定義一個同名的局部變量，而那個局部變量的作用域就在那個循環體內
79.如何引用一個已經定義過的全局變量？
答 、可以用引用頭文件的方式，也可以用extern關鍵字，如果用引用頭文件方式來引用某個在頭文件中聲明的全局變理，假定你將那個變寫錯了，那么在編譯期間會報錯，如果你用extern方式引用時，假定你犯了同樣的錯誤，那么在編譯期間不會報錯，而在連接期間報錯
80.全局變量可不可以定義在可被多個.C文件包含的頭文件中？為什么？
答 、可以，在不同的C文件中以static形式來聲明同名全局變量。
可以在不同的C文件中聲明同名的全局變量，前提是其中只能有一個C文件中對此變量賦初值，此時連接不會出錯
84.static 全局變量、局部變量、函數與普通全局變量、局部變量、函數
static全局變量與普通的全局變量有什么區別？static局部變量和普通局部變量有什么區別？static函數與普通函數有什么區別？
答 、全局變量(外部變量)的說明之前再冠以static 就構成了靜態的全局變量。全局變量本身就是靜態存儲方式， 靜態全局變量當然也是靜態存儲方式。 這兩者在存儲方式上並無不同。這兩者的區別雖在於非靜態全局變量的作用域是整個源程序， 當一個源程序由多個源文件組成時，非靜態的全局變量在各個源文件中都是有效的。 而靜態全局變量則限制了其作用域， 即只在定義該變量的源文件內有效， 在同一源程序的其它源文件中不能使用它。由於靜態全局變量的作用域局限於一個源文件內，只能為該源文件內的函數公用， 因此可以避免在其它源文件中引起錯誤。
從以上分析可以看出， 把局部變量改變為靜態變量后是改變了它的存儲方式即改變了它的生存期。把全局變量改變為靜態變量后是改變了它的作用域， 限制了它的使用范圍。
static函數與普通函數作用域不同。僅在本文件。只在當前源文件中使用的函數應該說明為內部函數(static)，內部函數應該在當前源文件中說明和定義。對於可在當前源文件以外使用的函數，應該在一個頭文件中說明，要使用這些函數的源文件要包含這個頭文件
static全局變量與普通的全局變量有什么區別：static全局變量只初使化一次，防止在其他文件單元中被引用;
static局部變量和普通局部變量有什么區別：static局部變量只被初始化一次，下一次依據上一次結果值；
static函數與普通函數有什么區別：static函數在內存中只有一份，普通函數在每個被調用中維持一份拷貝
程序的局部變量存在於（堆棧）中，全局變量存在於（靜態區 ）中，動態申請數據存在於（ 堆）中。
88.在c語言庫函數中將一個字符轉換成整型的函數是atol()嗎，這個函數的原型是什么？
答 、函數名: 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
92.預處理器標識#error的目的是什么？
如果你不知道答案，請看參考文獻1。這問題對區分一個正常的伙計和一個書呆子是很有用的。只有書呆子才會讀C語言課本的附錄去找出象這種
問題的答案。當然如果你不是在找一個書呆子，那么應試者最好希望自己不要知道答案。
死循環（Infinite loops）
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）
109.什么是預編譯,何時需要預編譯?
預編譯又稱為預處理,是做些代碼文本的替換工作。處理#開頭的指令,比如拷貝#include包含的文件代碼，#define宏定義的替換,條件編譯等，就是為編譯做的預備工作的階段，主要處理#開始的預編譯指令，預編譯指令指示了在程序正式編譯前就由編譯器進行的操作，可以放在程序中的任何位置。
c編譯系統在對程序進行通常的編譯之前，先進行預處理。c提供的預處理功能主要有以下三種：1）宏定義 2）文件包含 3）條件編譯
１、總是使用不經常改動的大型代碼體。
２、程序由多個模塊組成，所有模塊都使用一組標准的包含文件和相同的編譯選項。在這種情況下，可以將所有包含文件預編譯為一個預編譯頭。
110.進程和線程的區別
什么是進程（Process）：普通的解釋就是，進程是程序的一次執行，而什么是線程（Thread），線程可以理解為進程中的執行的一段程序片段。在一個多任務環境中下面的概念可以幫助我們理解兩者間的差別：
進程間是獨立的，這表現在內存空間，上下文環境；線程運行在進程空間內。 一般來講（不使用特殊技術）進程是無法突破進程邊界存取其他進程內的存儲空間；而線程由於處於進程空間內，所以同一進程所產生的線程共享同一內存空間。 同一進程中的兩段代碼不能夠同時執行，除非引入線程。線程是屬於進程的，當進程退出時該進程所產生的線程都會被強制退出並清除。線程占用的資源要少於進程所占用的資源。 進程和線程都可以有優先級。在線程系統中進程也是一個線程。可以將進程理解為一個程序的第一個線程。
線程是指進程內的一個執行單元,也是進程內的可調度實體.與進程的區別:
(1)地址空間:進程內的一個執行單元;進程至少有一個線程;它們共享進程的地址空間;而進程有自己獨立的地址空間;
(2)進程是資源分配和擁有的單位,同一個進程內的線程共享進程的資源
(3)線程是處理器調度的基本單位,但進程不是.
(4)二者均可並發執行.
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 (函數后面) 也可判斷是否重載
133.動態連接庫的兩種方式?
答：調用一個DLL中的函數有兩種方法：
1．載入時動態鏈接（load-time dynamic linking），模塊非常明確調用某個導出函數，使得他們就像本地函數一樣。這需要鏈接時鏈接那些函數所在DLL的導入庫，導入庫向系統提供了載入DLL時所需的信息及DLL函數定位。
2．運行時動態鏈接（run-time dynamic linking），運行時可以通過LoadLibrary或LoadLibraryEx函數載入DLL。DLL載入后，模塊可以通過調用GetProcAddress獲取DLL函數的出口地址，然后就可以通過返回的函數指針調用DLL函數了。如此即可避免導入庫文件了。