在面試過程中遇到C++相關的問題，有的也是網上搜索的總結，有的貼出原文連結，有的沒有貼

1111

1、虛擬函式和純虛擬函式的區別：

答：虛擬函式：為了過載和多型的需要，在基類中是有實現的，virtual void Eat(){……};所以子類中可以過載也可以不過載基類中的此函式

純虛擬函式：就是基類只定義了函式體，沒有實現過程，定義方法如： virtual void Eat() = 0; 純虛擬函式相當於Java中的介面，自己不去實現，需要子類來實現函式定義；帶純虛擬函式的類叫虛基類，這種基類不能直接生成物件，而只有被繼承，並過載其虛擬函式後，才能使用。這樣的類也叫抽象類。

2、行內函數和巨集定義的差別是什麼：

1）行內函數在編譯時展開，巨集在預編譯時展開；

  （2）行內函數直接嵌入到目的碼中，巨集是簡單的做文字替換；

  （3）行內函數有型別檢測、語法判斷等功能，而巨集沒有；

  （4）inline函式是函式，巨集不是；

3、過載、繼承、多肽都有什麼區別：

函式過載：函式名相同，引數不同

對於過載的多個函式來說,其函式名都是一樣的,為了加以區分,在編譯連線時,C++會按照自己的規則篡改函式名字,這一過程為"名字改編".有的書中也稱為"名字粉碎".不同的C++編譯器會採用不同的規則進行名字改編

也有運算子過載，實現運算子的加減乘除；

繼承：子類可以具有父類的特性，就是繼承；但是基類中私有成員無法被繼承。

一個派生類繼承了所有的基類方法，但下列情況除外：

基類的建構函式、解構函式和拷貝建構函式。

基類的過載運算子。

基類的友元函式（我們說過友元函式不是成員函式）。

有三種繼承方式：

公有繼承（public）：當一個類派生自公有基類時，基類的公有成員也是派生類的公有成員，基類的保護成員也是派生類的保護成員，基類的私有成員不能直接被派生類訪問，但是可以通過呼叫基類的公有和保護成員（指的是函式）來訪問。

保護繼承（protected）：當一個類派生自保護基類時，基類的公有和保護成員將成為派生類的保護成員。（注意：公有成員也變成了保護成員）

私有繼承（private）：當一個類派生自私有基類時，基類的公有和保護成員將成為派生類的私有成員。（一般都不會使用這種）

封裝:

封裝的思想就是將實現的細節隱藏，而暴露公有介面；

C++中的訪問識別符號，可以實現在類中的封裝；通常是將所有的成員變數私有化；

儘管看起來訪問成員變數的不直接，但使程式更有可重用性和可維護性；

B)隱藏了類的實現，類的使用者只需知道公共的介面，就可以使用該類；

C)封裝幫助防止意外的改變和誤用；

D)對程式除錯有很大的幫助，因為改變類的成員變數只用通過公共介面。

封裝可以使得程式碼模組化，繼承可以擴充套件已存在的程式碼，他們的目的都是為了程式碼重用,而多型的目的則是為了介面重用。也就是說，不論傳遞過來的究竟是那個類的物件，函式都能夠通過同一個介面呼叫到適應各自物件的實現方法。

多型：指相同物件收到不同訊息或不同物件收到相同訊息時產生不同的實現動作。C++支援兩種多型性：編譯時多型性(也叫靜態聯編)，執行時多型性（動態聯編）。 

C++支援兩種形式的多型性。第一種是編譯時的多型性，稱為靜態聯編。第二種是執行時的多型性，也稱為動態聯編。執行時的多型性是指必須在執行中才可以確定的多型性，是通過繼承和虛擬函式來實現的。  a、編譯時多型性：通過過載函式實現   採用早繫結：就是在編譯時確定物件呼叫的函式的地址（一般運用於過載）函式多型性
  b、執行時多型性：通過虛擬函式實現。  採用遲繫結：就會在執行時再去確定物件的型別以及正確的呼叫函式類的多型性（在基類的函式前加上virtual關鍵字，在派生類中重寫該函式，執行時將會根據物件的實際型別來呼叫相應的函式。如果物件型別是派生類，就呼叫派生類的函式；如果物件型別是基類，就呼叫基類的函式，此為多型的表現；）（ 動態聯編要求派生類中的虛擬函式與基類中對應的虛擬函式具有相同的名稱、相同的引數個數和相同的對應引數型別、返回值或者相同，或者都返回指標或引用，並且派生類虛擬函式所返回的指標或引用的基型別是基類中虛擬函式所返回的指標或引用的基型別的子型別。如果不滿足這些條件，派生類中的虛擬函式將丟失其虛特性，在呼叫時進行靜態聯編。參考：http://blog.csdn.net/neiloid/article/details/6934129）

4、預處理和連結庫：

答：一個C++程式一般需要經過以下幾個步驟才能成為可執行程式：

C++源程式——》編譯器預處理——》編譯程式——》優化程式——》彙編程式——》連結程式——》可執行程式

編譯器預處理：C++編譯器自帶前處理器，在程式編譯之前，由前處理器對C++源程式完成預處理工作。

預處理主要將源程式中的巨集定義指令、條件編譯指令、標頭檔案包含指令以及特殊符號完成相應的替換工作。

編譯程式：以預編譯的輸出作為輸入，利用C++執行庫，通過詞法分析和語法分析，

在確認所有的指令都符合語法規則時，將其翻譯成等價的中間程式碼表示或者是組合語言。

優化程式：優化階段一部分是對中間程式碼的優化，這種優化不依賴具體的計算機，同機器的硬體環境無關。另一種優化則主要針對目的碼的生成而進行的。對於前一種優化，主要的工作是刪除公共表示式、迴圈優化(迴圈展開，自動向量化、迴圈不變數程式碼移動)以及無用賦值的刪除等。

另一種優化同機器的硬體結構密切相關。最主要的是考慮如何充分利用機器的各個硬體暫存器存放有關的變數的值，以減少對於記憶體的訪問次數。

彙編程式：彙編階段的主要工作是將經過編譯、優化後的，以組合語言的形式存在的程式轉化為機器可識別的二進位制程式碼，從而得到相應的目標檔案。

連結程式：經歷了彙編之後的程式是字尾為.obj形式的檔案，仍然是不可執行的，只有經過連結階段，程式所引用的外部檔案關聯起來之後，形成.exe字尾的檔案之後，才是可執行的。程式中可能引用了定義在其他外部檔案中的變數或者函式，比如某些庫函式，而連結階段所做的主要事情就是將這些相關聯的檔案連結起來，使得所有這些目標檔案成為一個能夠被作業系統裝入執行的統一的整體。

動態連結：採用該連結方式表明，需要連結的程式碼是存放在動態連結庫或者某個共享物件的目標檔案。

靜態連結：採用該連結方式，需要連結的程式碼會被連結程式從相應的靜態連結庫中拷貝到可執行程式之中。

5、c++多型底層實現原理

編譯器在編譯的時候，發現基類中有虛擬函式，此時編譯器會為每個包含虛擬函式的類建立一個虛表（即vtable），該表是一個一維陣列，在這個陣列中存放每個虛擬函式的地址。對於基類和子類都包含了一個虛擬函式breathe()，因此編譯器會為這兩個類都建立一個虛表，（即使子類裡面沒有virtual函式，但是其父類裡面有，所以子類中也有了）如下圖所示:

那麼如何定位虛表呢？編譯器另外還為每個類的物件提供了一個虛表指標（即vptr），這個指標指向了物件所屬類的虛表。在程式執行時，根據物件的型別去初始化vptr，從而讓vptr正確的指向所屬類的虛表，從而在呼叫虛擬函式時，就能夠找到正確的函式。     正是由於每個物件呼叫的虛擬函式都是通過虛表指標來索引的，也就決定了虛表指標的正確初始化是非常重要的。換句話說，在虛表指標沒有正確初始化之前，我們不能夠去呼叫虛擬函式。那麼虛表指標在什麼時候，或者說在什麼地方初始化呢？      要注意：對於虛擬函式呼叫來說，每一個物件內部都有一個虛表指標，該虛表指標被初始化為本類的虛表。所以在程式中，不管你的物件型別如何轉換，但該物件內部的虛表指標是固定的，所以呢，才能實現動態的物件函式呼叫，這就是C++多型性實現的原理。

    對於虛擬函式呼叫來說，每一個物件內部都有一個虛表指標，該虛表指標被初始化為本類的虛表。所以在程式中，不管你的物件型別如何轉換，但該物件內部的虛表指標是固定的，所以呢，才能實現動態的物件函式呼叫，這就是C++多型性實現的原理。 需要注意的幾點總結（基類有虛擬函式）：     1、每一個類都有虛表。     2、虛表可以繼承，如果子類沒有重寫虛擬函式，那麼子類虛表中仍然會有該函式的地址，只不過這個地址指向的是基類的虛擬函式實現。如果基類3個虛擬函式，那麼基類的虛表中就有三項（虛擬函式地址），派生類也會有虛表，至少有三項，如果重寫了相應的虛擬函式，那麼虛表中的地址就會改變，指向自身的虛擬函式實現。如果派生類有自己的虛擬函式，那麼虛表中就會新增該項。     3、派生類的虛表中虛擬函式地址的排列順序和基類的虛表中虛擬函式地址排列順序相同。

6、指標（pointer）和引用（Reference）的區別：

函式呼叫時，什麼時候採用值傳遞，什麼時候採用引用傳遞：

如果資料物件很小，如內建資料型別或小型結構，則按值傳遞。

如果資料物件是陣列，則使用指標，因為這是唯一的選擇，並將指標宣告為指向const的指標。

如果資料物件是較大的結構，則使用const指標或const引用，以提高程式的效率。這樣可以節省複製結構所需的時間和空間。

如果資料物件是類物件，則使用const引用。類設計的語義常常要求使用引用，這是C++新增這項特性的主要原因。因此，傳遞類物件引數的標準方式是按引用傳遞。

對於修改呼叫函式中資料的函式：

如果資料物件是內建資料型別，則使用指標。如果看到諸如fixit(&x)這樣的程式碼（其中x是int型），則很明顯，該函式將修改x。

如果資料物件是陣列，則只能使用指標。

如果資料物件是結構，則使用引用或指標。

如果資料物件是類物件，則使用引用。

指標和引用的定義和性質區別：

(1)指標：指標是一個變數，只不過這個變數儲存的是一個地址，指向記憶體的一個儲存單元；而引用跟原來的變數實質上是同一個東西，只不過是原變數的一個別名而已。

int a=1;int *p=&a;

int a=1;int &b=a;

(2)可以有const指標，但是沒有const引用；

(3)指標可以有多級，但是引用只能是一級（int **p；合法 而 int &&a是不合法的）

(4)指標的值可以為空，但是引用的值不能為NULL，並且引用在定義的時候必須初始化；

(5)指標的值在初始化後可以改變，即指向其它的儲存單元，而引用在進行初始化後就不會再改變了。

(6)"sizeof引用"得到的是所指向的變數(物件)的大小，而"sizeof指標"得到的是指標本身的大小；

(7)指標和引用的自增(++)運算意義不一樣；

7、為什麼建構函式不能宣告為虛擬函式、解構函式可以

建構函式不能宣告為虛擬函式的原因是:（why）1 構造一個物件的時候，必須知道物件的實際型別，而虛擬函式行為是在執行期間確定實際型別的。而在構造一個物件時，由於物件還未構造成功。編譯器無法知道物件的實際型別，是該類本身，還是該類的一個派生類，或是更深層次的派生類。無法確定。。。

2 虛擬函式的執行依賴於虛擬函式表。而虛擬函式表在建構函式中進行初始化工作，即初始化vptr，讓他指向正確的虛擬函式表。而在構造物件期間，虛擬函式表還沒有被初始化，將無法進行。

什麼叫基類指標指向派生類：舉個例子，定義一個基類Person ，Student繼承Person

Person *pt1 = new Person;Person *pt2 = new Student;          // 用基類的指標指向子類// Student *pt3 = new Person;     // 不能用子類指標指向基類，錯誤！Student *pt4 = new Student;

這個時候delete *pt1 會直接呼叫Person 的解構函式

delete *pt2,如果Person的解構函式宣告為virtual型別，則會先呼叫Student的解構函式，再呼叫Person的解構函式，如果Person的解構函式宣告不是virtual型別，則只會呼叫基類Person的解構函式，不會呼叫Student的解構函式，這樣就會導致銷燬物件不完全。

結論：最好對著上面連結的例子理解：

可以看出：只有在用基類的指標指向派生類的時候，才會出現這種情況。（ps:為什麼只有這種情況呢，在基類中定義了一個虛擬函式，然後在派生類中又定義一個同名，同參數表的函式，這就是多型。通過一個基類指標來操作物件，如果物件是基類物件，就會呼叫基類中的那個函式，如果物件實際是派生類物件，就會呼叫派聲類中的那個函式，呼叫哪個函式並不由函式的引數表決定，而是由函式的實際型別決定。）因為這個時候虛擬函式發揮了動態的作用。

解構函式執行時先呼叫派生類的解構函式，其次才呼叫基類的解構函式。如果解構函式不是虛擬函式，而程式執行時又要通過基類的指標去銷燬派生類的動態物件，那麼用delete銷燬物件時，只調用了基類的解構函式，未呼叫派生類的解構函式。這樣會造成銷燬物件不完全。

如果在上面的例子中，基類Person中未定義virtual解構函式，而派生類Student中定義了virtual的解構函式，此時用基類指標指向派生類，再delete掉，執行結果會出錯。如果再定義一個類OneSt繼承Student，則不會出現錯誤，因為Student作為基類了。

Effective C++ (第7條：要將多型基類的解構函式宣告為虛擬函式)

需要記住的

應該為多型基類宣告虛析構器。一旦一個類包含虛擬函式，它就應該包含一個虛析構器。

如果一個類不用作基類或者不需具有多型性，便不應該為它宣告虛析構器。

基類指標指向派生類的例子，這個很容易考：

基類的指標指向派生類的物件，當呼叫同名的成員函式時：

1）如果在基類中成員函式為虛擬函式，那麼基類指標呼叫的就是派生類的同名函式。virtual void display();

     可以這麼理解：因為該函式是虛的，所以會找真正實現的那個函式，所以呼叫派生類B中的 B class virtual display.

2）如果基類中成員函式為非虛擬函式，則呼叫的是基類的成員函式。void show();

     因為基類是非虛的，已經完全實現了，所以沒有必要再呼叫派生類的了，就呼叫基類的A class show()

8、C++四中cast操作符：

參考:http://blog.csdn.net/starryheavens/article/details/4617637

c語言中強制轉換符：int a; (float)a;

因為c風格的型別轉換有不少的缺點，它可以在任意型別之間轉換，比如你可以把一個指向const物件的指標轉換成指向非const物件的指標，把一個指向基類物件的指標轉換成指向一個派生類物件的指標，這兩種轉換之間的差別是巨大的，但是傳統的c語言風格的型別轉換沒有區分這些。還有一個缺點就是，c風格的轉換不容易查詢，他由一個括號加上一個識別符號組成，而這樣的東西在c++程式裡一大堆。所以c++為了克服這些缺點，引進了4種新的型別轉換操作符。

對於c++來說,C++標準定義了四個新的轉換符：reinterpret_cast, static_cast, dynamic_cast和const_cast，目的在於控制類(class)之間的型別轉換。

1、reinterpret_cast

用法：reinpreter_cast<type-id> (expression)

type-id必須是一個指標、引用、算術型別、函式指標或者成員指標。它可以把一個指標轉換成一個整數，也可以把一個整數轉換成一個指標。

這個操作符能夠在非相關的型別之間轉換。操作結果只是簡單的從一個指標到別的指標的值的二進位制拷貝。在型別之間指向的內容不做任何型別的檢查和轉換。reinpreter_cast是特意用於底層的強制轉型，導致實現依賴（就是說，不可移植）的結果。

Int  n=9;

// reinterpret_cast 僅僅是複製 n 的位元位到 d，因此d 包含無用值。

double d=reinterpret_cast<double & > (n);

2、const_cast

用法：const_cast<type_id> (expression)

用於修改型別的const或volatile屬性。除了const 或volatile修飾之外，type_id和expression的型別是一樣的，一般用於強制消除物件的常量性。它是唯一能做到這一點的 C++ 風格的強制轉型，而C不提供消除const的機制（已驗證）。

常量指標被轉化成非常量指標，並且仍然指向原來的物件；常量引用被轉換成非常量引用，並且仍然指向原來的物件；常量物件被轉換成非常量物件。

3、static_cast

最常用的轉換，C語言型別的轉化，但是轉換的時候不會檢查型別來保證轉換的安全性。

1）用於基本資料型別之間的轉換，如把int轉換成char，non-const 物件轉型為 const 物件（這裡相反方向不可以，C++只有const_cast可以）。

2）把空指標轉換成目標型別的指標。（之前的做法是用強制轉換(type-id*)

3）把任何型別的表示式轉換成void型別。

4）應用到類的指標上，它允許子類型別的指標轉換為父類型別的指標（upercasting這是一個有效的隱式轉換）；也能夠執行相反動作，即轉換父類為它的子類（downcasting），這種轉換的安全性需要開發人員來保證（主要是在非上下轉型中）。

class Base {};

class Derived : public Base {};

Base *a = new Base;

Derived *b = NULL;

b = static_cast<Derived *>(a); //可以通過編譯，但存在安全隱患(如訪問//Derived的成員)

注意：

1．static_cast不能轉換掉expression的const、volitale、或者__unaligned屬性。

2．在非基本型別或上下轉型中，被轉換的父類需要檢查是否與目的型別相一致，否則，如果在兩個完全不相干的類之間進行轉換，將會導致編譯出錯。

4、dynamic_cast

Dynamic_cast 與其他操作符不同，涉及執行型別檢驗，如果繫結到指標或引用上的物件不是目標型別的物件，則dynamic_cast 失敗，如果轉換到指標型別的dynamic_cast失敗，則結果為0，如果轉換到引用型別的dynamic_cast 失敗，則丟擲bad_cast異常。

因此，dynamic_cast操作符一次執行兩個操作，它首先驗證被請求的轉換是否有效，只有轉換有效，操作符才實際進行轉換。由於引用或指標在所繫結的物件型別在編譯時時未知的，所以dynamic_cast執行的驗證只有在執行時進行。

注意：

（1）T必須是類的指標、類的引用或者void *。如果T是類指標型別，那麼expression也必須是一個指標，如果T是一個引用，那麼expression也必須是一個引用。

（2）dynamic_cast主要用於類層次間的上行轉換和下行轉換，還可以用於類之間的交叉轉換。
在類層次間進行上行轉換（子類->子類/基類）時，dynamic_cast和static_cast的效果是一樣的；在進行下行轉換（基類->子類）時，dynamic_cast具有型別檢查的功能，比static_cast更安全。

（2）dynamic_cast轉換符只能用於含有虛擬函式的類。

也就是說只有基類的指標指向派生類時，這種基類和子類之間的轉換才算成功

舉例：

class Base { virtual dummy() {} };

class Derived : public Base {};

class Other{} ;

Base* b1 = new Derived;

Base* b2 = new Base;

Derived* d1 = dynamic_cast<Derived *>(b1);  // succeeds

Derived* d2 = dynamic_cast<Derived *>(b2);  // fails: returns 'NULL'

//如果一個引用型別執行了型別轉換並且這個轉換是不可能的，執行時一個//bad_cast的異常型別會被丟擲：

Derived d3 = dynamic_cast<Derived &>(*b1);  // succeeds

Derived d4 = dynamic_cast<Derived &>(*b2);  // fails: exception thrown

注意：Base需要有虛擬函式，否則會編譯出錯。

dynamic_cast主要用於類層次間的上行轉換和下行轉換，還可以用於類之間的交叉轉換。
在類層次間進行上行轉換（子類->子類/基類）時，dynamic_cast和static_cast的效果是一樣的；在進行下行轉換（基類->子類）時，dynamic_cast具有型別檢查的功能，比static_cast更安全。

9、智慧指標，以及其原理和原因：

參考：http://www.cnblogs.com/lanxuezaipiao/p/4132096.html

   智慧指標： 智慧指標(smart pointer)是儲存指向動態分配（堆）物件指標的類，用於生存期控制，能夠確保自動正確的銷燬動態分配的物件，防止記憶體洩露。

智慧指標就是模擬指標動作的類。所有的智慧指標都會過載 -> 和 * 操作符。智慧指標還有許多其他功能，比較有用的是自動銷燬。這主要是利用棧物件的有限作用域以及臨時物件（有限作用域實現）解構函式釋放記憶體。當然，智慧指標還不止這些，還包括複製時可以修改源物件等。智慧指標根據需求不同，設計也不同。

智慧指標採用計數器的用法：

智慧指標類將一個計數器與類指向的物件相關聯，引用計數跟蹤該類有多少個物件共享同一指標。每次建立類的新物件時，初始化指標並將引用計數置為1；當物件作為另一物件的副本而建立時，拷貝建構函式拷貝指標並增加與之相應的引用計數；對一個物件進行賦值時，賦值操作符減少左運算元所指物件的引用計數（如果引用計數為減至0，則刪除物件），並增加右運算元所指物件的引用計數；呼叫解構函式時，建構函式減少引用計數（如果引用計數減至0，則刪除基礎物件。

STL常用的4種智慧指標型別為：auto_ptr、unique_ptr、shared_ptr和weak_ptr

(1) 為什麼現在不用auto_ptr了：為什麼現在不用auto_ptr了，因為auto_ptr建立所有權（ownership）概念。對於特定的物件，只能有一個智慧指標可擁有，這樣只有擁有物件的智慧指標的建構函式會刪除該物件。然後讓賦值操作轉讓所有權。這就是用於auto_ptr和unique_ptr 的策略，但unique_ptr的策略更嚴格。

(2) 為什麼unique_ptr比auto_ptr更嚴格:

舉個例子：auto_ptr<string> p1(new string ("auto") ； //#1

auto_ptr<string> p2;                      //#2

p2 = p1;                                   //#3

對於語句#3，auto_ptr 會執行，p2接管string物件的所有權後，p1的所有權將被剝奪。但如果程式隨後試圖使用p1，這將是件壞事，因為p1不再指向有效的資料。但是unique_ptr認為#3語句是非法的，所以不再執行語句3避免了p1不再指向有效資料的問題。

(3) 但是對於unique_ptr怎麼實現賦值操作呢？

可以採用呼叫函式的方式返回臨時變數的方式進行賦值，如下所示：

unique_ptr<string> demo(const char * s)

{

unique_ptr<string> temp (new string (s))；

return temp；

}

unique_ptr<string> ps;

ps = demo('Uniquely special")；

demo() 返回一個臨時unique_ptr，然後ps接管了原本歸返回的unique_ptr所有的物件，而返回時臨時的 unique_ptr 被銷燬，也就是說沒有機會使用 unique_ptr 來訪問無效的資料，換句話來說，這種賦值是不會出現任何問題的，即沒有理由禁止這種賦值。實際上，編譯器確實允許這種賦值，這正是unique_ptr更聰明的地方。

(4) 但是比較常用的還是shared_ptr指標：

  因為shared_ptr的出現就是為了解決所有權轉移出現的問題，採用引用計數器的方法，shared_ptr

相關推薦