C/C++必知必會1

 2. 什麼是“引用”？申明和使用“引用”要注意哪些問題？

    答：引用就是某個目標變數的“別名”（alias），對應用的操作與對變數直接操作效果完全相同。申明一個引用的時候，切記要對其進行初始化。引用聲明完畢後，相當於目標變數名有兩個名稱，即該目標原名稱和引用名，不能再把該引用名作為其他變數名的別名。聲明一個引用，不是新定義了一個變數，它只表示該引用名是目標變數名的一個別名，它本身不是一種資料類型，因此引用本身不佔儲存單元，系統也不給引用分配儲存單元。不能建立數組的引用。

    3. 將“引用”作為函數參數有哪些特點？

    （1）傳遞引用給函數與傳遞指標的效果是一樣的。這時，被調函數的形參就成為原來主調函數中的實參變數或對象的一個別名來使用，所以在被調函數中對形參變數的操作就是對其相應的目標對象（在主調函數中）的操作。

    （2）使用引用傳遞函數的參數，在記憶體中並沒有產生實參的副本，它是直接對實參操作；而使用一般變數傳遞函數的參數，當發生函數調用時，需要給形參分配儲存單元，形參變數是實參變數的副本；如果傳遞的是對象，還將調用拷貝建構函式。因此，當參數傳遞的資料較大時，用引用比用一般變數傳遞參數的效率和所佔空間都好。

    （3）使用指標作為函數的參數雖然也能達到與使用引用的效果，但是，在被調函數中同樣要給形參分配儲存單元，且需要重複使用"*指標變數名" 的形式進行運算，這很容易產生錯誤且程式的閱讀性較差；另一方面，在主調函數的調用點處，必須用變數的地址作為實參。而引用更容易使用，更清晰。

    4. 在什麼時候需要使用“常引用”？

    如果既要利用引用提高程式的效率，又要保護傳遞給函數的資料不在函數中被改變，就應使用常引用。常引用聲明方式：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 .

5. 將“引用”作為函數傳回值類型的格式、好處和需要遵守的規則？

    格式：類型標識符 &函數名（形參列表及類型說明）{ //函數體 }好處：在記憶體中不產生被傳回值的副本；（注意：正是因為這點原因，所以返回一個局部變數的引用是不可取的。因為隨著該局部變數生存期的結束，相應的引用也會失效，產生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而導致錯誤。所以可選的只剩下返回一個對象了。

    6. “引用”與多態的關係？

    引用是除指標外另一個可以產生多態效果的手段。這意味著，一個基類的引用可以指向它的衍生類別執行個體。

    例4

Class A; Class B : Class A{...};  B b; A& ref = b;

    7. “引用”與指標的區別是什嗎？

    指標通過某個指標變數指向一個對象後，對它所指向的變數間接操作。程式中使用指標，程式的可讀性差；而引用本身就是目標變數的別名，對引用的操作就是對目標變數的操作。此外，就是上面提到的對函數傳ref和pointer的區別。

    8. 什麼時候需要“引用”？

    流操作符<<和>>、賦值操作符=的傳回值、拷貝建構函式的參數、賦值操作符=的參數、其它情況都推薦使用引用。

    以上 2-8 參考：http://blog.csdn.net/wfwd/archive/2006/05/30/763551.aspx

18. 重載（overload）和重寫（overried，有的書也叫做“覆蓋”）的區別？

    常考的題目。從定義上來說：重載：是指允許存在多個同名函數，而這些函數的參數表不同（或許參數個數不同，或許參數類型不同，或許兩者都不同）。

    重寫：是指子類重新定義複類虛函數的方法。

    從實現原理上來說：重載：編譯器根據函數不同的參數表，對同名函數的名稱做修飾，然後這些同名函數就成了不同的函數（至少對於編譯器來說是這樣的）。如，有兩個同名函數：function func（p：integer）：integer；和function func（p：string）：integer；。那麼編譯器做過修飾後的函數名稱可能是這樣的：int_func、str_func.對於這兩個函數的調用，在編譯器間就已經確定了，是靜態。也就是說，它們的地址在編譯期就綁定了（早綁定），因此，重載和多態無關！

    重寫：和多態真正相關。當子類重新定義了父類的虛函數後，父類指標根據賦給它的不同的子類指標，動態調用屬於子類的該函數，這樣的函數調用在編譯期間是無法確定的（調用的子類的虛函數的地址無法給出）。因此，這樣的函數地址是在運行期綁定的（晚綁定）。

19. 多態的作用？

    主要是兩個：1. 隱藏實現細節，使得代碼能夠模組化；擴充代碼模組，實現代碼重用；2. 介面重用：為了類在繼承和派生的時候，保證使用家族中任一類的執行個體的某一屬性時的正確調用。

24. C++是不是型別安全的？

    答案：不是。兩個不同類型的指標之間可以強制轉換（用reinterpret cast）。C#是型別安全的。

25. main 函數執行以前，還會執行什麼代碼？

    答案：全域對象的建構函式會在main 函數之前執行。

    26. 描述記憶體配置方式以及它們的區別？

    1）從靜態儲存地區分配。記憶體在程式編譯的時候就已經分配好，這塊記憶體在程式的整個運行期間都存在。例如全域變數，static 變數。

    2）在棧上建立。在執行函數時，函數內局部變數的儲存單元都可以在棧上建立，函數執行結束時這些儲存單元自動被釋放。棧記憶體配置運算內建於處理器的指令集。

    3） 從堆上分配，亦稱動態記憶體分配。程式在啟動並執行時候用malloc 或new 申請任意多少的記憶體，程式員自己負責在何時用free 或delete 釋放記憶體。動態記憶體的生存期由程式員決定，使用非常靈活，但問題也最多。

27.struct 和 class 的區別答案：struct 的成員預設是公有的，而類的成員預設是私人的。struct 和 class 在其他方面是功能相當的。

    從感情上講，大多數的開發人員感到類和結構有很大的差別。感覺上結構僅僅象一堆缺乏封裝和功能的開放的記憶體位，而類就象活的並且可靠的社會成員，它有智慧型服務，有牢固的封裝屏障和一個良好定義的介面。既然大多數人都這麼認為，那麼只有在你的類有很少的方法並且有公有資料（這種事情在良好設計的系統中是存在的！）時，你也許應該使用 struct 關鍵字，否則，你應該使用 class 關鍵字。

29. 在8086 彙編下，邏輯地址和物理地址是怎樣轉換的？（Intel）

    答案：通用寄存器給出的地址，是段內位移地址，相應段寄存器地址*10H+通用寄存器內地址，就得到了真正要訪問的地址。

    30. 比較C++中的4種類型轉換方式？

    請參考：http://blog.csdn.net/wfwd/archive/2006/05/30/763785.aspx ，重點是static_cast， dynamic_cast和reinterpret_cast的區別和應用

32.請說出const與#define 相比，有何優點？

    答案：1） const 常量有資料類型，而宏常量沒有資料類型。編譯器可以對前者進行型別安全檢查。而對後者只進行字元替換，沒有型別安全檢查，並且在字元替換可能會產生意料不到的錯誤。

    2） 有些整合化的調試工具可以對const 常量進行調試，但是不能對宏常量進行調試。

34.類成員函數的重載、覆蓋和隱藏區別？

    答案：

    a.成員函數被重載的特徵：

    （1）相同的範圍（在同一個類中）；（2）函數名字相同；（3）參數不同；（4）virtual 關鍵字可有可無。

    b.覆蓋是指衍生類別函數覆蓋基類函數，特徵是：

    （1）不同的範圍（分別位於衍生類別與基類）；（2）函數名字相同；（3）參數相同；（4）基類函數必須有virtual 關鍵字。

    c.“隱藏”是指衍生類別的函數屏蔽了與其同名的基類函數，規則如下：

    （1）如果衍生類別的函數與基類的函數同名，但是參數不同。此時，不論有無virtual關鍵字，基類的函數將被隱藏（注意別與重載混淆）。

    （2）如果衍生類別的函數與基類的函數同名，並且參數也相同，但是基類函數沒有virtual 關鍵字。此時，基類的函數被隱藏（注意別與覆蓋混淆）

37. 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.

 

44. 多重繼承的記憶體配置問題：比如有class A ： public class B， public class C {}那麼A的記憶體結構大致是怎麼樣的？

    這個是compiler-dependent的， 不同的實現其細節可能不同。

    如果不考慮有虛函數、虛繼承的話就相當簡單；否則的話，相當複雜。

    可以參考《深入探索C++物件模型》，或者：http://blog.csdn.net/wfwd/archive/2006/05/30/763797.aspx

  45. 如何判斷一個單鏈表是有環的？（注意不能用標誌位，最多隻能用兩個額外指標）

    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; }

 

1. 是不是一個父類寫了一個 virtual 函數，如果子類覆蓋它的函數不加 virtual ， 也能實現多態 ？

    virtual 修飾符會被隱形繼承的。

    private 也被整合，只事衍生類別沒有存取權限而已virtual 可加可不加子類的空間裡有父類的所有變數 （static 除外 ）

    同一個函數只存在一個實體 （inline 除外 ）

    子類覆蓋它的函數不加 virtual ， 也能實現多態。

    在子類的空間裡，有父類的私人變數。私人變數不能直接存取。

3. 請簡單描述 Windows 記憶體管理的方法。

    記憶體管理是作業系統中的重要部分，兩三句話恐怕誰也說不清楚吧～～我先說個大概，希望能夠拋磚引玉吧當程式運行時需要從記憶體中讀出這段程式的代碼。代碼的位置必須在實體記憶體中才能被運行，由於現在的作業系統中有非常多的程式運行著，記憶體中不能夠完全放下，所以引出了虛擬記憶體的概念。把哪些不常用的程式片斷就放入虛擬記憶體，當需要用到它的時候在 load 入主存（實體記憶體）中。這個就是記憶體管理所要做的事。記憶體管理還有另外一件事需要做：計算程式片段在主存中的物理位置，以便 CPU 調度。

    記憶體管理有塊式管理，頁式管理，段式和段頁式管理。現在常用段頁式管理塊式管理：把主存分為一大塊、一大塊的，當所需的程式片斷不在主存時就分配一塊主存空間，把程 序片斷 load 入主存，就算所需的程式片度只有幾個位元組也只能把這一塊分配給它。這樣會造成很大的浪費，平均浪費了 50 ％的記憶體空間，但時易於管理。

    頁式管理：把主存分為一頁一頁的，每一頁的空間要比一塊一塊的空間小很多，顯然這種方法的空間利用率要比塊式管理高很多。

    段式管理：把主存分為一段一段的，每一段的空間又要比一頁一頁的空間小很多，這種方法在空間利用率上又比頁式管理高很多，但是也有另外一個缺點。一個程式片斷可能會被分為幾十段，這樣很多時間就會被浪費在計算每一段的物理地址上（電腦最耗時間的大家都知道是 I/O 吧）。

    段頁式管理：結合了段式管理和頁式管理的優點。把主存分為若干頁，每一頁又分為若干段。好處就很明顯，不用我多說了吧。

    各種記憶體管理都有它自己的方法來計算出程式片斷在主存中的物理地址，其實都很相似。

    這隻是一個大概而已，不足以說明記憶體管理的皮毛。無論哪一本作業系統書上都有詳細的講解

2. 以下代碼中的兩個sizeof用法有問題嗎？[C易]

void UpperCase( char str[] ) // 將 str 中的小寫字母轉換成大寫字母 {     for( size_t i=0; i<sizeof(str)/sizeof(str[0]); ++i )         if( 'a'<=str[i] && str[i]<='z' )             str[i] -= ('a'-'A' ); } char str[] = "aBcDe"; cout << "str字元長度為: " << sizeof(str)/sizeof(str[0]) << endl; UpperCase( str ); cout << str << endl;

    答：函數內的sizeof有問題。根據文法，sizeof如用於數組，只能測出靜態數組的大小，無法檢測動態分配的或外部數組大小。函數外的str是一個靜態定義的數組，因此其大小為6，函數內的str實際只是一個指向字串的指標，沒有任何額外的與數組相關的資訊，因此siz eof作用於上只將其當指標看，一個指標為4個位元組，因此返回4.

3. 非C++內建型別 A 和 B，在哪幾種情況下B能隱式轉化為A？[C++中等]

    答：   

    a. class B ： public A { ……} // B公有繼承自A，可以是間接繼承的

    b. class B { operator A（ ）； } // B實現了隱式轉化為A的轉化

    c. class A { A（ const B& ）； } // A實現了non-explicit的參數為B（可以有其他帶預設值的參數）建構函式

    d. A& operator= （ const A& ）； // 賦值操作，雖不是正宗的隱式類型轉換，但也可以勉強算一個

4. 以下代碼有什麼問題？[C++易]

struct Test {     Test( int ) {}     Test() {}     void fun() {} }; void main( void ) {     Test a(1);     a.fun();     Test b();     b.fun(); }

    答：變數b定義出錯。按預設建構函式定義對象，不需要加括弧。

    5. 以下代碼有什麼問題？[C++易]

cout << (true?1:"1") << endl;

    答：三元運算式“？：”問號後面的兩個運算元必須為同一類型。

    6. 以下代碼能夠編譯通過嗎，為什嗎？[C++易]

unsigned int const size1 = 2; char str1[ size1 ]; unsigned int temp = 0; cin >> temp; unsigned int const size2 = temp; char str2[ size2 ];

    答：str2定義出錯，size2非編譯器期間常量，而數組定義要求長度必須為編譯期常量。

7. 以下反向遍曆array數組的方法有什麼錯誤？[STL易]

vector array; array.push_back( 1 ); array.push_back( 2 ); array.push_back( 3 ); for( vector::size_type i=array.size()-1; i>=0; --i ) // 反向遍曆array數組 {     cout << array[i] << endl; }

    答：首先數組定義有誤，應加上型別參數：vector<int> array.其次vector：：size_type被定義為unsigned int，即無符號數，這樣做為迴圈變數的i為0時再減1就會變成最大的整數，導致迴圈失去控制 .

    8. 以下代碼中的輸出語句輸出0嗎，為什嗎？[C++易]

struct CLS {     int m_i;     CLS( int i ) : m_i(i) {}     CLS()     {         CLS(0);     } }; CLS obj; cout << obj.m_i << endl;

    答：不能。在預設建構函式內部再調用帶參的建構函式屬使用者行為而非編譯器行為，亦即僅執行函數調用，而不會執行其後的初始設定式。只有在產生對象時，初始設定式才會隨相應的建構函式一起調用。

    9. C++中的空類，預設產生哪些類成員函數？[C++易]

    答：

class Empty { public:     Empty();                          // 預設建構函式     Empty( const Empty& );            // 拷貝建構函式     ~Empty();                         // 解構函式     Empty& operator=( const Empty& ); // 賦值運算子     Empty* operator&();               // 取址運算子     const Empty* operator&() const;   // 取址運算子 const };

    10. 以下兩條輸出語句分別輸出什嗎？[C++難]

float a = 1.0f; cout << (int)a << endl; cout << (int&)a << endl; cout << boolalpha << ( (int)a == (int&)a ) << endl; // 輸出什嗎？ float b = 0.0f; cout << (int)b << endl; cout << (int&)b << endl; cout << boolalpha << ( (int)b == (int&)b ) << endl; // 輸出什嗎？

    答：分別輸出false和true.注意轉換的應用。（int）a實際上是以浮點數a為參數構造了一個整型數，該整數的值是1，（int&）a則是告訴編譯器將a當作整數看（並沒有做任何實質上的轉換）。因為1以整數形式存放和以浮點形式存放其記憶體資料是不一樣的，因此兩者不等。

    對b的兩種轉換意義同上，但是0的整數形式和浮點形式其記憶體資料是一樣的，因此在這種特殊情形下，兩者相等（僅僅在數值意義上）。

    注意，程式的輸出會顯示（int&）a=1065353216，這個值是怎麼來的呢？前面已經說了，1以浮點數形式存放在記憶體中，按ieee754規定，其內容為0x0000803F（已考慮位元組反序）。這也就是a這個變數所佔據的記憶體單元的值。當（int&）a出現時，它相當於告訴它的上下文：“把這塊地址當做整數看待！不要管它原來是什麼。”這樣，內容0x0000803F按整數解釋，其值正好就是1065353216（十進位數）。

    通過查看彙編代碼可以證實“（int）a相當於重新構造了一個值等於a的整型數”之說，而（in t&）的作用則僅僅是表達了一個類型資訊，意義在於為cout<<及==選擇正確的重載版本。

    11. 以下代碼有什麼問題？[STL易]

typedef vector IntArray; IntArray array; array.push_back( 1 ); array.push_back( 2 ); array.push_back( 2 ); array.push_back( 3 ); // 刪除array數組中所有的2 for( IntArray::iterator itor=array.begin(); itor!=array.end(); ++itor ) {     if( 2 == *itor ) array.erase( itor ); }

    答：同樣有缺少型別參數的問題。另外，每次調用“array.erase（ itor ）；”，被刪除元素之後的內容會自動往前移，導致迭代漏項，應在刪除一項後使itor——，使之從已經前移的下一個元素起繼續遍曆。

    12. 寫一個函數，完成記憶體之間的拷貝。[考慮問題是否全面]

    答：

void* mymemcpy( void *dest, const void *src, size_t count ) {     char* pdest = static_cast<char*>( dest );     const char* psrc = static_cast<const char*>( src );     if( pdest>psrc && pdest<psrc+cout ) 能考慮到這種情況就行了     {         for( size_t i=count-1; i!=-1; --i )                 pdest[i] = psrc[i];     }     else     {         for( size_t i=0; i<count; ++i )             pdest[i] = psrc[i];     }     return dest; ｝