#ifndef _TEST__
#define _TEST__
#include <iostream>
#include <sstream>

class Test {
 public:
	Test();								// 默认构造函数
	~Test();							// 默认析构函数

	Test(const Test &ex);				// 拷贝构造函数，默认形式
	Test( Test &ex);					// 拷贝构造函数
	//Test(Test ex);					// 不合法，防止递归无限调用

	Test& operator = (const Test& ex);	// 赋值运算，默认形式
	Test& operator = (Test& ex);		// 赋值运算
	//Test& operator = (const Test ex);	// 赋值运算，合法，引用作为重载条件，调用是需要转型
	//Test operator = (const Test& ex);	// 赋值运算，合法，但是返回不能作为重载条件
	Test& operator = (int k);			// 赋值运算
	// ...

	static Test func1(Test ex);
	static Test& func2(Test &ex);

 private:
 	int key;
 	std::string str;
 	static int num;		// 用于计数
};
#endif

Test::Test() {
	key = ++num;
	std::cout<<"\tTest()"<<std::endl;
}

Test::Test(const Test &ex) {
	this->key = ++num;
	std::stringstream ss;
	ss<<"copy_c_&"<<ex.key;
	this->str = ss.str();
	std::cout<<"\tTest(const Test &ex)"<<std::endl;
}

Test::Test(Test &ex) {
	this->key = ++num;
	std::stringstream ss;
	ss<<"copy_&"<<ex.key;
	this->str = ss.str();
	std::cout<<"\tTest(Test &ex)"<<std::endl;
}

Test& Test::operator = (const Test& ex) {
	if(&ex == this)
		return *this;
	this->key = ++num;
	std::stringstream ss;
	ss<<"operator=_&_c_&"<<ex.key;
	// 如果是堆分配，需要释放原来的内存
	// 拷贝strcpy等
	this->str = ss.str();
	std::cout<<"\tTest& operator = (const Test& ex)"<<std::endl;
	return *this;
}

Test& Test::operator = (Test& ex) {
	if(&ex == this)
		return *this;
	this->key = ++num;
	std::stringstream ss;
	ss<<"operator=_&_&"<<ex.key;
	// 如果是堆分配，需要释放原来的内存
	// 拷贝strcpy等
	this->str = ss.str();
	std::cout<<"\tTest& operator = (Test& ex)"<<std::endl;
	return *this;
}

/*Test Test::operator = (const Test& ex) {
	if(&ex == this)
		return *this;
	this->key = ++num;
	std::stringstream ss;
	ss<<"operator=_c_&"<<ex.key;
	this->str = ss.str();
	std::cout<<"\tTest operator = (const Test& ex)"<<std::endl;
	return *this;
}*/

/*Test& Test::operator = (const Test ex) {
	if(&ex == this)
		return *this;
	this->key = ++num;
	std::stringstream ss;
	ss<<"operator=_&_c"<<ex.key;
	this->str = ss.str();
	std::cout<<"\tTest& operator = (const Test ex)"<<std::endl;
	return *this;
}*/

Test& Test::operator = (const int k) {
	this->key = ++num;
	std::stringstream ss;
	ss<<"operator=_&_c["<<k<<"]";
	this->str = ss.str();
	std::cout<<"\tTest& operator = (const int k)"<<std::endl;
	return *this;
}

Test Test::func1(Test ex) {
	std::cout<<"\tTest func1(Test ex)"<<std::endl;
	return ex;
}

Test& Test::func2(Test &ex) {
	std::cout<<"\tTest func2(Test ex)"<<std::endl;
	return ex;
}

Test::~Test() {
	std::cout<<"\t~Test():"<<key<<":"<<str<<std::endl;
}

int Test::num = 0;

int main(int argc, char const *argv[])
{	
	// 默认构造
	std::cout<<"Test aaa;"<<std::endl;
	Test aaa;
	std::cout<<"const Test bbb;"<<std::endl;
	const Test bbb;
	// 拷贝构造
	std::cout<<"Test ccc(aaa);"<<std::endl;
	Test ccc(aaa);
	std::cout<<"Test ddd = bbb;"<<std::endl;
	Test ddd = bbb;

	// 赋值运算
	std::cout<<"ddd = 10;"<<std::endl;
	ddd = 10;
	std::cout<<"ddd = aaa;"<<std::endl;
	ddd = aaa;
	std::cout<<"ddd = bbb;"<<std::endl;
	ddd = bbb;

	// 拷贝构造和赋值运算结合
	std::cout<<"ddd=Test::func1(aaa);"<<std::endl;
	ddd=Test::func1(aaa);	// 参数和返回相当于Test ex = aaa;		
	std::cout<<"ddd=Test::func2(aaa);"<<std::endl;
	ddd=Test::func2(aaa);	// 参数和返回相当于Test &ex = aaa; 没有拷贝构造，也没有赋值
	std::cout<<"Test eee = Test::func2(aaa);"<<std::endl;
	Test eee = Test::func2(aaa);

	std::cout<<"return 0"<<std::endl;
	return 0;
}