double Divide(int a, int b)
{
	// 當(dāng)b == 0時(shí)拋出異常
	if (b == 0)
	{
		throw "Divide by zero condition!";
	}
	else
	{
		return (double)a / (double)b;
	}
}

void Func()
{
	// 這?可以看到如果發(fā)?除0錯(cuò)誤拋出異常，另外下?的array和array2沒(méi)有得到釋放。
	// 所以這?捕獲異常后并不處理異常，異常還是交給外?處理，這?捕獲了再重新拋出去。
	// 但是如果array2new的時(shí)候拋異常呢，就還需要套?層捕獲釋放邏輯，這?更好解決?案
	// 是智能指針，否則代碼太戳了
	int* array1 = new int[10];
	int* array2 = new int[10];// 拋異常呢
	// 連續(xù)的兩個(gè)new
	// 如果第一個(gè)new拋異常可以捕獲
	// 如果第二個(gè)new拋異常，可以解決delete第二個(gè)new
	// 但是第一個(gè)new沒(méi)有被delete
	// 這樣就需要再第二個(gè)new的地方捕獲異常,delete第一個(gè)new
	// 如果有很多個(gè)new呢,就太麻煩了,這里就需要智能指針了
	try
	{
		int len, time;
		cin >> len >> time;
		cout << Divide(len, time) << endl;
	}
	catch (...)
	{
		cout << "delete []" << array1 << endl;
		cout << "delete []" << array2 << endl;
		delete[] array1;
		delete[] array2;
		throw; // 異常重新拋出，捕獲到什么拋出什么
	}
	// ...
	cout << "delete []" << array1 << endl;
	delete[] array1;
	cout << "delete []" << array2 << endl;
	delete[] array2;
}

int main()
{
	try
	{
		Func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	catch (...)
	{
		cout << "未知異常" << endl;
	}

	return 0;
}

template<class T>
class SmartPtr
{
public:
	// RAII
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

	~SmartPtr()
	{
		cout << "delete[] " << _ptr << endl;
		delete[] _ptr;
	}

private:
	T* _ptr;
};

double Divide(int a, int b)
{
	// 當(dāng)b == 0時(shí)拋出異常
	if (b == 0)
	{
		throw "Divide by zero condition!";
	}
	else
	{
		return (double)a / (double)b;
	}
}

void Func()
{
	// 這?可以看到如果發(fā)?除0錯(cuò)誤拋出異常，另外下?的array和array2沒(méi)有得到釋放。
	// 所以這?捕獲異常后并不處理異常，異常還是交給外?處理，這?捕獲了再重新拋出去。
	// 但是如果array2new的時(shí)候拋異常呢，就還需要套?層捕獲釋放邏輯，這?更好解決?案
	// 是智能指針，否則代碼太戳了
	SmartPtr<int> p1 = new int[10];
	SmartPtr<int> p2 = new int[10];// 拋異常呢
	SmartPtr<int> p3 = new int[10];

	int len, time;
	cin >> len >> time;
	cout << Divide(len, time) << endl;
}

int main()
{
	try
	{
		Func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	catch (...)
	{
		cout << "未知異常" << endl;
	}

	return 0;
}

template<class T>
class SmartPtr
{
public:
	// RAII
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

	~SmartPtr()
	{
		cout << "delete[] " << _ptr << endl;
		delete[] _ptr;
	}

	// 重載運(yùn)算符，模擬指針的?為，?便訪問(wèn)資源
	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}

	T& operator[](size_t i)
	{
		return _ptr[i];
	}

private:
	T* _ptr;
};

void Func()
{
   p1[1] = 50;
   p4->first = 1;
   p4->second = 2;
   cout << p1[1] << endl;
}

int main()
{
	// 需要p1和p2同時(shí)管理同一塊資源，淺拷貝
	// 析構(gòu)多次的問(wèn)題如何解決?
	SmartPtr<int> p1 = new int[10];
	SmartPtr<int> p2(p1);

	return 0;
}

struct Date
{
	int _year;
	int _month;
	int _day;

	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}

	// 本身不需要析構(gòu),為了驗(yàn)證auto_ptr是否可以解決析構(gòu)兩次的問(wèn)題
	~Date()
	{
		cout << "~Date()" << endl;
	}
};

int main()
{
	// 拷?時(shí)，管理權(quán)限轉(zhuǎn)移，被拷?對(duì)象ap1懸空
	auto_ptr<Date> ap1(new Date);

	auto_ptr<Date> ap2(ap1);
	// 空指針訪問(wèn)，ap1對(duì)象已經(jīng)懸空
	// ap1->_year++;

	return 0;
}

int main()
{
   unique_ptr<Date> up1(new Date);

   不支持拷貝
   // unique_ptr<Date> up2(up1);

   支持移動(dòng),移動(dòng)后up1也懸空了
   unique_ptr<Date> up3(move(up1));

   return 0;
}

int main()
{
   shared_ptr<Date> p1(new Date);
   shared_ptr<Date> p2(p1);
   shared_ptr<Date> p3(p1);
   
   cout << p1.use_count() << endl;// 3
   p1->_day++;
   cout << p1->_day << endl; // 2
   cout << p2->_day << endl; // 2
   cout << p3->_day << endl; // 2
   
   return 0;
}