c++中的函數重載、函數重寫、函數重定義

時間 2020-03-01

標籤 c++ 函數重載重寫定義欄目 C&C++ 简体版

原文原文鏈接

1、函數重載（Function Overloading）　

一、什麼是函數重載

　　在同一個類中（同一個做用域中/在類的內部），存在一組函數名相同，函數的參數列表不一樣（參數的個數、類型、順序），函數有無 virtual 關鍵字均可以，咱們把這組函數稱爲函數重載。

二、爲何使用函數重載（函數重載的好處）

　　因爲函數重載能夠在同一個做用域內，使用同一個函數名命名一組功能類似的函數，這樣作減小了函數名的數量，避免了程序員因給函數名命名所帶來的煩惱，從而提升程序的開發的效率。.net

三、函數重載的條件

　　1. 必須在同一做用域下3d

　　2. 函數名相同可是參數列表不一樣

　　3. 返回值的類型不會影響重載

　　4. const屬性相同

四、函數重載的原理（本質：c++編譯器對同名函數進行重命名）

　　編譯器在編譯.cpp文件中當前使用的做用域裏的同名函數時，根據函數形參的類型和順序會對函數進行重命名（不一樣的編譯器在編譯時對函數的重命名標準不同）；

　　可是總的來講，他們都把文件中的同一個函數名進行了重命名；

在vs編譯器中：

　　根據返回值類型（不起決定性做用）+形參類型和順序（起決定性做用）的規則重命名並記錄在map文件中。

在linux g++ 編譯器中：

　　根據函數名字的字符數+形參類型和順序的規則重命名記錄在符號表中；從而產生不一樣的函數名，當外面的函數被調用時，即是根據這個記錄的結果去尋找符合要求的函數名,進行調用；

　　爲何c語言不能實現函數重載？

　　編譯器在編譯.c文件時，只會給函數進行簡單的重命名；

　　具體的方法是給函數名以前加上」_」；因此加入兩個函數名相同的函數在編譯以後的函數名也照樣相同；調用者會由於不知道到底調用那個而出錯；

 1 #include<stdio.h>
 2 
 3 int Add(int a, int b)
 4 {
 5     return a + b;
 6 }
 7 
 8 
 9 float Add(float a, float b)
10 {
11     return a + b;
12 }
13 
14 void testFunc()
15 {
16     Add(10, 20);
17     Add(20.0f, 30.0f);
18 }
19 
20 int main(int argc, char *argv[])
21 {
22     testFunc();
23 
24     return 0;
25 }

案例分析

1. 將上述代碼保存到.c文件中

　　若上述代碼用c編譯器編譯，因爲c語言中無函數重載，因此，在程序運行時出錯。

　　出錯緣由：由於在c語言中，c編譯器只是在函數名的前面加下劃線進行簡單的重命名；

　　爲了驗證結果，將上述的代碼稍做修改（ float Add(float a, float b) -> float Add1(float a, float b) ）。而後用 vs Debug模式編譯.c文件，以後在.map文件中就能夠看到結果。

　　在vs中，map文件生成的步驟設置：工程名右擊—>屬性—->配置屬性—->連接器—–>調試—->生成映射文件—>選擇是;

2. 將上述代碼保存到.cpp文件中

　　若上述代碼用c++編譯器編譯，因爲c++語言支持函數重載，因此程序正常運行；可是，在不一樣c++編譯器之間對函數重載的機制也是不同，接下來分別用vs 和 g++介紹。

（1）用 vs Debug模式編譯.cpp文件，以後就能夠在map文件中看到以下結果，

　　// ‘？’表示名稱開始，‘？’後邊是函數名；「@@YA」表示參數表開始，後邊的3個字符分別表示返回值類型，兩個參數類型；「@Z」表示名稱結束。

（2）在Ubuntu下測試（須要安裝g++編譯器），執行如下指令：

　　1）g++ test.cpp

　　2）objdump a.out -t > test.out // -t是表示生成符號表，最後是將生成的符號表用重定向符號放在test.out文件。

　　3）vi test.out

　　打開test.out文件，就會發現，整形數相加的函數Add(int a,int b)生成的符號表中，Add函數名被記錄爲_Z3Addii。

　　其中，_Z表示符號表名稱開始, 3表明函數名的字符個數，ii表明參數列表順序中2個形參的類型；

綜述，不管使用何種編譯器，在.cpp文件中，雖然兩個函數的函數名同樣，可是他們在符號表中生成的名稱不同，因此是能夠編譯經過的。

由上述分析可知，c編譯器與 c++編譯器對函數的重命名規則不同；那麼，在c++中如何確保將一段c代碼以c編譯器的方式被編譯呢？---- 使用 extern 關鍵字

 1 // 使用方式1
 2 extern "C"
 3 {
 4       // C-Style Compilation
 5 }
 6 
 7 // 使用方式2
 8 //__cplusplus 是 c++ 編譯器內置的標準宏定義
 9 //__cplusplus 的意義：確保C代碼以統一的C方式被編譯成目標文件
10 
11 #ifdef __cplusplus
12 extern "C" {
13 #endif
14 
15 // C-Style Compilation
16 
17 #ifdef __cplusplus
18 }
19 #endif

extern "C" 的使用方式

參考連接：https://blog.csdn.net/qq_37791134/article/details/81502017、https://blog.csdn.net/gogogo_sky/article/details/71189499、https://blog.csdn.net/fantian_/article/details/80719144

五、函數重載的結論

　　1. 函數重載的本質：多個不一樣的函數；

　　2. 函數名和參數列表是惟一的標識；

　　3. 函數重載必須發生在同一個做用域中；

　　4. c++編譯器和 c編譯器對函數重命名的規則不一樣；

　　5. 編譯器決定符號表中函數名被編譯後的最終目標名；

　　　　c++ 編譯器將函數名和參數列表編譯成目標名；

　　　　c 編譯器將函數名編譯成目標名；

　　6. 函數重載是在編譯期間根據參數類型和個數決定函數調用

　　7. 函數重載是一種靜態多態；

　　（1）多態：用同一個東西表示不一樣的形態；

　　（2）多態分爲：靜態多態（編譯時的多態）、動態多態（運行時的多態）；

六、編譯器調用函數重載的規則

　　1. 將全部同名函數做爲候選者；

　　2. 嘗試尋找可行的候選者函數

　　（1）精確匹配實參；

　　（2）經過默認參數可以匹配實參；

　　（3）經過默認類型轉換匹配實參；

　　3. 匹配失敗

　　（1）最終尋找的候選函數不惟一，則出現二義性，編譯失敗；

　　（2）沒法匹配全部的候選函數，函數沒定義，編譯失敗；

七、函數重載與默認參數

　　當函數重載遇到默認參數時，就會發生二義性；

　　代碼以下：　　

 1 #include<iostream>
 2 using namespace std;
 3 
 4 class A
 5 {
 6     void func(int a, int b, int c = 0) {}
 7     void func(int a, int b) {}
 8 };
 9 
10 int main()
11 {
12     A a;
13     a.func(1, 2); // 二義性出現
14 
15     return 0;
16 }

函數重載的二義性案例

八、函數重載與函數指針

　　將重載函數名賦值給函數指針時，

　　1. 根據重載規則挑選與函數指針參數列表一致的候選者；

　　2. 嚴格匹配候選者的函數類型與函數指針的函數類型；

 1 #include <stdio.h>
 2 #include <string.h>
 3 
 4 int func(int x)
 5 {
 6     return x;
 7 }
 8 
 9 int func(int a, int b)
10 {
11     return a + b;
12 }
13 
14 int func(const char* s)
15 {
16     return strlen(s);
17 }
18 
19 typedef int(*PFUNC)(int a);
20 
21 
22 int main(int argc, char *argv[])
23 {
24     int c = 0;
25 
26     PFUNC p = func;
27         
28     c = p(1);   
29     
30     printf("c = %d\n", c);    // c = 1
31 
32     return 0;
33 }

函數重載與函數指針

2、函數重寫（也稱爲覆蓋， Function override）

一、什麼是函數重寫

　　函數重寫分爲虛函數重寫（會發生多態）與非虛函數重寫（重定義的一種形式）；

　　函數重寫：也叫作覆蓋。子類從新定義父類中有相同返回值、名稱和參數的虛函數。函數特徵相同。可是具體實現不一樣，主要是在繼承關係中出現的。

　　注：通常而言，函數重寫就是虛函數重寫，爲的是實現多態調用；

二、函數重寫的條件

　　1. 函數的返回類型、方法名、參數列表徹底相同；

　　2. 必須發生在不一樣的做用域中（基類與派生類中）；

　　3. 基類中有 virtual 關鍵字聲明，派生類中無關緊要，不能有 static （虛函數重寫）；

三、函數重寫的意義

　　在面向對象的繼承關係中，咱們瞭解到子類能夠擁有父類中的全部屬性與行爲；可是，有時父類中提供的方法並不能知足現有的需求，因此，咱們必須在子類中重寫父類中已有的方法，來知足當前的需求。

3、函數重定義（也稱爲隱藏，Function redefining）

一、什麼是函數重定義

　　子類從新定義父類中有相同名稱的函數 ( 不包括虛函數重寫 ) 。

二、重定義的表現形式

　　1. 必須發生在不一樣的做用域中（基類與派生類中）；

　　2. 函數名相同；

　　3. 返回值能夠不一樣；

　　4. 參數列表不一樣，此時，不管基類中的同名函數有無 virtual 關鍵字，基類中的同名函數都會被隱藏。

　　5. 參數列表相同，此時，基類中的同名函數沒有 virtual 關鍵字，則基類中的同名函數將會被隱藏 --- 非虛函數重寫。

三、關於同名覆蓋的結論（概括：基類與派生類中存在同名成員；--- 同名覆蓋）

　　1. 子類將隱藏父類中的同名成員；

　　2. 父類中的同名成員依然存在於子類中；

　　3. 能夠經過做用域分辨符(::)訪問被隱藏的父類中的同名成員；

　　4. 不能夠直接經過子類對象訪問父類成員；

　　　注：同名覆蓋規則適用於類的成員變量與成員函數；

　　相關代碼展現：

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 class Parent
 7 {
 8 public:
 9     int mi;
10     
11     Parent()
12     {
13         cout << "Parent() : " << "&mi = " << &mi << endl;
14     }
15 };
16 
17 class Child : public Parent
18 {
19 public:
20     int mi;
21     
22     Child()
23     {
24         cout << "Child() : " << "&mi = " << &mi << endl;
25     }
26 };
27 
28 int main()
29 {
30     Child c;
31     
32     c.mi = 100;    
33         
34     c.Parent::mi = 1000;
35     
36     cout << "&c.mi = " << &c.mi << endl;
37     cout << "c.mi = " << c.mi << endl;
38     
39     cout << "&c.Parent::mi = " << &c.Parent::mi << endl;
40     cout << "c.Parent::mi = " << c.Parent::mi << endl;
41     
42     return 0;
43 }
44 
45 /**
46 * Parent() : &mi = 0x7ffe98191450
47 * Child() : &mi = 0x7ffe98191454
48 * &c.mi = 0x7ffe98191454
49 * c.mi = 100
50 * &c.Parent::mi = 0x7ffe98191450
51 * c.Parent::mi = 1000
52 */

同名成員變量案例

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 class Parent
 7 {
 8 public:
 9     int mi;
10     
11     void add(int v)
12     {
13         mi += v;
14     }
15     
16     void add(int a, int b)
17     {
18         mi += (a + b);
19     }
20 };
21 
22 class Child : public Parent
23 {
24 public:
25     int mi;
26     
27     void add(int v)
28     {
29         mi += v;
30     }
31     
32     void add(int a, int b)
33     {
34         mi += (a + b);
35     }
36     
37     void add(int x, int y, int z)
38     {
39         mi += (x + y + z);
40     }
41 };
42 
43 int main()
44 {
45     Child c;
46     
47     c.mi = 100;        
48     c.Parent::mi = 1000;
49     
50     cout << "c.mi = " << c.mi << endl;    
51     cout << "c.Parent::mi = " << c.Parent::mi << endl;
52     
53     c.add(1);
54     c.add(2, 3);
55     c.add(4, 5, 6);
56     c.Parent::add(10);
57     c.Parent::add(11, 12);
58     
59     cout << "c.mi = " << c.mi << endl;    
60     cout << "c.Parent::mi = " << c.Parent::mi << endl;
61     
62     return 0;
63 }
64 /**
65 * c.mi = 100
66 * c.Parent::mi = 1000
67 * c.mi = 121
68 * c.Parent::mi = 1033
69 */

重定義案例

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 class Parent
 7 {
 8 public:
 9     int mi;
10     
11     virtual void add(int v)
12     {
13         mi += v;
14     }
15 };
16 
17 class Child : public Parent
18 {
19 public:
20     int mi;
21     
22     virtual void add(int v)
23     {
24         mi += v;
25     }
26     
27     void add(int a, int b)
28     {
29         mi += (a + b);
30     }
31 };
32 
33 int main()
34 {
35     Child c;
36     Parent &p = c;  // 父類引用指向子類對象，多態發生
37     
38     c.mi = 100;     
39     c.Parent::mi = 1000;
40     
41     cout << "c.mi = " << c.mi << endl;   
42     cout << "c.Parent::mi = " << c.Parent::mi << endl;
43     
44     c.add(1);
45     c.add(2, 3);
46     p.add(100);     // 實際調用的是子類中 add(int v) 函數
47     c.Parent::add(10);
48      
49     cout << "c.mi = " << c.mi << endl;   // c.mi = 1 + 2 + 3 + 100
50     cout << "c.Parent::mi = " << c.Parent::mi << endl; // c.Parent::mi = 1000 + 10
51     
52     return 0;
53 }
54 /**
55 * c.mi = 100
56 * c.Parent::mi = 1000
57 * c.mi = 206
58 * c.Parent::mi = 1010
59 */