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();