#include<iostream>
using namespace std;

//抛出类对象的时候使用new接收时候使用引用
//throw int类型异常 进行字符串的复制
void my_strcpy1(char*to,char*from)
{
	if (from==NULL)
	{
		throw 1;
	}
	if (to==NULL)
	{
		throw 2;
	}
	//copy场景的检查
	if (*from=='a')
	{
		throw 3;//copy时候出错
	}
	while (*from!='\0')
	{
		*to = *from;
		to++;
		from++;
	}
	*to = '\0';
}
//throw char*类型异常 进行字符串的复制
void my_strcpy2(char*to, char*from)
{
	if (from == NULL)
	{
		throw "源地址出错";
	}
	if (to == NULL)
	{
		throw "目的地址出错";
	}
	//copy场景的检查
	if (*from == 'a')
	{
		throw "copy时候出错";//copy时候出错
	}
	while (*from != '\0')
	{
		*to = *from;
		to++;
		from++;
	}
	*to = '\0';
}
//抛出对象类型-
class BadSrcType{};
class BadDestType{};
class BadProcessType
{
public:
	BadProcessType()
	{
		cout << "BadProcessType构造函数do \n";
	}


	BadProcessType(const BadProcessType &obj)
	{
		cout << "BadProcessType copy构造函数do \n";
	}

	~BadProcessType()
	{
		cout << "BadProcessType析构函数do \n";
	}
};

void my_strcpy3(char*to, char*from)
{
	if (from == NULL)
	{
		throw BadSrcType();//调用无参数构造函数
	}
	if (to == NULL)
	{
		throw BadDestType();
	}
	//copy场景的检查
	if (*from == 'a')
	{
		throw BadProcessType();//copy时候出错,是否会产生一个无名对象？？？
		//会调用构造函数产生一个新对象
	}
	if (*from=='b')
	{
		throw &(BadProcessType());//会不会产生一个匿名对象？？
	}
	if (*from=='c')
	{
		throw new BadProcessType();//会不会产生一个匿名对象?使用new来避免野指针
		//调用构造函数产生一个新对象
	}
	while (*from != '\0')
	{
		*to = *from;
		to++;
		from++;
	}
	*to = '\0';
}
int main(void)
{
	int ret = 0;
	char buf1[] = "aisuanjizuchengyuanli";
	char buf2[1024] = { 0 };
	try
	{
		//my_strcpy1(buf2, buf1);
		//my_strcpy2(buf2,buf1);
		my_strcpy3(buf2, buf1);

	}
	catch (int e)
	{
		cout << "抛出int类型异常----" << e << endl;

	}
	catch (char*e)
	{
		cout << "抛出字符串类型异常----" << e << endl;
	}
	catch (BadSrcType e)
	{
		cout << "BadSrcType类型异常" << endl;
	}
	catch (BadDestType e)
	{
		cout << " BadDestType 类型异常" << endl;
	}
	//结论1: 如果 接受异常的时候 使用一个异常变量,则copy构造异常变量.  
	/*
	catch( BadProcessType e) //是把匿名对象copy给e 还是e还是那个匿名对象
	{
	cout << " BadProcessType 类型异常" << endl;
	}
	*/
	//结论2: 使用引用的话 会使用throw时候的那个对象
	//catch( BadProcessType &e) //是把匿名对象copy给e 还是e还是那个匿名对象
	//{
	//	cout << " BadProcessType 类型异常" << endl;
	//}

	//结论3: 指针可以和引用/元素写在一块 但是引用/元素不能写在一块
	catch (BadProcessType *e) //是把匿名对象copy给e 还是e还是那个匿名对象
	{
		cout << " BadProcessType 类型异常" << endl;
		delete e;
	}
	//结论4: 类对象时, 使用引用比较合适 

	// --
	catch (...)
	{
		cout << "未知 类型异常" << endl;
	}

	cout << buf2 << endl;

	system("pause");
	return 0;
}


/*
1）throw的异常是有类型的，可以使，数字、字符串、类对象。
2）throw的异常是有类型的，catch严格按照类型进行匹配。
3）注意 异常对象的内存模型  。
结论：接受类异常的时候使用引用最好，throw的地方使用new。
*/