1.new、delete、malloc、free關係
delete會調用對象的析構函數,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操作符用於數組時，它爲每個數組元素調用析構函數，然後調用operator delete來釋放內存。”delete與new配套，delete []與new []配套
MemTest *mTest1=new MemTest[10];
MemTest *mTest2=new MemTest;
Int *pInt1=new int [10];
Int *pInt2=new int;
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++有哪些性質（面向對象特點）
封裝，繼承和多態。
4.子類析構時要調用父類的析構函數嗎？
析構函數調用的次序是先派生類的析構後基類的析構，也就是說在基類的的析構調用的時候,派生類的信息已經全部銷燬了。定義一個對象時先調用基類的構造函數、然後調用派生類的構造函數；析構的時候恰好相反：先調用派生類的析構函數、然後調用基類的析構函數。
5.多態，虛函數，純虛函數
多態：是對於不同對象接收相同消息時產生不同的動作。
C++的多態性具體體現在運行和編譯兩個方面：在程序運行時的多態性通過繼承和虛函數來體現；
在程序編譯時多態性體現在函數和運算符的重載上；
虛函數：在基類中冠以關鍵字 virtual 的成員函數。 它提供了一種接口界面。允許在派生類中對基類的虛函數重新定義。
純虛函數的作用：在基類中爲其派生類保留一個函數的名字，以便派生類根據需要對它進行定義。作爲接口而存在 純虛函數不具備函數的功能，一般不能直接被調用。
從基類繼承來的純虛函數，在派生類中仍是虛函數。如果一個類中至少有一個純虛函數，那麼這個類被稱爲抽象類（abstract class）。
抽象類中不僅包括純虛函數，也可包括虛函數。抽象類必須用作派生其他類的基類，而不能用於直接創建對象實例。但仍可使用指向抽象類的指針支持運行時多態性。
6.求下面函數的返回值（微軟）
int func(x)
{
int countx = 0;
while(x)
{
countx ++;
x = x&(x-1);
}
return countx;
}
假定x = 9999。 答案：8
思路：將x轉化爲2進制，看含有的1的個數。
7.什麼是“引用”？申明和使用“引用”要注意哪些問題？
答：引用就是某個目標變量的“別名”(alias)，對應用的操作與對變量直接操作效果完全相同。申明一個引用的時候，切記要對其進行初始化。引用聲明完畢後，相當於目標變量名有兩個名稱，即該目標原名稱和引用名，不能再把該引用名作爲其他變量名的別名。聲明一個引用，不是新定義了一個變量，它只表示該引用名是目標變量名的一個別名，它本身不是一種數據類型，因此引用本身不佔存儲單元，系統也不給引用分配存儲單元。不能建立數組的引用。
8.將“引用”作爲函數參數有哪些特點？
（1）傳遞引用給函數與傳遞指針的效果是一樣的。這時，被調函數的形參就成爲原來主調函數中的實參變量或對象的一個別名來使用，所以在被調函數中對形參變量的操作就是對其相應的目標對象（在主調函數中）的操作。
（2）使用引用傳遞函數的參數，在內存中並沒有產生實參的副本，它是直接對實參操作；而使用一般變量傳遞函數的參數，當發生函數調用時，需要給形參分配存儲單元，形參變量是實參變量的副本；如果傳遞的是對象，還將調用拷貝構造函數。因此，當參數傳遞的數據較大時，用引用比用一般變量傳遞參數的效率和所佔空間都好。
（3）使用指針作爲函數的參數雖然也能達到與使用引用的效果，但是，在被調函數中同樣要給形參分配存儲單元，且需要重複使用"*指針變量名"的形式進行運算，這很容易產生錯誤且程序的閱讀性較差；另一方面，在主調函數的調用點處，必須用變量的地址作爲實參。而引用更容易使用，更清晰。
9.在什麼時候需要使用“常引用”？
如果既要利用引用提高程序的效率，又要保護傳遞給函數的數據不在函數中被改變，就應使用常引用。常引用聲明方式：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 。
10.將“引用”作爲函數返回值類型的格式、好處和需要遵守的規則?
格式：類型標識符 &函數名（形參列表及類型說明）{ //函數體 }
好處：在內存中不產生被返回值的副本；（注意：正是因爲這點原因，所以返回一個局部變量的引用是不可取的。因爲隨着該局部變量生存期的結束，相應的引用也會失效，產生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;賦值操作符的返回值必須是一個左值，以便可以被繼續賦值。因此引用成了這個操作符的惟一返回值選擇。
＃include<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而導致錯誤。所以可選的只剩下返回一個對象了。
11、結構與聯合有和區別？
(1). 結構和聯合都是由多個不同的數據類型成員組成, 但在任何同一時刻, 聯合中只存放了一個被選中的成員（所有成員共用一塊地址空間）, 而結構的所有成員都存在（不同成員的存放地址不同）。
(2). 對於聯合的不同成員賦值, 將會對其它成員重寫, 原來成員的值就不存在了, 而對於結構的不同成員賦值是互不影響的。
12、試寫出程序結果：
int a=4;
int &f(int x)
{ a=a+x;
return a;
}
int main(void)
{ int t=5;
cout<<f(t)<<endl; a = 9
f(t)=20; a = 20
cout<<f(t)<<endl; t = 5,a = 20 a = 25
t=f(t); a = 30 t = 30
cout<<f(t)<<endl; } t = 60
}
13.重載（overload)和重寫(overwrited，有的書也叫做“覆蓋”）的區別？
常考的題目。從定義上來說：
重載：是指允許存在多個同名函數，而這些函數的參數表不同（或許參數個數不同，或許參數類型不同，或許兩者都不同）。
重寫：是指子類重新定義父類虛函數的方法。
從實現原理上來說：
重載：編譯器根據函數不同的參數表，對同名函數的名稱做修飾，然後這些同名函數就成了不同的函數（至少對於編譯器來說是這樣的）。如，有兩個同名函數：function func(p:integer):integer;和function func(p:string):integer;。那麼編譯器做過修飾後的函數名稱可能是這樣的：int_func、str_func。對於這兩個函數的調用，在編譯器間就已經確定了，是靜態的。也就是說，它們的地址在編譯期就綁定了（早綁定），因此，重載和多態無關！
重寫：和多態真正相關。當子類重新定義了父類的虛函數後，父類指針根據賦給它的不同的子類指針，動態的調用屬於子類的該函數，這樣的函數調用在編譯期間是無法確定的（調用的子類的虛函數的地址無法給出）。因此，這樣的函數地址是在運行期綁定的（晚綁定）。
14.有哪幾種情況只能用intialization list 而不能用assignment?
答案：當類中含有const、reference 成員變量；基類的構造函數都需要初始化表。
15. C++是不是類型安全的？
答案：不是。兩個不同類型的指針之間可以強制轉換（用reinterpret cast)。C#是類型安全的。
16. main 函數執行以前，還會執行什麼代碼？
答案：全局對象的構造函數會在main 函數之前執行。
17. 描述內存分配方式以及它們的區別?
1） 從靜態存儲區域分配。內存在程序編譯的時候就已經分配好，這塊內存在程序的整個運行期間都存在。例如全局變量，static 變量。
2） 在棧上創建。在執行函數時，函數內局部變量的存儲單元都可以在棧上創建，函數執行結束時這些存儲單元自動被釋放。棧內存分配運算內置於處理器的指令集。
3） 從堆上分配，亦稱動態內存分配。程序在運行的時候用malloc 或new 申請任意多少的內存，程序員自己負責在何時用free 或delete 釋放內存。動態內存的生存期由程序員決定，使用非常靈活，但問題也最多。
18.分別寫出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)
19.請說出const與#define 相比，有何優點？
答案：
const作用：定義常量、修飾函數參數、修飾函數返回值三個作用。被Const修飾的東西都受到強制保護，可以預防意外的變動，能提高程序的健壯性。
1） const 常量有數據類型，而宏常量沒有數據類型。編譯器可以對前者進行類型安全檢查。而對後者只進行字符替換，沒有類型安全檢查，並且在字符替換可能會產生意料不到的錯誤。
2） 有些集成化的調試工具可以對const 常量進行調試，但是不能對宏常量進行調試。
20.簡述數組與指針的區別？
數組要麼在靜態存儲區被創建（如全局數組），要麼在棧上被創建。指針是可以隨時指向任意類型的內存塊。
(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 字節
}
第21題： int (*s[10])(int) 表示的是什麼？
int (*s[10])(int) 函數指針數組，每個指針指向一個int func(int param)的函數。
第22題：棧內存與文字常量區
char str1[] = "abc";
char str2[] = "abc";
const char str3[] = "abc";
const char str4[] = "abc";
const char *str5 = "abc";
const char *str6 = "abc";
char *str7 = "abc";
char *str8 = "abc";
cout << ( str1 == str2 ) << endl;//0 分別指向各自的棧內存
cout << ( str3 == str4 ) << endl;//0 分別指向各自的棧內存
cout << ( str5 == str6 ) << endl;//1指向文字常量區地址相同
cout << ( str7 == str8 ) << endl;//1指向文字常量區地址相同
結果是：0 0 1 1
解答：str1,str2,str3,str4是數組變量，它們有各自的內存空間；而str5,str6,str7,str8是指針，它們指向相同的常量區域。
第23題：將程序跳轉到指定內存地址
要對絕對地址0x100000賦值，我們可以用(unsigned int*)0x100000 = 1234;那麼要是想讓程序跳轉到絕對地址是0x100000去執行，應該怎麼做？
*((void (*)( ))0x100000 ) ( );
首先要將0x100000強制轉換成函數指針,即:
(void (*)())0x100000
然後再調用它:
*((void (*)())0x100000)();
用typedef可以看得更直觀些:
typedef void(*)() voidFuncPtr;
*((voidFuncPtr)0x100000)();
第24題：int id[sizeof(unsigned long)];這個對嗎？爲什麼？
答案:正確 這個 sizeof是編譯時運算符，編譯時就確定了 ,可以看成和機器有關的常量。
第25題：引用與指針有什麼區別？
【參考答案】
1) 引用必須被初始化，指針不必。
2) 引用初始化以後不能被改變，指針可以改變所指的對象。
3) 不存在指向空值的引用，但是存在指向空值的指針。
第26題：const 與 #define 的比較 ，const有什麼優點?
【參考答案】
（1） const 常量有數據類型，而宏常量沒有數據類型。編譯器可以對前者進行類型安全檢查。而對後者只進行字符替換，沒有類型安全檢查，並且在字符替換可能會產生意料不到的錯誤（邊際效應） 。
（2） 有些集成化的調試工具可以對 const 常量進行調試，但是不能對宏常量進行調試。
第27題：複雜聲明
void * ( * (*fp1)(int))[10];
float (*(* fp2)(int,int,int))(int);
int (* ( * fp3)())[10]();
分別表示什麼意思？
【標準答案】
1.void * ( * (*fp1)(int))[10]; fp1是一個指針，指向一個函數，這個函數的參數爲int型，函數的返回值是一個指針，這個指針指向一個數組，這個數組有10個元素，每個元素是一個void*型指針。
2.float (*(* fp2)(int,int,int))(int); fp2是一個指針，指向一個函數，這個函數的參數爲3個int型，函數的返回值是一個指針，這個指針指向一個函數，這個函數的參數爲int型，函數的返回值是float型。
3.int (* ( * fp3)())[10](); fp3是一個指針，指向一個函數，這個函數的參數爲空，函數的返回值是一個指針，這個指針指向一個數組，這個數組有10個元素，每個元素是一個指針，指向一個函數，這個函數的參數爲空，函數的返回值是int型。
第28題：內存的分配方式有幾種?
【參考答案】
一、從靜態存儲區域分配。內存在程序編譯的時候就已經分配好，這塊內存在程序的整個運行期間都存在。例如全局變量。
二、在棧上創建。在執行函數時，函數內局部變量的存儲單元都可以在棧上創建，函數執行結束時這些存儲單元自動被釋放。棧內存分配運算內置於處理器的指令集中，效率很高，但是分配的內存容量有限。
三、從堆上分配，亦稱動態內存分配。程序在運行的時候用malloc或new申請任意多少的內存，程序員自己負責在何時用free或delete釋放內存。動態內存的生存期由我們決定，使用非常靈活，但問題也最多。
第29題：基類的析構函數不是虛函數，會帶來什麼問題？
【參考答案】派生類的析構函數用不上，會造成資源的泄漏。
第30題：全局變量和局部變量有什麼區別？是怎麼實現的？操作系統和編譯器是怎麼知道的？
【參考答案】
生命週期不同：
全局變量隨主程序創建和創建，隨主程序銷燬而銷燬；局部變量在局部函數內部，甚至局部循環體等內部存在，退出就不存在；
使用方式不同：通過聲明後全局變量程序的各個部分都可以用到；局部變量只能在局部使用；分配在棧區。
操作系統和編譯器通過內存分配的位置來知道的，全局變量分配在全局數據段並且在程序開始運行的時候被加載。局部變量則分配在堆棧裏面 。
計算機基礎知識
1. C/C++內存有哪幾種類型？
C中，內存分爲5個區：堆(malloc)、棧(如局部變量、函數參數)、程序代碼區（存放二進制代碼）、全局/靜態存儲區（全局變量、static變量）和常量存儲區（常量）。此外，C++中有自由存儲區（new）一說。
全局變量、static變量會初始化爲零，而堆和棧上的變量是隨機的，不確定的。
2. 堆和棧的區別？
1).堆存放動態分配的對象——即那些在程序運行時分配的對象，比如局部變量，其生存期由程序控制；
2).棧用來保存定義在函數內的非static對象，僅在其定義的程序塊運行時才存在；
3).靜態內存用來保存static對象，類static數據成員以及定義在任何函數外部的變量，static對象在使用之前分配，程序結束時銷燬；
4).棧和靜態內存的對象由編譯器自動創建和銷燬。
3. 堆和自由存儲區的區別？
總的來說，堆是C語言和操作系統的術語，是操作系統維護的一塊動態分配內存；自由存儲是C++中通過new與delete動態分配和釋放對象的抽象概念。他們並不是完全一樣。
從技術上來說，堆（heap）是C語言和操作系統的術語。堆是操作系統所維護的一塊特殊內存，它提供了動態分配的功能，當運行程序調用malloc()時就會從中分配，稍後調用free可把內存交還。而自由存儲是C++中通過new和delete動態分配和釋放對象的抽象概念，通過new來申請的內存區域可稱爲自由存儲區。基本上，所有的C++編譯器默認使用堆來實現自由存儲，也即是缺省的全局運算符new和delete也許會按照malloc和free的方式來被實現，這時藉由new運算符分配的對象，說它在堆上也對，說它在自由存儲區上也正確。
4. 程序編譯的過程？
程序編譯的過程中就是將用戶的文本形式的源代碼(c/c++)轉化成計算機可以直接執行的機器代碼的過程。主要經過四個過程：預處理、編譯、彙編和鏈接。具體示例如下。
一個hello.c的c語言程序如下。
#include <stdio.h>
int main()
{
printf("happy new year!\n");
return 0;
}
5. 計算機內部如何存儲負數和浮點數？
負數比較容易，就是通過一個標誌位和補碼來表示。
對於浮點類型的數據採用單精度類型（float）和雙精度類型(double)來存儲，float數據佔用32bit,double數據佔用64bit,我們在聲明一個變量float f= 2.25f的時候，是如何分配內存的呢？如果胡亂分配，那世界豈不是亂套了麼，其實不論是float還是double在存儲方式上都是遵從IEEE的規範的，float遵從的是IEEE R32.24 ,而double 遵從的是R64.53。更多可以參考浮點數表示。
無論是單精度還是雙精度在存儲中都分爲三個部分：
1). 符號位(Sign) : 0代表正，1代表爲負
2). 指數位（Exponent）:用於存儲科學計數法中的指數數據，並且採用移位存儲
3). 尾數部分（Mantissa）：尾數部分
其中float的存儲方式如下圖所示：
而雙精度的存儲方式如下圖:
6. 函數調用的過程？
如下結構的代碼，
int main(void)
{
...
d = fun(a, b, c);
cout<<d<<endl;
...
return 0;
}
調用fun()的過程大致如下：
main()========
1).參數拷貝（壓棧），注意順序是從右到左，即c-b-a；
2).保存d = fun(a, b, c)的下一條指令，即cout<<d<<endl（實際上是這條語句對應的彙編指令的起始位置）;
3).跳轉到fun()函數，注意，到目前爲止，這些都是在main()中進行的；
fun()=====
4).移動ebp、esp形成新的棧幀結構;
5).壓棧（push）形成臨時變量並執行相關操作;
6).return一個值;
7).出棧（pop）;
8).恢復main函數的棧幀結構;
9).返回main函數;
main()========
。。。
7. 左值和右值
不是很嚴謹的來說，左值指的是既能夠出現在等號左邊也能出現在等號右邊的變量(或表達式)，右值指的則是隻能出現在等號右邊的變量(或表達式)。舉例來說我們定義的變量 a 就是一個左值，而malloc返回的就是一個右值。或者左值就是在程序中能夠尋值的東西，右值就是一個具體的真實的值或者對象，沒法取到它的地址的東西(不完全準確)，因此沒法對右值進行賦值，但是右值並非是不可修改的，比如自己定義的class, 可以通過它的成員函數來修改右值。
8. 什麼是內存泄漏？面對內存泄漏和指針越界，你有哪些方法？你通常採用哪些方法來避免和減少這類錯誤？
用動態存儲分配函數動態開闢的空間，在使用完畢後未釋放，結果導致一直佔據該內存單元即爲內存泄露。
1). 使用的時候要記得指針的長度.
2). malloc的時候得確定在那裏free.
3). 對指針賦值的時候應該注意被賦值指針需要不需要釋放.
4). 動態分配內存的指針最好不要再次賦值.
5). 在C++中應該優先考慮使用智能指針.
C v.s. C++
1. C和C++的區別？
1). C++是C的超集;
2). C是一個結構化語言，它的重點在於算法和數據結構。C程序的設計首要考慮的是如何通過一個過程，對輸入（或環境條件）進行運算處理得到輸出（或實現過程（事務）控制），而對於C++，首要考慮的是如何構造一個對象模型，讓這個模型能夠契合與之對應的問題域，這樣就可以通過獲取對象的狀態信息得到輸出或實現過程（事務）控制。
2. int fun() 和 int fun(void)的區別?
這裏考察的是c 中的默認類型機制。
在c中，int fun() 會解讀爲返回值爲int(即使前面沒有int，也是如此，但是在c++中如果沒有返回類型將報錯)，輸入類型和個數沒有限制， 而int fun(void)則限制輸入類型爲一個void。
在c++下，這兩種情況都會解讀爲返回int類型，輸入void類型。
3. const 有什麼用途
主要有三點：
1).定義只讀變量，或者常量（只讀變量和常量的區別參考下面一條）;
2).修飾函數的參數和函數的返回值;
3).修飾函數的定義體，這裏的函數爲類的成員函數，被const修飾的成員函數代表不能修改成員變量的值，因此const成員函數只能調用const成員函數；
4).只讀對象。只讀對象只能調用const成員函數。
class Screen {
public:
const char cha； //const成員變量
char get() const; //const成員函數
};
const Screen screen； //只讀對象
4. 在C中用const 能定義真正意義上的常量嗎？C++中的const呢？
不能。c中的const僅僅是從編譯層來限定，不允許對const 變量進行賦值操作，在運行期是無效的，所以並非是真正的常量（比如通過指針對const變量是可以修改值的），但是c++中是有區別的，c++在編譯時會把const常量加入符號表，以後（仍然在編譯期）遇到這個變量會從符號表中查找，所以在C++中是不可能修改到const變量的。
補充：
1）. c中的局部const常量存儲在棧空間，全局const常量存在只讀存儲區，所以全局const常量也是無法修改的，它是一個只讀變量。
2）. 這裏需要說明的是，常量並非僅僅是不可修改，而是相對於變量，它的值在編譯期已經決定，而不是在運行時決定。
3）.c++中的const 和宏定義是有區別的，宏是在預編譯期直接進行文本替換，而const發生在編譯期，是可以進行類型檢查和作用域檢查的。
4）.c語言中只有enum可以實現真正的常量。
5). c++中只有用字面量初始化的const常量會被加入符號表，而變量初始化的const常量依然只是只讀變量。
6). c++中const成員爲只讀變量，可以通過指針修改const成員的值，另外const成員變量只能在初始化列表中進行初始化。
下面我們通過代碼來看看區別。
同樣一段代碼，在c編譯器下，打印結果爲*pa = 4， 4
在c++編譯下打印的結果爲 *pa = 4， 8
int main(void)
{
const int a = 8;
int *pa = (int *)&a;
*pa = 4;
printf("*pa = %d, a = %d", *pa, a);
return 0;
}
另外值得一說的是，由於c++中const常量的值在編譯期就已經決定，下面的做法是OK的，但是c中是編譯通不過的。
int main(void)
{
const int a = 8;
const int b = 2;
int array[a+b] = {0};
return 0;
}
5. 宏和內聯（inline）函數的比較？
1). 首先宏是C中引入的一種預處理功能；
2). 內聯（inline）函數是C++中引用的一個新的關鍵字；C++中推薦使用內聯函數來替代宏代碼片段；
3). 內聯函數將函數體直接擴展到調用內聯函數的地方，這樣減少了參數壓棧，跳轉，返回等過程；
4). 由於內聯發生在編譯階段，所以內聯相較宏，是有參數檢查和返回值檢查的，因此使用起來更爲安全；
5). 需要注意的是， inline會向編譯期提出內聯請求，但是是否內聯由編譯期決定（當然可以通過設置編譯器，強制使用內聯）；
6). 由於內聯是一種優化方式，在某些情況下，即使沒有顯示的聲明內聯，比如定義在class內部的方法，編譯器也可能將其作爲內聯函數。
7). 內聯函數不能過於複雜，最初C++限定不能有任何形式的循環，不能有過多的條件判斷，不能對函數進行取地址操作等，但是現在的編譯器幾乎沒有什麼限制，基本都可以實現內聯。
更多請參考inline關鍵字
6. C++中有了malloc / free , 爲什麼還需要 new / delete？
1). malloc與free是C++/C語言的標準庫函數，new/delete是C++的運算符。它們都可用於申請動態內存和釋放內存。
2). 對於非內部數據類型的對象而言，光用maloc/free無法滿足動態對象的要求。對象在創建的同時要自動執行構造函數，對象在消亡之前要自動執行析構函數。
由於malloc/free是庫函數而不是運算符，不在編譯器控制權限之內，不能夠把執行構造函數和析構函數的任務強加於malloc/free。因此C++語言需要一個能完成動態內存分配和初始化工作的運算符new，以一個能完成清理與釋放內存工作的運算符delete。注意new/delete不是庫函數。
最後補充一點體外話，new 在申請內存的時候就可以初始化（如下代碼）， 而malloc是不允許的。另外，由於malloc是庫函數，需要相應的庫支持，因此某些簡易的平臺可能不支持，但是new就沒有這個問題了，因爲new是C++語言所自帶的運算符。
int *p = new int(1);
1
特別的，在C++中，如下的代碼，用new創建一個對象(new 會觸發構造函數， delete會觸發析構函數)，但是malloc僅僅申請了一個空間，所以在C++中引入new和delete來支持面向對象。
#include <cstdlib>
class Test
{
...
}
Test* pn = new Test;
Test* pm = (Test*)malloc(sizeof(Test));
7. C和C++中的強制類型轉換？
C中是直接在變量或者表達式前面加上（小括號括起來的）目標類型來進行轉換，一招走天下，操作簡單，但是由於太過直接，缺少檢查，因此容易發生編譯檢查不到錯誤，而人工檢查又及其難以發現的情況；而C++中引入了下面四種轉換：
1). static_cast
a. 用於基本類型間的轉換
b. 不能用於基本類型指針間的轉換
c. 用於有繼承關係類對象間的轉換和類指針間的轉換
2). dynamic_cast
a. 用於有繼承關係的類指針間的轉換
b. 用於有交叉關係的類指針間的轉換
c. 具有類型檢查的功能
d. 需要虛函數的支持
3). reinterpret_cast
a. 用於指針間的類型轉換
b. 用於整數和指針間的類型轉換
4). const_cast
a. 用於去掉變量的const屬性
b. 轉換的目標類型必須是指針或者引用
在C++中，普通類型可以通過類型轉換構造函數轉換爲類類型，那麼類可以轉換爲普通類型嗎？答案是肯定的。但是在工程應用中一般不用類型轉換函數，因爲無法抑制隱式的調用類型轉換函數（類型轉換構造函數可以通過explicit來抑制其被隱式的調用），而隱式調用經常是bug的來源。實際工程中替代的方式是定義一個普通函數，通過顯式的調用來達到類型轉換的目的。
class test{
int m_value;
...
public:
operator int() //類型轉換函數
{
return m_value;
}
int toInt() //顯示調用普通函數來實現類型轉換
{
return m_value
}
}；
int main()
{
...
test a(5);
int i = a;
...
return 0;
}
8. static 有什麼用途
1）. 靜態（局部/全局）變量
2）. 靜態函數
3）. 類的靜態數據成員
4）. 類的靜態成員函數
9. 類的靜態成員變量和靜態成員函數各有哪些特性？
靜態成員變量
1). 靜態成員變量需要在類內聲明（加static），在類外初始化（不能加static），如下例所示；
2). 靜態成員變量在類外單獨分配存儲空間，位於全局數據區，因此靜態成員變量的生命週期不依賴於類的某個對象，而是所有類的對象共享靜態成員變量；
3). 可以通過對象名直接訪問公有靜態成員變量；
4). 可以通過類名直接調用公有靜態成員變量，即不需要通過對象，這一點是普通成員變量所不具備的。
class example{
private:
static int m_int; //static成員變量
};
int example::m_int = 0; //沒有static
cout<<example::m_int; //可以直接通過類名調用靜態成員變量
靜態成員函數
1). 靜態成員函數是類所共享的；
2). 靜態成員函數可以訪問靜態成員變量，但是不能直接訪問普通成員變量（需要通過對象來訪問）；需要注意的是普通成員函數既可以訪問普通成員變量，也可以訪問靜態成員變量；
3). 可以通過對象名直接訪問公有靜態成員函數；
4). 可以通過類名直接調用公有靜態成員函數，即不需要通過對象，這一點是普通成員函數所不具備的。
class example{
private:
static int m_int_s; //static成員變量
int m_int;
static int getI() //靜態成員函數在普通成員函數前加static即可
{
return m_int_s; //如果返回m_int則報錯，但是可以return d.m_int是合法的
}
};
cout<<example::getI(); //可以直接通過類名調用靜態成員變量
10. 在C++程序中調用被C編譯器編譯後的函數，爲什麼要加extern“C”?
C++語言支持函數重載，C語言不支持函數重載，函數被C++編譯器編譯後在庫中的名字與C語言的不同，假設某個函數原型爲：
void foo(int x, int y);
1
該函數被C編譯器編譯後在庫中的名字爲 _foo, 而C++編譯器則會產生像: _foo_int_int 之類的名字。爲了解決此類名字匹配的問題，C++提供了C鏈接交換指定符號 extern “C”。
11. 頭文件中的 ifndef/define/endif 是幹什麼用的? 該用法和 program once 的區別？
相同點:
它們的作用是防止頭文件被重複包含。
不同點
1). ifndef 由語言本身提供支持，但是 program once 一般由編譯器提供支持，也就是說，有可能出現編譯器不支持的情況(主要是比較老的編譯器)。
2). 通常運行速度上 ifndef 一般慢於 program once，特別是在大型項目上， 區別會比較明顯，所以越來越多的編譯器開始支持 program once。
3). ifndef 作用於某一段被包含（define 和 endif 之間）的代碼， 而 program once 則是針對包含該語句的文件， 這也是爲什麼 program once 速度更快的原因。
4). 如果用 ifndef 包含某一段宏定義，當這個宏名字出現“撞車”時，可能會出現這個宏在程序中提示宏未定義的情況（在編寫大型程序時特性需要注意，因爲有很多程序員在同時寫代碼）。相反由於program once 針對整個文件， 因此它不存在宏名字“撞車”的情況， 但是如果某個頭文件被多次拷貝，program once 無法保證不被多次包含，因爲program once 是從物理上判斷是不是同一個頭文件，而不是從內容上。
12. 當i是一個整數的時候++i和i++那個更快一點？i++和++i的區別是什麼？
答：理論上++i更快，實際與編譯器優化有關，通常幾乎無差別。
//i++實現代碼爲：
int operator++(int)
{
int temp = *this;
++*this;
return temp;
}//返回一個int型的對象本身
// ++i實現代碼爲：
int& operator++()
{
*this += 1;
return *this;
}//返回一個int型的對象引用
i++和++i的考點比較多，簡單來說，就是i++返回的是i的值，而++i返回的是i+1的值。也就是++i是一個確定的值，是一個可修改的左值，如下使用：
cout << ++(++(++i)) << endl;
cout << ++ ++i << endl;
1
2
可以不停的嵌套++i。
第三部分：數組、指針 & 引用
1. 指針和引用的區別？
相同點：
1). 都是地址的概念；
2). 都是“指向”一塊內存。指針指向一塊內存，它的內容是所指內存的地址；而引用則是某塊內存的別名；
3). 引用在內部實現其實是藉助指針來實現的，一些場合下引用可以替代指針，比如作爲函數形參。
不同點：
1). 指針是一個實體，而引用(看起來，這點很重要)僅是個別名；
2). 引用只能在定義時被初始化一次，之後不可變；指針可變；引用“從一而終”，指針可以“見異思遷”；
3). 引用不能爲空，指針可以爲空；
4). “sizeof 引用”得到的是所指向的變量(對象)的大小，而“sizeof 指針”得到的是指針本身的大小；
5). 指針和引用的自增(++)運算意義不一樣；
6). 引用是類型安全的，而指針不是 (引用比指針多了類型檢查)
7). 引用具有更好的可讀性和實用性。
2. 引用佔用內存空間嗎？
如下代碼中對引用取地址，其實是取的引用所對應的內存空間的地址。這個現象讓人覺得引用好像並非一個實體。但是引用是佔用內存空間的，而且其佔用的內存和指針一樣，因爲引用的內部實現就是通過指針來完成的。
比如 Type& name； <===> Type* const name。
int main(void)
{
int a = 8;
const int &b = a;
int *p = &a;
*p = 0;
cout<<a; //output 0
return 0;
}
3. 三目運算符
在C中三目運算符(? :)的結果僅僅可以作爲右值，比如如下的做法在C編譯器下是會報錯的，但是C++中卻是可以是通過的。這個進步就是通過引用來實現的，因爲下面的三目運算符的返回結果是一個引用，然後對引用進行賦值是允許的。
int main(void)
{
int a = 8;
int b = 6;
(a>b ? a : b) = 88;
cout<<a; //output 88
return 0;
}
4. 指針數組和數組指針的區別
數組指針，是指向數組的指針，而指針數組則是指該數組的元素均爲指針。
數組指針，是指向數組的指針，其本質爲指針，形式如下。如 int (*p)[10]，p即爲指向數組的指針，()優先級高，首先說明p是一個指針，指向一個整型的一維數組，這個一維數組的長度是n，也可以說是p的步長。也就是說執行p+1時，p要跨過n個整型數據的長度。數組指針是指向數組首元素的地址的指針，其本質爲指針，可以看成是二級指針。
類型名 (*數組標識符)[數組長度]
1
指針數組，在C語言和C++中，數組元素全爲指針的數組稱爲指針數組，其中一維指針數組的定義形式如下。指針數組中每一個元素均爲指針，其本質爲數組。如 int *p[n]， []優先級高，先與p結合成爲一個數組，再由int*說明這是一個整型指針數組，它有n個指針類型的數組元素。這裏執行p+1時，則p指向下一個數組元素，這樣賦值是錯誤的：p=a；因爲p是個不可知的表示，只存在p[0]、p[1]、p[2]…p[n-1],而且它們分別是指針變量可以用來存放變量地址。但可以這樣 *p=a; 這裏*p表示指針數組第一個元素的值，a的首地址的值。
類型名 *數組標識符[數組長度]
1
第四部分：C++特性
1. 什麼是面向對象（OOP）？面向對象的意義？
Object Oriented Programming, 面向對象是一種對現實世界理解和抽象的方法、思想，通過將需求要素轉化爲對象進行問題處理的一種思想。其核心思想是數據抽象、繼承和動態綁定（多態）。
面向對象的意義在於：將日常生活中習慣的思維方式引入程序設計中；將需求中的概念直觀的映射到解決方案中；以模塊爲中心構建可複用的軟件系統；提高軟件產品的可維護性和可擴展性。
2. 解釋下封裝、繼承和多態？
1). 封裝：
封裝是實現面向對象程序設計的第一步，封裝就是將數據或函數等集合在一個個的單元中（我們稱之爲類）。
封裝的意義在於保護或者防止代碼（數據）被我們無意中破壞。
2). 繼承：
繼承主要實現重用代碼，節省開發時間。
子類可以繼承父類的一些東西。
a. 公有繼承(public)
公有繼承的特點是基類的公有成員和保護成員作爲派生類的成員時，它們都保持原有的狀態，而基類的私有成員仍然是私有的，不能被這個派生類的子類所訪問。
b. 私有繼承(private)
私有繼承的特點是基類的公有成員和保護成員都作爲派生類的私有成員，並且不能被這個派生類的子類所訪問。
c. 保護繼承(protected)
保護繼承的特點是基類的所有公有成員和保護成員都成爲派生類的保護成員，並且只能被它的派生類成員函數或友元訪問，基類的私有成員仍然是私有的。
3. 什麼時候生成默認構造函數（無參構造函數）？什麼時候生成默認拷貝構造函數？什麼是深拷貝？什麼是淺拷貝？默認拷貝構造函數是哪種拷貝？什麼時候用深拷貝？
1). 沒有任何構造函數時，編譯器會自動生成默認構造函數，也就是無參構造函數；當類沒有拷貝構造函數時，會生成默認拷貝構造函數。
2). 深拷貝是指拷貝後對象的邏輯狀態相同，而淺拷貝是指拷貝後對象的物理狀態相同；默認拷貝構造函數屬於淺拷貝。
3). 當系統中有成員指代了系統中的資源時，需要深拷貝。比如指向了動態內存空間，打開了外存中的文件或者使用了系統中的網絡接口等。如果不進行深拷貝，比如動態內存空間，可能會出現多次被釋放的問題。是否需要定義拷貝構造函數的原則是，是類是否有成員調用了系統資源，如果定義拷貝構造函數，一定是定義深拷貝，否則沒有意義。
4. 構造函數和析構函數的執行順序？