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

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

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后定義，兩者的使用參數(shù)列表初始化的順序是先 mb, 再 ma
		2. 在初始化之前 ma 與 mb 都是隨機值，或被填充為0xcccccccc （具體看編譯器實現(xiàn)）
		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;
};

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

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

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

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

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

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

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

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