C++類別中隱藏的幾個預設函數你知道嗎

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;	// 注意：如果成員中含有指標型別，需過載拷貝函數與賦值函數
						// 否則會造成淺拷貝
						// 另外，需要注意在解構函式中，釋放類中使用的額外資源（堆區申請的資源）
};

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

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;
};

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::~Test()
{		//沒有額外的資源，什麼都不寫
}

//如果程式中有額外的空間需要釋放
class Test
{
public:
	//建構函式 
	Test(int ia = 0) 
	{
		data = new int{ ia };		//data指向一塊堆區記憶體
	}
	//解構函式
	~Test();
private:
		int* data;
};
//解構函式 
Test::~Test()
{
	delete data;	//把額外空間的釋放寫進解構函式
	data = nullptr;
}

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)})
{
}

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;		//返回自身類型別的參照
}

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

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

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;
}

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;
}

#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 

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