C++類中隱藏的默認函數有哪些

這篇文章主要介紹了C++類中隱藏的默認函數有哪些，具有一定借鑒價值，感興趣的朋友可以參考下，希望大家閱讀完這篇文章之后大有收獲，下面讓小編帶著大家一起了解一下。

Test類中隱藏的六個默認的函數

class Test
{
public:
	//默認的構造函數
	Test()；
	//析構函數 
	~Test()；
	//拷貝構造函數 
	Test(const Test &t)；
	//賦值函數 
	Test& operator=(const Test &x)；
	//一般對象取地址函數 
	Test* operator&()；
	//常對象取地址函數 
	const Test* operator&()const；
private:
		int data;
		//int *data;	// 注意：如果成員中含有指針類型，需重載拷貝函數與賦值函數
						// 否則會造成淺拷貝
						// 另外，需要注意在析構函數中，釋放類中使用的額外資源（堆區申請的資源）
};

1.構造函數

作用：對象所在的內存空間做初始化 、給對象賦資源

特點：

1.可以重載 ：可以根據實際需要進行缺省的、多參重載

2.不依賴對象：對象無法調用構造函數，只能在對象定義點被調用

//成員函數類外實現，需在函數名前指定作用域，否則編譯器會認為在定義一個普通的函數
Test::Test()	//類中默認的構造函數
{
}
//此外，構造函數可以支持重載，我們可以根據需要自己寫一些構造函數
//需要注意的是，如果我們自己寫了構造函數，那么編譯器就不會提供默認的構造函數了
Test::Test(int d = 0 )	//缺省的構造函數
{
	data = d;
}
Test::Test(int d = 0 ):data(d)	//缺省的構造函數,用初始化列表的方式初始化
{
}

兩者初始化的區別在于，初始化列表是真正意義上的初始化，它告訴編譯器在實例化對象的時候以何種方式對成員賦值，而在前者的賦值規則寫在了構造函數內部，是在已經生成了成員變量之后再進行的賦值操作。

初始化列表示例：

Tips: 注意區分列表參數初始化和列表初始化的區別 。列表參數初始化即在函數的形參列表后通過 fun(int ia) :mval(ia) 冒號+括號的這種方式初始化，而列表初始化一般是指如 std::vector<int> vec{ 1,2,3,4,5 }; vec{1,2,3,4,5}; 這種，在定義時通過 { } 括起來的列表初始化“數組”的行為。 事實上，在C++11標準中還有一種就地初始化的概念，這里先不做討論。

對于 初始化列表 有幾點特性需要注意：

比如以下操作，成員變量有引用類型和const類型，在C++中規定const類型為一個常量，定義時必須初始化，而引用我們認為是一個變量的別名也需要在定義時就初始化。所以以下操作只能使用初始化列表的方式初始化。

class Test
{
public:
	/* error 常量、引用在定義時就初始化
	Test(int a, int b,int c)
	{
		ma = a;
		mb = a;	// error
		mc = a; // error
	}
	*/
	Test(int a, int b, int c):ma(a),mb(b),mc(c)
	{
	}
private:
	int ma;
	int& mb;
	const int mc;
};

此外，如果有多個成員變量需要使用初始化列表的方式初始化，需要注意一點細節，初始化的順序只與成員變量的定義順序相關。

如以下程序，可以寫成Test(int a):ma(mb), mb(a){}或Test(int a):mb(a),ma(mb){}因為成員變量的定義順序為int mb; int ma;，也就是說賦值順序與初始化列表無關，只與成員變量被定義的順序有關。

class Test
{
public:
	Test(int a):ma(mb), mb(a)	//mb先被定義出來，先給mb賦值，再給ma賦值
	{
	}
	/* 下面錯誤的寫法： 
		解釋：
		1. mb先定義，ma后定義，兩者的使用參數列表初始化的順序是先 mb, 再 ma
		2. 在初始化之前 ma 與 mb 都是隨機值，或被填充為0xcccccccc （具體看編譯器實現）
		3. 在初始化時， mb(ma) ，則mb被初始化為無效值（隨機值或0xcccccccc）
		                ma(a) ,  ma 被初始化為 a 的值。
						因此，如果調用Test(10), 則 mb: -858993460 ma: 10
	*/
	Test(int a) :mb(ma), ma(a)	
	{
	}
public:
	void Show()
	{
		std::cout << "ma: " << ma << std::endl;
		std::cout << "mb: " << mb << std::endl;
	}
private:
	int mb;
	int ma;
};

注：以下函數的Test類成員均為 int *ma ，表示數據成員為指針時，各成員函數的實現方法。

2.析構函數

作用：釋放對象所占的其他資源。

特點：

不可重載 ： 對象銷毀時會調用析構函數，并釋放空間。依賴對象：可手動調用即this->~Test()或 Test t; t.~Test()，但是不建議，因為對象銷毀時會自動調用，如果手動調用可能會引起內存空間的重復析構導致程序崩潰

//默認的析構函數 
Test::~Test()
{		//沒有額外的資源，什么都不寫
}

//如果程序中有額外的空間需要釋放
class Test
{
public:
	//構造函數 
	Test(int ia = 0) 
	{
		data = new int{ ia };		//data指向一塊堆區內存
	}
	//析構函數
	~Test();
private:
		int* data;
};
//析構函數 
Test::~Test()
{
	delete data;	//把額外空間的釋放寫進析構函數
	data = nullptr;
}

3.拷貝構造函數

作用：拿一個已存在的對象來生成相同類型的新對象

注意：類中提供的拷貝構造函數為一個淺拷貝類型，即如果成員變量中含有指針類型，它在進行拷貝構造的時候不會進行額外空間的開辟，最終會造成函數析構時的錯誤。

class Test
{
public:
	//構造函數 
	Test(int ia = 0) 
	{
		data = new int{ ia };		//data指向一塊堆區內存
	}
	//拷貝構造函數 
	Test(const Test &t);	//一定要傳引用，否則在開辟形參的過程中會遞歸的調用拷貝構造函數來構造形參，而函數始終無法執行
private:
		int* data;
};
//默認的拷貝構造函數 
Test::Test(const Test &t)
{
	data = t.data;		//淺拷貝，只把現有的成員變量進行拷貝，沒有對堆區內存進行拷貝，使多個對象的data指向了同一片堆區空間，在對象銷毀時會造成空間的重復釋放引發程序崩潰。
}
//拷貝構造函數
Test::Test(const Test &t)
{
	data = new int;		//如果是字符類型data = new char[strlen(t.data) + 1]; 
						// 注意strlen() 函數不能傳遞nullptr參數
	strcpy_s(data,sizeof(int), t.data);
}
// 或者使用初始化列表的方式
Test::Test(const Test& t) :data(new int{*(t.data)})
{
}

4.賦值運算符的重載函數

作用：拿一個已存在的對象給相同類型的已存在對象賦值

實現步驟

1.賦值判斷

2.釋放舊資源

3.生成新資源

4.賦值

class Test
{
public:
	//構造函數 
	Test(int ia = 0) 
	{
		data = new int{ ia };		//data指向一塊堆區內存
	}
	//賦值函數
	Test& operator=(const Test &x);	//以自身類類型的引用的方式返回
private:
		int* data;
};
//默認的賦值函數(淺拷貝)
Test& Test::operator=(const Test &x)
{
	if(this!=&x)		//自賦值判斷
	{
		data=x.data;	//淺拷貝
	}
	return *this;		//返回自身類類型的引用
}
//賦值函數(深拷貝)
Test& Test::operator=(const Test &x)
{
	if(this!=&x)		//自賦值判斷
	{
		delete data;	//釋放原資源 
		//delete[] data; 如果申請的空間是多個，即數組形式，需要delete [] data 釋放
		data = new int;	//開辟空間
		memcpy(data, x.data, sizeof(data));	// 賦值
	}
	return *this;		//返回自身類類型的引用
}

5.一般對象取地址函數

//一般對象取地址函數 
Test::Test* operator&()
{
	return this;
}

6.常對象取地址函數

//常對象取地址函數 
const Test::Test* operator&()const
{
	return this;
}

C++11以后增加了右值引用的概念，同時增加了移動構造函數、和移動賦值函數。

7.移動構造函數

作用：針對某些情況構造對象的優化，避免重復的開辟內存。

使用場景：比如把臨時對象的資源作為構建新對象的資源使用，而臨時對象銷毀時，資源繼續被其他對象使用（這里就節省了一次舊對象資源的的銷毀與新對象資源申請的開銷）。

class Test
{
public:
	//構造函數 
	Test(int ia = 0) :data(new int{ ia })
	{}
	// 拷貝構造 ..
	// 賦值..
	// 析構..
	// 移動構造
	Test(Test&& rhs)
	{
		this->data = rhs.data;	// 資源的轉移
		rhs.data = nullptr;		// 資源的釋放
	}
	 /* 
	 //使用初始化列表的方式
	Test(Test&& rhs) :data(rhs.data)
	{
		rhs.data = nullptr;
	}
	*/
public:
	void print() { std::cout << (void*)data << std::endl; }
private:
	int* data;
};
int main()
{
	Test t(10); 
	t.print();
	Test t2(std::move(t));	// 把 t 的資源轉移給 t2
	t.print();
	t2.print();
	return 0;
}

8.移動賦值函數

作用：資源的轉移，針對某些情況下，節省內存的開辟。

class Test
{
public:
	//構造函數 
	Test(int ia = 0) :data(new int{ ia })
	{}
	// 拷貝構造 ..
	// 賦值..
	// 析構..
	// 移動構造
	// 移動賦值
	Test& operator=(Test&& rhs) noexcept // 不拋出異常
	{
		if (this != &rhs)	// 防止自賦值
		{
			delete data;			// 銷毀當前資源
			this->data = rhs.data;	// 轉移資源，即接收對方資源
			rhs.data = nullptr;		// 對方放棄資源的擁有
		}
		return *this;
	}

public:
	void print() { std::cout << (void*)data << std::endl; }
private:
	int* data;
};

int main()
{
	Test t(10), t2(20);
	t.print();
	t2.print();
	t2 = std::move(t);	// 把 t 的資源交給 t2
	t.print();	// 輸出 00000000
	t2.print();
	return 0;
}

補充：

另外一個關于移動構造的話題是異常。對于移動構造函數來說，拋出異常有時是件危險的事情。因為可能移動語義還沒完成，一個異常卻拋出來了，這就會導致一些指針就成為懸掛指針。因此程序員應該盡量編寫不拋出異常的移動構造函數，通過為其添加一個noexcept關鍵字，可以保證移動構造函數中拋出來的異常會直接調用terminate程序終止運行，而不是造成指針懸掛的狀態。而標準庫中，我們還可以用一個std::move_if_noexcept的模板函數替代move函數。該函數在類的移動構造函數沒有noexcept關鍵字修飾時返回一個左值引用從而使變量可以使用拷貝語義，而在類的移動構造函數有noexcept關鍵字時，返回一個右值引用，從而使變量可以使用移動語義。

關于移動構造函數的示例程序，引用自《深入理解C++11》一書：

#include <iostream>
using namespace std;
class HasPtrMem {
public:
	HasPtrMem() :d(new int(3)) {
		cout<<"Construct:"<<++n_cstr<<endl;
	}
	HasPtrMem(const HasPtrMem& h) :d(new int(*h.d)) {
		cout<<"Copy construct:"<<++n_cptr<<endl;
	}
	HasPtrMem(HasPtrMem&& h) :d(h.d) {//移動構造函數
		h.d = nullptr;//將臨時值的指針成員置空
		cout<<"Move construct:"<<++n_mvtr<<endl;
	}
	~HasPtrMem() {
		delete d;
		cout<<"Destruct:"<<++n_dstr<<endl;
	}
	int* d;
	static int n_cstr;
	static int n_dstr;
	static int n_cptr;
	static int n_mvtr;
};
int HasPtrMem::n_cstr = 0;		
int HasPtrMem::n_dstr = 0;
int HasPtrMem::n_cptr = 0;
int HasPtrMem::n_mvtr = 0;
HasPtrMem GetTemp() {
	HasPtrMem h;
	cout<<"Resource from"<<__func__<<":"<<hex<<h.d<<endl;
	return h;
}
int main() {
	HasPtrMem a = GetTemp();
	cout<<"Resource from"<<__func__<<":"<<hex<<a.d<<endl;
}
//編譯選項:g++ -std=c++11 test.cpp -fno-elide-constructors

輸出：左邊是輸出結果，右邊是注釋

Construct:1						// 在GetTemp() 函數中，執行 HasPtrMem h; 構造對象
Resource fromGetTemp:0x1047f28	// 在GetTemp() 函數中，執行cout << ... 
Move construct:1				// 在GetTemp() 函數中，return h; 產生臨時對象，此時第一次調用移動構造
Destruct:1						// 進入main() 函數時，GetTemp();調用結束、進行清棧（棧幀回退），析構掉局部對象( h )
Move construct:2				// 在main() 函數中，執行 GetTemp(); 后產生的返回值是一個臨時無名對象，調用了移動構造函數，此時第二次調用移動構造
Destruct:2						// 在main() 函數中，執行了a = GetTemp(); 后，臨時對象生存期結束，析構掉臨時對象(函數返回值)
Resource frommain:0x1047f28		// 在main() 函數中，執行cout << ... 
Destruct:3						// main() 函數結束，對象 a 生存周期結束，銷毀對象 a

需要注意的是，在編譯器中存在被稱為RVO/NRVO的優化（RVO,Return Value Optimization，返回值優化，或者NRVO，Named Return Value optimization)。因此在上述編譯時使用了 -fno-elide-constructors 選項在g++/clang++中關閉這個優化，這樣可以使我們在代碼運行的結果中較為容易地利用函數返回的臨時量右值?！?/p>

如果在編譯的時候不使用該選項的話，我們寫的很多含有移動語義的函數都被省略了。例如以下的代碼

A ReturnRvalue(){A a();return a;}
A b=ReturnRvalue();

b 變量實際就使用了ReturnRvalue函數中a的地址，任何的拷貝和移動都沒有了。通俗地說，就是b變量直接“霸占”了a變量。這是編譯器中一個效果非常好的一個優化。不過RVO/NRVO并不是對任何情況都有效。比如有些情況下，一些構造是無法省略的。還有一些情況，即使RVO/NRVO完成了，也不能達到最好的效果?！?/p>

總體而言，移動語義除了可以解決某些情況下編譯器無法解決的優化問題，還在一些其他特殊的場合有著重要的用途（比如在unique_ptr中禁止構造函數，卻可以通過移動的構造或移動賦值對unique_ptr擁有的資源進行轉移）。

感謝你能夠認真閱讀完這篇文章，希望小編分享的“C++類中隱藏的默認函數有哪些”這篇文章對大家有幫助，同時也希望大家多多支持億速云，關注億速云行業資訊頻道，更多相關知識等著你來學習!