91超碰碰碰碰久久久久久综合_超碰av人澡人澡人澡人澡人掠_国产黄大片在线观看画质优化_txt小说免费全本

溫馨提示×

溫馨提示×

您好,登錄后才能下訂單哦!

密碼登錄×
登錄注冊×
其他方式登錄
點擊 登錄注冊 即表示同意《億速云用戶服務條款》

C++直接初始化與復制初始化的區別有哪些

發布時間:2021-11-24 10:23:10 來源:億速云 閱讀:122 作者:iii 欄目:互聯網科技

這篇文章主要介紹“C++直接初始化與復制初始化的區別有哪些”,在日常操作中,相信很多人在C++直接初始化與復制初始化的區別有哪些問題上存在疑惑,小編查閱了各式資料,整理出簡單好用的操作方法,希望對大家解答”C++直接初始化與復制初始化的區別有哪些”的疑惑有所幫助!接下來,請跟著小編一起來學習吧!

一、Primer中的說法

首先我們現來看看經典是怎么說的:

“當用于類類型對象時,初始化的復制形式和直接形式有所不同:直接初始化直接調用與實參匹配的構造函數,復制初始化總是調用復制構造函數。復制初始化首先使用指定構造函數創建一個臨時對象,然后用復制構造函數將那個臨時對象復制到正在創建的對象”

還有一段這樣說:

“通常直接初始化和復制初始化僅在低級別優化上存在差異,然而,對于不支持復制的類型,或者使用非explicit構造函數的時候,它們有本質區別:

1

2

ifstream file1(          "filename"          ):          //ok:direct initialization        

ifstream file2 =          "filename"          ;          //error:copy constructor is private”        

二、通常的誤解

從上面的說法中,我們可以知道,直接初始化不一定要調用復制構造函數,而復制初始化一定要調用復制構造函數。然而大多數人卻認為,直接初始化是構造對象時要調用復制構造函數,而復制初始化是構造對象時要調用賦值操作函數(operator=),其實這是一大誤解。因為只有對象被創建才會出現初始化,而賦值操作并不應用于對象的創建過程中,且primer也沒有這樣的說法。至于為什么會出現這個誤解,可能是因為復制初始化的寫法中存在等號(=)吧。

為了把問題說清楚,還是從代碼上來解釋比較容易讓人明白,請看下面的代碼:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

#include <iostream>        

#include <cstring>        

using          namespace          std;        

  

class          ClassTest        

{        

public          :        

ClassTest()        

{        

c[0] =          '\0'          ;        

cout<<          "ClassTest()"          <<endl;        

}        

ClassTest& operator=(          const          ClassTest &ct)        

{        

strcpy          (c, ct.c);        

cout<<          "ClassTest& operator=(const ClassTest &ct)"          <<endl;        

return          *          this          ;        

}        

ClassTest(          const          char          *pc)        

{        

strcpy          (c, pc);        

cout<<          "ClassTest (const char *pc)"          <<endl;        

}        

// private:        

ClassTest(          const          ClassTest& ct)        

{        

strcpy          (c, ct.c);        

cout<<          "ClassTest(const ClassTest& ct)"          <<endl;        

}        

private          :        

char          c[256];        

};        

  

int          main()        

{        

cout<<          "ct1: "          ;        

ClassTest ct1(          "ab"          );          //直接初始化        

cout<<          "ct2: "          ;        

ClassTest ct2 =          "ab"          ;          //復制初始化        

cout<<          "ct3: "          ;        

ClassTest ct3 = ct1;          //復制初始化        

cout<<          "ct4: "          ;        

ClassTest ct4(ct1);          //直接初始化        

cout<<          "ct5: "          ;        

ClassTest ct5 = ClassTest();          //復制初始化        

return          0;        

}        

輸出結果為:

C++直接初始化與復制初始化的區別有哪些

從輸出的結果,我們可以知道對象的構造到底調用了哪些函數,從ct1與ct2、ct3與ct4的比較中可以看出,ct1與ct2對象的構建調用的都是同一個函數——ClassTest(const char *pc),同樣道理,ct3與ct4調用的也是同一個函數——ClassTest(const ClassTest& ct),而ct5則直接調用了默認構造函數。

于是,很多人就認為ClassTest ct1("ab");等價于ClassTest ct2 = "ab";,而ClassTest ct3 = ct1;也等價于ClassTest ct4(ct1);而且他們都沒有調用賦值操作函數,所以它們都是直接初始化,然而事實是否真的如你所想的那樣呢?答案顯然不是。

三、層層推進,到底誰欺騙了我們

很多時候,自己的眼睛往往會欺騙你自己,這里就是一個例子,正是你的眼睛欺騙了你。為什么會這樣?其中的原因在談優化時的補充中也有說明,就是因為編譯會幫你做很多你看不到,你也不知道的優化,你看到的結果,正是編譯器做了優化后的代碼的運行結果,并不是你的代碼的真正運行結果。

你也許不相信我所說的,那么你可以把類中的復制函數函數中面注釋起來的那行取消注釋,讓復制構造函數成為私有函數再編譯運行這個程序,看看有什么結果發生。

很明顯,發生了編譯錯誤,從上面的運行結果,你可能會認為是因為ct3和ct4在構建過程中用到了復制構造函數——ClassTest(const ClassTest& ct),而現在它變成了私有函數,不能在類的外面使用,所以出現了編譯錯誤,但是你也可以把ct3和ct4的函數語句注釋起來,如下所示:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

int          main()        

{        

cout<<          "ct1: "          ;        

ClassTest ct1(          "ab"          );        

cout<<          "ct2: "          ;        

ClassTest ct2 =          "ab"          ;        

// cout<<"ct3: ";        

// ClassTest ct3 = ct1;        

// cout<<"ct4: ";        

// ClassTest ct4(ct1);        

cout<<          "ct5: "          ;        

ClassTest ct5 = ClassTest();        

return          0;        

}        

然而你還是非常遺憾地發現,還是沒有編譯通過。這是為什么呢?從上面的語句和之前的運行結果來看,的確是已經沒有調用復制構造函數了,為什么還是編譯錯誤呢?

經過實驗,main函數只有這樣才能通過編譯:

1

2

3

4

5

6

int          main()        

{        

cout<<          "ct1: "          ;        

ClassTest ct1(          "ab"          );        

return          0;        

}        

在這里我們可以看到,原來是復制構造函數欺騙了我們。

四、揭開真相

看到這里,你可能已經大驚失色,下面就讓我來揭開這個真相吧!

還是那一句,什么是直接初始化,而什么又是復制初始化呢?

簡單點來說,就是定義對象時的寫法不一樣,一個用括號,如ClassTest ct1("ab"),而一個用等號,如ClassTest ct2 = "ab"。

但是從本質來說,它們卻有本質的不同:直接初始化直接調用與實參匹配的構造函數,復制初始化總是調用復制構造函數。復制初始化首先使用指定構造函數創建一個臨時對象,然后用復制構造函數將那個臨時對象復制到正在創建的對象。所以當復制構造函數被聲明為私有時,所有的復制初始化都不能使用。

現在我們再來看回main函數中的語句:

1、ClassTest ct1("ab");這條語句屬于直接初始化,它不需要調用復制構造函數,直接調用構造函數ClassTest(const char *pc),所以當復制構造函數變為私有時,它還是能直接執行的。

2、ClassTest ct2 = "ab";這條語句為復制初始化,它首先調用構造函數ClassTest(const char *pc)函數創建一個臨時對象,然后調用復制構造函數,把這個臨時對象作為參數,構造對象ct2;所以當復制構造函數變為私有時,該語句不能編譯通過。

3、ClassTest ct3 = ct1;這條語句為復制初始化,因為ct1本來已經存在,所以不需要調用相關的構造函數,而直接調用復制構造函數,把它值復制給對象ct3;所以當復制構造函數變為私有時,該語句不能編譯通過。

4、ClassTest ct4(ct1);這條語句為直接初始化,因為ct1本來已經存在,直接調用復制構造函數,生成對象ct3的副本對象ct4。所以當復制構造函數變為私有時,該語句不能編譯通過。

注:第4個對象ct4與第3個對象ct3的創建所調用的函數是一樣的,但是本人卻認為,調用復制函數的原因卻有所不同。因為直接初始化是根據參數來調用構造函數的,如ClassTest ct4(ct1),它是根據括號中的參數(一個本類的對象),來直接確定為調用復制構造函數ClassTest(const ClassTest& ct),這跟函數重載時,會根據函數調用時的參數來調用相應的函數是一個道理;而對于ct3則不同,它的調用并不是像ct4時那樣,是根據參數來確定要調用復制構造函數的,它只是因為初始化必然要調用復制構造函數而已。它理應要創建一個臨時對象,但只是這個對象卻已經存在,所以就省去了這一步,然后直接調用復制構造函數,因為復制初始化必然要調用復制構造函數,所以ct3的創建仍是復制初始化。

5、ClassTest ct5 = ClassTest();這條語句為復制初始化,首先調用默認構造函數產生一個臨時對象,然后調用復制構造函數,把這個臨時對象作為參數,構造對象ct5。所以當復制構造函數變為私有時,該語句不能編譯通過。

五、假象產生的原因

產生上面的運行結果的主要原因在于編譯器的優化,而為什么把復制構造函數聲明為私有(private)就能把這個假象去掉呢?主要是因為復制構造函數是可以由編譯默認合成的,而且是公有的(public),編譯器就是根據這個特性來對代碼進行優化的。然而如里你自己定義這個復制構造函數,編譯則不會自動生成,雖然編譯不會自動生成,但是如果你自己定義的復制構造函數仍是公有的話,編譯還是會為你做同樣的優化。然而當它是私有成員時,編譯器就會有很不同的舉動,因為你明確地告訴了編譯器,你明確地拒絕了對象之間的復制操作,所以它也就不會幫你做之前所做的優化,你的代碼的本來面目就出來了。

舉個例子來說,就像下面的語句:

1

ClassTest ct2 =          "ab"          ;        

它本來是要這樣來構造對象的:首先調用構造函數ClassTest(const char *pc)函數創建一個臨時對象,然后調用復制構造函數,把這個臨時對象作為參數,構造對象ct2。然而編譯也發現,復制構造函數是公有的,即你明確地告訴了編譯器,你允許對象之間的復制,而且此時它發現可以通過直接調用重載的構造函數ClassTest(const char *pc)來直接初始化對象,而達到相同的效果,所以就把這條語句優化為ClassTest ct2("ab")。

而如果把復制構造函數聲明為私有的,則對象之前的復制不能進行,即不能把臨時對像作為參數,調用復制構造函數,所以編譯就認為ClassTest ct2 = "ab"與ClassTest ct2("ab")是不等價的,也就不會幫你做這個優化,所以編譯出錯了。

注:根據上面的代碼,有些人可能會運行出與本人測試不一樣的結果,這是為什么呢?就像前面所說的那樣,編譯器會為代碼做一定的優化,但是不同的編譯器所作的優化的方案卻可能有所不同,所以當你使用不同的編譯器時,由于這些優化的方案不一樣,可能會產生不同的結果,我這里用的是g++4.7。

到此,關于“C++直接初始化與復制初始化的區別有哪些”的學習就結束了,希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習,快去試試吧!若想繼續學習更多相關知識,請繼續關注億速云網站,小編會繼續努力為大家帶來更多實用的文章!

向AI問一下細節

免責聲明:本站發布的內容(圖片、視頻和文字)以原創、轉載和分享為主,文章觀點不代表本網站立場,如果涉及侵權請聯系站長郵箱:is@yisu.com進行舉報,并提供相關證據,一經查實,將立刻刪除涉嫌侵權內容。

c++
AI

福贡县| 阿荣旗| 浮梁县| 石家庄市| 淮南市| 嵊州市| 东乌珠穆沁旗| 乌拉特后旗| 彰化市| 山阳县| 南安市| 宜兰市| 东莞市| 民和| 措勤县| 彩票| 成武县| 波密县| 旬阳县| 万安县| 桃江县| 荥阳市| 海安县| 北辰区| 德钦县| 望谟县| 南川市| 大方县| 泰和县| 怀柔区| 衡阳县| 长垣县| 茂名市| 嘉峪关市| 雅江县| 金溪县| 珲春市| 咸宁市| 巨鹿县| 长葛市| 通江县|