2. 程式人生 > >C++中建構函式，拷貝建構函式，解構函式

C++中建構函式，拷貝建構函式，解構函式

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

C++中預設建構函式就是沒有形參的建構函式。準確的說法，按照《C++ Primer》中定義：只要定義一個物件時沒有提供初始化式，就是用預設建構函式。為所有 的形參提供預設實參的建構函式也定義了預設建構函式。

合成的預設建構函式，即編譯器自動生成的預設建構函式。《C++ Primer》中的說明：一個類哪怕只定義了一個建構函式，編譯器也不會再生成預設建構函式。這條規則的根據是，如果一個類再某種情況下需要控制物件初始化，則該類很可能在所有情況下都需要控制。只有當一個類沒有定義建構函式時，編譯器才會自動生成一個預設建構函式。

需要注意的是自定義的建構函式包括拷貝建構函式。就是說在下面這種情況下，編譯器也不會自動生成預設建構函式，程式碼會出錯。把拷貝建構函式刪除掉後就沒有問題了。

編譯器為類自動生成的函式包括預設建構函式，拷貝建構函式，解構函式，賦值函式。但是如果自己定義了拷貝建構函式，那麼預設建構函式編譯器就不會自動生成了。但是自己定義了預設建構函式時其他函式都會自動生成。

注意拷貝建構函式的引數型別為const Base &型別。&是必須的很容易理解，需要傳遞引用才行。至於const引數在g++中不加在編譯時會報錯，在vs中能通過編譯。不過建議還是加上，因為傳遞的是引用，根據原物件構造新的物件時當然不希望將原物件改變。

#include <iostream>

using namespace std;

class Base{
public:
	//建構函式
	//Base(){
	//	cout<<"default constructor invoke!"<<endl;
	//}
	//Base(int d){
	//	this->data=d;
	//	cout<<"constructor invoke!"<<endl;
	//}
	//拷貝建構函式
	Base(const Base &b){
		cout<<"copy constructor invoke!"<<endl;
		this->data=b.data;
	}
	//賦值操作符
	Base & operator=(const Base &b){
		cout<<"operator constructor invoke!"<<endl;
		this->data=b.data;
	}
	//7構函式
	~Base(){
		cout<<"deconstructor invoke!"<<endl;
	}
private:
	int data;

};

int main(){

	Base b;
	return 0;
}
首先使用下面的程式碼測試，預設建構函式，建構函式，拷貝建構函式，賦值操作符的呼叫： 
#include <iostream>

using namespace std;

class Base{
public:
	//建構函式
	Base(){
		cout<<"default constructor invoke!"<<endl;
	}
	Base(int d){
		this->data=d;
		cout<<"constructor invoke!"<<endl;
	}
	//拷貝建構函式
	Base(const Base &b){
		cout<<"copy constructor invoke!"<<endl;
		this->data=b.data;
	}
	//賦值操作符
	void  operator=(const Base &b){
		cout<<"operator constructor invoke!"<<endl;
		this->data=b.data;
	}
	//解構函式
	~Base(){
		cout<<"deconstructor invoke!"<<endl;
	}

private:
	int data;

};

int main(){

	Base b(1);//建構函式呼叫

	Base b2=b;//拷貝建構函式呼叫

	Base b3;//預設建構函式呼叫
	b3=b;//賦值操作符呼叫

	return 0;
}
執行結果如下：

在g++和vs中執行的結果都是一樣的。

然後新增一個函式呼叫來測試：

#include <iostream>

using namespace std;

class Base{
	public:
		//建構函式
		Base(){
			cout<<"default constructor invoke!"<<endl;
		}
		Base(int d){
			this->data=d;
			cout<<"constructor invoke!"<<endl;
		}
		//拷貝建構函式
		Base(const Base &b){
			cout<<"copy constructor invoke!"<<endl;
			this->data=b.data;
		}
		//賦值操作符
		void  operator=(const Base &b){
			cout<<"operator constructor invoke!"<<endl;
			this->data=b.data;
		}
		//7構函式
		~Base(){
			cout<<"deconstructor invoke!"<<endl;
		}

		Base play(Base b){
			return b;
		}
	private:
		int data;

};

int main(){

	Base b(1);//建構函式呼叫

	Base b2=b;//拷貝建構函式呼叫

	Base b3;//預設建構函式呼叫
	b3=b;//賦值操作符呼叫

	b.play(2);//建構函式呼叫，拷貝建構函式呼叫（由於函式返回引起的）

	return 0;
}
結果如下：函式b.play(2)執行時，首先會使用建構函式（即接受一個int型變數的建構函式）進行隱式的型別轉換，即呼叫一次建構函式。注意,如果play的形參是B&型別的話，就不可以這樣做。否則會出錯。


然後使用直接呼叫時：

#include <iostream>

using namespace std;

class Base{
	public:
		//建構函式
		Base(){
			cout<<"default constructor invoke!"<<endl;
		}
		Base(int d){
			this->data=d;
			cout<<"constructor invoke!"<<endl;
		}
		//拷貝建構函式
		Base(const Base &b){
			cout<<"copy constructor invoke!"<<endl;
			this->data=b.data;
		}
		//賦值操作符
		void  operator=(const Base &b){
			cout<<"operator constructor invoke!"<<endl;
			this->data=b.data;
		}
		//7構函式
		~Base(){
			cout<<"deconstructor invoke!"<<endl;
		}

		Base play(Base  b){
			return b;
		}
	private:
		int data;

};

int main(){

	Base b(1);//建構函式呼叫

	Base b2=b;//拷貝建構函式呼叫

	Base b3;//預設建構函式呼叫
	b3=b;//賦值操作符呼叫

	b.play(2);//建構函式呼叫，拷貝建構函式呼叫（由於函式返回引起的）
	b.play(b);//<span style="font-size: 11.8181819915771px; font-family: Arial, Helvetica, sans-serif;">第一次拷貝建構函式呼叫是構造形參，第二次拷貝建構函式呼叫是函式返回值</span>

	return 0;
}
輸出結構如下：


最開始也不明白為什麼是兩次拷貝建構函式呼叫。那麼打印出每個物件的地址吧。

vs中的結果：


g++中的結果，可以發現g++中的結果引數進棧的順序還是有規律的，但是vs好像就沒有規律了。

這樣還是看不明白，但是和下面程式碼的這種情況進行比較就比較容易理解了：

#include <iostream>

using namespace std;

class Base{
public:
	//建構函式
	Base(){
		cout<<"default constructor invoke!"<<(int *)this<<endl;
	}
	Base(int d){
		this->data=d;
		cout<<"constructor invoke!"<<(int *)this<<endl;
	}
	//拷貝建構函式
	Base(const Base &b){
		cout<<"copy constructor invoke!"<<(int *)this<<endl;
		this->data=b.data;
	}
	//賦值操作符
	void  operator=(const Base &b){
		cout<<"operator constructor invoke!"<<(int *)this<<endl;
		this->data=b.data;
	}
	//7構函式
	~Base(){
		cout<<"deconstructor invoke!"<<(int *)this<<endl;
	}

	Base play(Base  b){
		return b;
	}
private:
	int data;

};

int main(){

	Base b(1);//建構函式呼叫

	Base b2=b;//拷貝建構函式呼叫

	Base b3;//預設建構函式呼叫
	b3=b;//賦值操作符呼叫

	b.play(2);//建構函式呼叫，拷貝建構函式呼叫（由於函式返回引起的）
	b.play(b);//第一次拷貝建構函式呼叫是構造形參，第二次拷貝建構函式呼叫是函式返回值

	cout<<"---------------"<<endl;
	Base b4=b.play(2);
	cout<<"---------------"<<endl;
	Base b5=b.play(b);
	cout<<"---------------"<<endl;
	return 0;
}
g++中執行結果為：

可以發現Base b4=b.play(2);和b.play(2);這行程式碼相比，解構函式的位置發生了變化，之前是連續兩次析構，現在換成了先析構一次，然後函式結束後又析構一次。並且是第二次拷貝建構函式建立的物件在函式結束後析構的（根據物件的地址可以得知）。那麼情況可能是這樣的，即第二次拷貝建構函式是由於函式返回物件時引起的。因為在函式play呼叫結束後形參b會被析構掉，所以需要將b複製到一個新的記憶體區域。呼叫b.play(2)時的記憶體佈局可能是這樣的（根據上面的地址繪製）：


為了驗證這個測試，可以讓play函式不返回B的物件，程式碼如下：

#include <iostream>

using namespace std;

class Base{
public:
	//建構函式
	Base(){
		cout<<"default constructor invoke!"<<(int *)this<<endl;
	}
	Base(int d){
		this->data=d;
		cout<<"constructor invoke!"<<(int *)this<<endl;
	}
	//拷貝建構函式
	Base(const Base &b){
		cout<<"copy constructor invoke!"<<(int *)this<<endl;
		this->data=b.data;
	}
	//賦值操作符
	void  operator=(const Base &b){
		cout<<"operator constructor invoke!"<<(int *)this<<endl;
		this->data=b.data;
	}
	//7構函式
	~Base(){
		cout<<"deconstructor invoke!"<<(int *)this<<endl;
	}

	void play(Base  b){
		
	}
private:
	int data;

};

int main(){

	Base b(1);//建構函式呼叫

	Base b2=b;//拷貝建構函式呼叫

	Base b3;//預設建構函式呼叫
	b3=b;//賦值操作符呼叫

	b.play(2);//建構函式呼叫
	b.play(b);//呼叫一次拷貝建構函式

	return 0;
}
可以發現少了一次拷貝建構函式的呼叫：


最後再來看看函式引數為引用的時候的情況，這種情況下不會再建立形參，函式是直接對實參進行操作：

#include <iostream>

using namespace std;

class Base{
public:
	//建構函式
	Base(){
		cout<<"default constructor invoke!"<<(int *)this<<endl;
	}
	Base(int d){
		this->data=d;
		cout<<"constructor invoke!"<<(int *)this<<endl;
	}
	//拷貝建構函式
	Base(const Base &b){
		cout<<"copy constructor invoke!"<<(int *)this<<endl;
		this->data=b.data;
	}
	//賦值操作符
	void  operator=(const Base &b){
		cout<<"operator constructor invoke!"<<(int *)this<<endl;
		this->data=b.data;
	}
	//7構函式
	~Base(){
		cout<<"deconstructor invoke!"<<(int *)this<<endl;
	}

	void play(Base  b){
		
	}
	void refer(Base  b){
		cout<<"refer address:"<<(int *)&b<<endl;
	}
private:
	int data;

};

int main(){

	Base b(1);//建構函式呼叫

	Base b2=b;//拷貝建構函式呼叫

	Base b3;//預設建構函式呼叫
	b3=b;//賦值操作符呼叫

	b.play(b);//只會呼叫拷貝建構函式
	b.play(2);//建構函式呼叫

	cout<<"-----------------"<<endl;
	b.refer(b);
	cout<<"-----------------"<<endl;
	return 0;
}
執行結果為：



refer函式引數為引用返回物件時：

#include <iostream>

using namespace std;

class Base{
public:
	//建構函式
	Base(){
		cout<<"default constructor invoke!"<<(int *)this<<endl;
	}
	Base(int d){
		this->data=d;
		cout<<"constructor invoke!"<<(int *)this<<endl;
	}
	//拷貝建構函式
	Base(const Base &b){
		cout<<"copy constructor invoke!"<<(int *)this<<endl;
		this->data=b.data;
	}
	//賦值操作符
	void  operator=(const Base &b){
		cout<<"operator constructor invoke!"<<(int *)this<<endl;
		this->data=b.data;
	}
	//7構函式
	~Base(){
		cout<<"deconstructor invoke!"<<(int *)this<<endl;
	}

	void play(Base  b){
		
	}

	Base refer(Base & b){
		cout<<"refer address:"<<(int *)&b<<endl;
		return b;
	}
private:
	int data;

};

int main(){

	Base b(1);//建構函式呼叫

	Base b2=b;//拷貝建構函式呼叫

	Base b3;//預設建構函式呼叫
	b3=b;//賦值操作符呼叫

	b.play(b);//只會呼叫拷貝建構函式
	b.play(2);//建構函式呼叫

	cout<<"-----------------"<<endl;
	b.refer(b);
	cout<<"-----------------"<<endl;
	return 0;
}
依然呼叫了拷貝建構函式來複制返回值：



refer函式引數為引用並且返回引用時，才不會呼叫拷貝建構函式：

#include <iostream>

using namespace std;

class Base{
public:
	//建構函式
	Base(){
		cout<<"default constructor invoke!"<<(int *)this<<endl;
	}
	Base(int d){
		this->data=d;
		cout<<"constructor invoke!"<<(int *)this<<endl;
	}
	//拷貝建構函式
	Base(const Base &b){
		cout<<"copy constructor invoke!"<<(int *)this<<endl;
		this->data=b.data;
	}
	//賦值操作符
	void  operator=(const Base &b){
		cout<<"operator constructor invoke!"<<(int *)this<<endl;
		this->data=b.data;
	}
	//7構函式
	~Base(){
		cout<<"deconstructor invoke!"<<(int *)this<<endl;
	}

	void play(Base  b){
		
	}

	Base& refer(Base & b){
		cout<<"refer address:"<<(int *)&b<<endl;
		return b;
	}
private:
	int data;

};

int main(){

	Base b(1);//建構函式呼叫

	Base b2=b;//拷貝建構函式呼叫

	Base b3;//預設建構函式呼叫
	b3=b;//賦值操作符呼叫

	b.play(b);//只會呼叫拷貝建構函式
	b.play(2);//建構函式呼叫

	cout<<"-----------------"<<endl;
	b.refer(b);
	cout<<"-----------------"<<endl;
	return 0;
}
輸出：

注意：不能返回區域性物件的引用，所以如果引數不為引用是不能返回一個引用的物件的。



到這裡應該對建構函式，拷貝建構函式和賦值操作符在何時會呼叫應該有一個清晰的認識了。

相關推薦

C++中抽象類以及虛/純虛、解構函式的區別與介紹

一、虛擬函式 在某基類中宣告為 virtual 並在一個或多個派生類中被重新定義的成員函式，用法格式為：virtual+函式返回型別+ 函式名（引數表） {函式體}；實現多型性，通過指向派生類的基類指標或引用，訪問派生類中同名覆蓋成員函式。 二、純虛擬函式 純虛擬函式是一種

設計模式中的單例模式的程式碼為什麼解構函式會多次被呼叫，而建構函式只調用一次

單例模式 package com.seven.exercise.testEception; /**  * 單例模式，餓漢式  * @author Seven  *  */ public class SingleDemoHunger {   &nb

C++在單繼承、多繼承、虛繼承時，建構函式、複製建構函式、賦值操作符、解構函式的執行順序和執行內容

一、本文目的與說明     1. 本文目的：理清在各種繼承時，建構函式、複製建構函式、賦值操作符、解構函式的執行順序和執行內容。     2. 說明：雖然複製建構函式屬於建構函式的一種，有共同的地方，但是也具有一定的特殊性，所以在總結它的性質時將它單獨列出來了。  

C++中基類的解構函式為什麼要用virtual虛解構函式【轉】

（轉自：https://blog.csdn.net/iicy266/article/details/11906457） 知識背景          要弄明白這個問題，首先要了解下C++中的動態繫結。&n

C++中基類的解構函式為什麼要用virtual虛解構函式

知識背景          要弄明白這個問題，首先要了解下C++中的動態繫結。  正題          直接的講，C++中基類採用virtual虛解構函式是為了防止記憶體洩漏。具體地說，如果派生類中申請了記憶體空間，並在其解構函式中對這些記憶體空間進行釋放

[收集]c++抽象類、純虛擬函式以及巧用純虛解構函式實現介面類

在Java、C#中有關鍵詞abstract指明抽象函式、抽象類，但是在C++中沒有這個關鍵詞，很顯然，在C++也會需要只需要在基類宣告某函式的情況，而不需要寫具體的實現，那C++中是如何實現這一功能的，答案是純虛擬函式。 含有純虛擬函式的類是抽象類，不能生成物件，只能派生。

C++類中的一些細節(過載、重寫、覆蓋、隱藏，建構函式、解構函式、拷貝建構函式、賦值函式在繼承時的一些問題)

1 函式的過載、重寫（重定義）、函式覆蓋及隱藏 其實函式過載與函式重寫、函式覆蓋和函式隱藏不是一個層面上的概念。前者是同一個類內，或者同一個函式作用域內，同名不同引數列表的函式之間的關係。而後三者是基類和派生類函式不同情況下的關係。 1.1 函式過載

C++中建構函式，拷貝建構函式，解構函式

C++中預設建構函式就是沒有形參的建構函式。準確的說法，按照《C++ Primer》中定義：只要定義一個物件時沒有提供初始化式，就是用預設建構函式。為所有 的形參提供預設實參的建構函式也定義了預設建構函式。 合成的預設建構函式，即編譯器自動生成的預設建構函式。《C++ Pr

C++中的建構函式，拷貝建構函式和賦值函式

一.建構函式 1.首先說明一下空類： 對於空類，編譯器會自動加入： 預設建構函式，拷貝建構函式，賦值建構函式，解構函式和取值函式 擴充：空類的大小為1.（因為每個例項在記憶體中都有獨一無二的地址，為了達到這個目的，編譯器往往會給空類增加一個位元組） 2

C++中建構函式，拷貝建構函式和賦值函式的區別和實現

C++中一般建立物件，拷貝或賦值的方式有建構函式，拷貝建構函式，賦值函式這三種方法。下面就詳細比較下三者之間的區別以及它們的具體實現 1.建構函式 建構函式是一種特殊的類成員函式，是當建立一個類的物件時，它被呼叫來對類的資料成員進行初始化和分配記憶體。（建構函式的命名必須

c++建構函式，拷貝建構函式，解構函式，賦值運算子過載

建構函式：        是一個特殊的成員函式，名字與類名相同，建立類型別物件時，由編譯器自動呼叫，在物件的生命週期內只且只調用一次，以保證每個資料成員都有一個合適的初始值。 <strong&g

廣義表的C++實現（包含建構函式，拷貝建構函式，解構函式，獲取表頭，表尾，獲取直接後繼等操作）

資料結構是資料在系統中的物理儲存結構，自己編寫資料結構可以對某種資料結構的物理和邏輯結構有更深的瞭解。 一、廣義表作為一種資料結構有以下的特點： 1. 廣義表是遞迴的； 2. 廣義表的元素可以使廣義表，也可以是值； 3. 廣義表是有序的； 4. 廣義表是有長度有深度的。 二

C++ 建構函式，解構函式中能否呼叫虛擬函式？

牛客網 ------------------- ------------------- ------------------- 設計模式 ------------------- -------------------

c++類詳解：訪問許可權，建構函式，拷貝建構函式，解構函式

類的定義 類可以看做是一種資料型別，類這種資料型別是一個包含成員變數和成員函式的集合。類的成員變數和普通變數一樣，也有資料型別和名稱，佔用固定長度的記憶體。但是，在定義類的時候不能對成員變數賦值，因為類只是一種資料型別或者說是一種模板，本身不佔用記憶體空間，而變數的值則需要

C++基礎知識（八）---函式返回值（返回值，返回指標，返回物件，返回引用）---引用---複製建構函式（拷貝建構函式）

一、函式返回值 　　1.返回值： int test () { int a=1; return a; }   返回值時最簡單的方式，它的操作主要在棧上，變數a在函式結束後會刪除，為了返回a的值，系統會在內部建立一個臨時變數儲存a的值，以返回給呼叫該函式的表示式，呼叫結束後變數便

c++的建構函式極其呼叫（無參建構函式，有參建構函式，拷貝建構函式）

1.c++編譯器會自動呼叫建構函式//建構函式(與類名相同) //解構函式：沒有引數也沒有任何返回型別，被自動呼叫 #include<iostream> using namespace std; class Test { public: Test();//無參建

C++之建構函式，解構函式，拷貝建構函式

一、定義    建構函式：是在一個定義在類裡面的函式，它的作用是在你建立這個類的物件時被自動呼叫。                    如果你自己定義了則呼叫自己定義的，否則呼叫預設的。    解構函式：是一個在類裡面定義的函式，它的作用是在你的類物件死亡時被呼叫刪除這個類

C++中struct也有建構函式與解構函式，也可以有訪問型別控制以及結構體大小，類大小

C++中struct也有建構函式與解構函式，也可以有訪問型別控制，可以用private關鍵字。如下所示： #include <iostream> struct point { public: point():x_(0.0),y_(0.0

c++中類的預設四個成員函式介紹（建構函式+拷貝構造+解構函式+賦值運算子過載函式）

在C++中，類的6個預設的成員函式包括： 建構函式、解構函式、拷貝建構函式、賦值運算子過載函式、取地址操作符過載、const修飾的取地址操作符過載。 本文將主要介紹前四個成員函式： 一、建構函式 在c++程式中，物件的初始化時一個不可缺少且十分重要的

1、【C++】類&物件/建構函式/拷貝建構函式/操作符過載/解構函式

一、C++類 & 物件     C++ 在 C 語言的基礎上增加了面向物件程式設計，C++ 支援面向物件程式設計。類是 C++ 的核心特性，通常被稱為使用者定義的型別。     類用於指定物件的形式，它包含了資料表示法和用於處理資料的方法。類中的資料和方法稱為類的成員。函式在