C++語言特性：建構函式,解構函式,虛擬函式,行內函數,靜態成員函式,過載，覆蓋，隱藏

阿新 • • 發佈：2019-01-13

C++中class預設屬性為private, struct預設屬性為public

建構函式：

1.初始化物件成員;
2.建立類物件;
由於虛擬函式是建立在物件的基礎上的，因此建構函式不能宣告為虛擬函式;虛擬函式是在執行的時候才識別,根據具體物件進行動態繫結.
每個類物件都有一個預設建構函式.當一個物件被在堆上建立的時候，第一步先執行new操作,第二步才會執行建構函式體，因此儘可能不要在建構函式內部動態申請太多的資源，以免引起記憶體洩露.
詳情如下：

cppBaseClass *base = new cppBaseClass();
012A1FDD  push        0Ch  
012A1FDF  call        operator new (12A11E5h)  
012A1FE4  add         esp,4  
012A1FE7  mov         dword ptr [ebp-11Ch],eax  
012A1FED  mov         dword ptr [ebp-4],0  
012A1FF4  cmp         dword ptr [ebp-11Ch],0  
012A1FFB  je          main+70h (12A2010h)  
012A1FFD  mov         ecx,dword ptr [ebp-11Ch]  
012A2003  call        cppBaseClass::cppBaseClass (12A1023h)  
012A2008  mov         dword ptr [ebp-130h],eax  
012A200E  jmp         main+7Ah (12A201Ah)  
012A2010  mov         dword ptr [ebp-130h],0  
012A201A  mov         eax,dword ptr [ebp-130h]  
012A2020  mov         dword ptr [ebp-128h],eax  
012A2026  mov         dword ptr [ebp-4],0FFFFFFFFh  
012A202D  mov         ecx,dword ptr [ebp-128h]  
012A2033  mov         dword ptr [ebp-14h],ecx

拷貝建構函式[複製建構函式]：
如果要動態地為本地C++類的成員分配空間,則必須實現複製建構函式.
下面是拷貝建構函式的實現模版：

          ConstructorFunctionClassName(const ConstructorFunctionClassName& ObjectType)
          {
          }

拷貝建構函式的呼叫條件：
1.當一個物件以值傳遞的方式傳入函式體;
2.當一個物件以值傳遞的方式作為函式的返回值;
3.當一個物件通過另外一個物件進行初始化;
為什麼需要實現拷貝建構函式？

首先這裡需要描述一下C++中預設拷貝建構函式，參考下面程式碼：

          className Object0("Test the constructor function");
          className Object1 = Object0; //預設建構函式被呼叫

預設建構函式會把類物件Object0的指標成員儲存地址複製到Object1中，這個時候Object1和Object0同時指向同一塊記憶體區域, 那麼如果Oject1被銷燬了，那麼Object0中的內容就會發生改變.
上面的現象也被OOP中稱為淺拷貝.
那對應的肯定有深拷貝, Object0擁有資源，當上面的Object1在複製的過程中重新分配了資源，那麼這個過程就是深拷貝.

        className cName;
        className::className(cName);

在傳遞物件cName之前，編譯器需要安排建立該物件的副本.因此，編譯器為了處理複製建構函式的這條語句，需要呼叫複製建構函式來建立實參的副本。由於是按值傳遞，第二次呼叫同樣需要建立實參的副本,因此還得呼叫複製建構函式，產生無窮呼叫.
看下面的一段程式碼：

        className  cName("Test default constructor");
        testDefaultConstructor(cName);
         void testDefaultConstructor( className Object0)
         {
                Object0.PrintString();
         }

實參cName是作為傳值的方式傳遞的，那麼Object0將導致預設建構函式被呼叫:
1.建立cName物件;
2.由於cName是傳值方式，因此導致Object0將要建立一個副本,而且該副本同時指向原來物件所指向的資料成員.
3.當退出testDefaultConstructor函式的時候, Object0超出了其作用域,那麼Object0的解構函式將要被呼叫,Object0指向的資料成員將要被釋放.
4.當函式從testDefaultConstructor返回的時候, cName物件依然指向之前Object0指向的資料區域.異常發生！

PS:

當類物件中有指標成員時必須用深拷貝，淺拷貝會導致指標成員變成野指標的風險;

傳值的時候，物件的副本產生，但是該副本和原始物件都包含了指標成員，同時該指標成員指向的地址是相同的，那麼在完成了傳值的作用域之後，該副本物件會自動銷燬，因此必然導致該副本的解構函式被呼叫[通常會在解構函式中釋放指標成員的資源]，那麼當真正的物件被習夠的時候，就會再次處理該指標成員.

解構函式：

1.給物件提供釋放資源的機會;
2.銷燬物件,銷燬不再需要或超出其作用域的物件.當物件超出其作用域時，程式將自動呼叫類的解構函式.
如果想要防止對像被建立在堆上，可以私有化解構函式,不過這樣以來該類不能被繼承.
如果需要呼叫私有解構函式，則需要實現一個成員函式,在該成員函式內部呼叫

delete this;

虛擬解構函式：
如果當前類作為介面基類，那麼需要宣告該類的解構函式為虛擬解構函式.
因為如果，當我們使用基類的指標去刪除派生類的物件的時候,如果基類的解構函式不是虛擬解構函式，那麼派生類的解構函式將會不被執行.
但是當生命了虛擬函式之後，在物件中就會生成一個虛擬函式表,這樣會增加類物件的儲存空間開銷.
下面部分是基於基類虛擬解構函式的條件下反彙編出來的：

cppBaseClass *base = new cppDeriveClass();
002D235D  push        10h  
002D235F  call        operator new (2D121Ch)  
002D2364  add         esp,4  
002D2367  mov         dword ptr [ebp-104h],eax  
002D236D  mov         dword ptr [ebp-4],0  
002D2374  cmp         dword ptr [ebp-104h],0  
002D237B  je          main+70h (2D2390h)  
002D237D  mov         ecx,dword ptr [ebp-104h]  
002D2383  call        cppDeriveClass::cppDeriveClass (2D1069h)  
002D2388  mov         dword ptr [ebp-118h],eax  
002D238E  jmp         main+7Ah (2D239Ah)  
002D2390  mov         dword ptr [ebp-118h],0  
002D239A  mov         eax,dword ptr [ebp-118h]  
002D23A0  mov         dword ptr [ebp-110h],eax  
002D23A6  mov         dword ptr [ebp-4],0FFFFFFFFh  
002D23AD  mov         ecx,dword ptr [ebp-110h]  
002D23B3  mov         dword ptr [ebp-14h],ecx  
delete base;
002D23B6  mov         eax,dword ptr [ebp-14h]  
002D23B9  mov         dword ptr [ebp-0ECh],eax  
002D23BF  mov         ecx,dword ptr [ebp-0ECh]  
002D23C5  mov         dword ptr [ebp-0F8h],ecx  
002D23CB  cmp         dword ptr [ebp-0F8h],0  
002D23D2  je          main+0D9h (2D23F9h)  
002D23D4  mov         esi,esp  
002D23D6  push        1  
002D23D8  mov         edx,dword ptr [ebp-0F8h]  
002D23DE  mov         eax,dword ptr [edx]  
002D23E0  mov         ecx,dword ptr [ebp-0F8h]  
002D23E6  mov         edx,dword ptr [eax]  
002D23E8  call        edx  
002D23EA  cmp         esi,esp  
002D23EC  call        @ILT+445(__RTC_CheckEsp) (2D11C2h)  
002D23F1  mov         dword ptr [ebp-118h],eax  
002D23F7  jmp         main+0E3h (2D2403h)  
002D23F9  mov         dword ptr [ebp-118h],0  
return 0;
002D2403  xor         eax,eax  
}

虛擬函式：

虛擬函式主要是實現了面向物件中的多型的作用.通俗的講就是通過基類的指標指向派生類的物件，用基類的指標來呼叫派生類的成員函式. 這種技術可以讓派生類擁有“多種形態”，這是一種泛型技術, 通過使用不變的程式碼來實現可變的演算法.比如：模版技術, RTTI[Run-Time Type Identification], 虛擬函式技術.
虛擬函式是以virtual關鍵字宣告的基類函式.如果在基類中將某個函式指定為virtual，並且派生類中有該函式的另外一個定義,則編譯器將知道我們不想靜態連結該函式.
當基類中聲明瞭虛擬函式，那麼根據呼叫該函式的當前物件的型別，選擇派生類中出現的該函式的其他定義.
純虛擬函式, 通過在函式宣告最後新增=0,可以將本地C++基類中的虛擬函式定義為純虛擬函式. 那麼該類就稱為不能建立任何物件的抽象類，在任何派生類中，都必須定義所有純虛擬函式.如果不是，則該派生類也將稱為抽象類.
根據虛擬函式定義後的虛擬函式表，基類指標既可以指向派生類的成員，也可以指向基類的成員.
虛擬函式表,
下面部分內容參考陳皓專欄

http://blog.csdn.net/haoel/article/details/1948051

cppVirtualFunctionTable.cpp

#include <iostream>
using std::cout;
using std::endl;

class baseClass
{
public:
	virtual void a(){ cout<<"baseClass function a()"<<endl;}
	virtual void b(){ cout<<"baseClass function b()"<<endl;}
	virtual void c(){ cout<<"baseClass function c()"<<endl;}
};

class deriveClass: public baseClass
{
public:
	void a(){ cout<<"deriveClass function a()"<<endl;}
	void b1(){ cout<<"deriveClass function b1()"<<endl;}
	void c1(){ cout<<"deriveClass function c1()"<<endl;}
};

main.cpp

#include "cppVirtualFunctionTable.cpp"
int main(int argc, char** argv)
{
     // define the Func is an alias for the function pointer.
     typedef void(*Func)(void);

     baseClass cBase;
     Func pFunc = NULL;
     cout<<"虛擬函式表地址："<<(int*)(&cBase)<<endl;
     cout<<"虛擬函式表第一個函式地址："<<(int*)*(int*)(&cBase)<<endl;

     // Invoke first virtual function
     pFunc = (Func)*((int*)*(int*)(&cBase));
     pFunc();
     return 0;
}

環境：Microsoft Visual Studio 2010, Window 7

輸出結果：
虛擬函式表地址：0031fce4
虛擬函式表第一個函式地址：011e7868
baseClass function a()
請按任意鍵繼續. . .
下面是虛擬函式表的詳細情況：

圖1
(int*)(&cBase) //強制轉換cBase物件在記憶體中的內容為int*[0x0031fce4]，它指向cBase物件的第一個成員的地址，即虛擬函式表的地址[0x011e7868]
(int*)*(int*)(&cBase) //對虛擬函式表的地址進行解引用，*(int*)(&cBase)指向的地址就是虛擬函式表的地址，然後轉換為int*,它指向虛擬函式表的第一個成員，即_vfptr[0] ,地址為[0x011e121c]

下面是關於基類地址，以及虛擬函式表、基類成員、派生類成員的詳細分佈：

圖2

從上面的圖中我們可以看到,派生類的成員a()覆蓋了基類的成員a()
C++中的過載、覆蓋、隱藏
1.過載從最簡單的角度來講只發生在物件內部，物件內部同名的函式，但是引數個數或引數型別不同;

2.覆蓋就是上面圖中標示的那種情況;

3.當派生類和基類的函式同名，而且基類同名函式前virtual修飾符,基類的同名函式被隱藏;

“隱藏”是指派生類的函式遮蔽了與其同名的基類函式，規則如下：
（1）如果派生類的函式與基類的函式同名，但是引數不同。此時，不論有無 virtual 關鍵字，基類的函式將被隱藏（注意別與過載混淆）。
（2）如果派生類的函式與基類的函式同名，並且引數也相同，但是基類函式沒有 virtual關鍵字。此時，基類的函式被隱藏（注意別與覆蓋混淆）。

行內函數：
關鍵字inline,功能類似巨集替換，具有函式的結構，在編譯時刻根據函式名來替換成對應的程式碼，在程式碼量小的重複次數多的情況下，比較高效.不是適合複雜程式碼,同時是否能夠實現內聯的功能，具體要依賴編譯器,有可能編譯器根據實際情況當成普通函式來處理.
靜態成員函式：
靜態成員在同類物件中只有一個例項，因此可以用來統計同類物件的計數;
靜態成員函式獨立於類物件，因此即使類物件不存在，靜態成員函式依然可以被呼叫，靜態成員函式只能呼叫靜態成員變數在這樣的情況下.

例項：Singleton模式，保證一個類只有一個例項物件,同時使該例項只有一個全域性訪問點.

C++物件屬性：public, protected, private

共有繼承，基類的公共成員和保護成員可以作為其派生類的公共成員和保護成員.派生類無法訪問基類的私有成員.

私有繼承，基類的共有成員和私有成員都作為其派生類的私有成員.基類的成員只能由直接派生類來訪問，不能再往下繼承。

保護繼承，基類的共有成員和保護成員都作為其派生類的保護成員，基類的共有成員和保護成員只能被其派生類成員和友元函式訪問.

C++語言特性：建構函式,解構函式,虛擬函式,行內函數,靜態成員函式,過載，覆蓋，隱藏

C++語言特性：建構函式,解構函式,虛擬函式,行內函數,靜態成員函式,過載，覆蓋，隱藏

4、【C++】靜態成員變數/靜態成員函式/行內函數/友元函式/友元類/友元成員函式

C/C++之巨集、行內函數和普通函式的區別

c++ 行內函數和constexper函式

行內函數與普通函式有什麼區別

行內函數與巨集函式的區別

行內函數、模板函式之於標頭檔案

c++——函式特性，函式過載，行內函數簡單解釋

個人C++速成筆記（1） -- C++與C不一樣的地方：行內函數、預設引數、函式過載、函式模板、庫函式的呼叫

C++關鍵字、名稱空間、函式過載、預設引數、行內函數、引用

Python函式細節：多數量引數、強制引數傳遞、返回多值、匿名/行內函數

C語言 inline行內函數與帶參巨集

c/c++區別（一）函式的預設值函式過載行內函數 c/c++介面呼叫 const在c/c++的區別

C++:名稱空間、預設引數、函式過載、引用、行內函數

【C++】詳解行內函數（inline）

c++：行內函數

c++中函式的引數傳遞，行內函數和預設實參的理解

在c++中普通函式與行內函數的區別

C++巨集，普通函式，行內函數的執行速度以及三者的差異

C++的行內函數和過載函式

C++語言特性：建構函式,解構函式,虛擬函式,行內函數,靜態成員函式,過載，覆蓋，隱藏

相關推薦