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 
using namespace std;
class HasPtrMem {
public:
	HasPtrMem() :d(new int(3)) {
		cout<<"Construct:"<<++n_cstr<
輸出：左邊是輸出結果，右邊是注釋
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++中關閉這個優化，這樣可以使我們在代碼運行的結果中較為容易地利用函數返回的臨時量右值。　
如果在編譯的時候不使用該選項的話，我們寫的很多含有移動語義的函數都被省略了。例如以下的代碼
A ReturnRvalue(){A a();return a;}
A b=ReturnRvalue();

b 變量實際就使用了ReturnRvalue函數中a的地址，任何的拷貝和移動都沒有了。通俗地說，就是b變量直接“霸占”了a變量。這是編譯器中一個效果非常好的一個優化。不過RVO/NRVO并不是對任何情況都有效。比如有些情況下，一些構造是無法省略的。還有一些情況，即使RVO/NRVO完成了，也不能達到最好的效果。　
總體而言，移動語義除了可以解決某些情況下編譯器無法解決的優化問題，還在一些其他特殊的場合有著重要的用途（比如在unique_ptr中禁止構造函數，卻可以通過移動的構造或移動賦值對unique_ptr擁有的資源進行轉移）。

總結