//求a和b的余數    怎么拋出異常
int division(int a,int b){
    if(b==0)
        throw 0;    //拋出一個值（任意）--->之后處理
    return a/b;
}
void print(int a,int b){
 
    cout<<division(a,b);
}
int main(){
 
    print(1,0);
 
}
/* 把b==0 的情況稱為異常,b==0 時代碼不成立,會調用默認abort函數終止程序 */

//try 與catch必須是一起出現，并且他們的括號{}不能省略
try
{
	//正常需要檢查是否存在異常的代碼 
}
catch(類型)     //理解為switch中case語句
{
    //處理是根據拋出數據類型決定如何處理 匹配項 匹配拋出異常的類型
}
 
//一個try可以對應多個catch
try
{
	//...    
}
catch(int)
{
	    
}
catch(double)
{
    
}
catch(string)
{
	    
}
//catch和if else_if 執行機制是一樣的，只能執行一個匹配項

int division(int a,int b){
    if(b==0)
        throw 0;    
    return a/b;
}
void print(int a,int b){
 
    cout<<division(a,b);
}
int main(){
 
    try
    {
        print(1,0);     //檢查異常
        cout<<"別的代碼"<<endl;    //這一句不會運行,會直接跳到catch
    }    
    catch(int)                    //拋出的是int類型,捕獲int類型
    {
        cout<<"除數不能為0"<<endl;
    }
}

//某個函數不存在異常,在某個函數后面用throw() 描述,表示它不存在異常
void  print() throw() 
{
	cout << "當前函數不存在拋出異常操作" << endl;
}
void printData() noexcept 
{
	cout << "c++新標準中的關鍵字: 不存在拋出異常操作" << endl;
	//throw 0;  一旦說明沒有異常操作，就不能拋出
}

catch(...)
{
 
    cout <<"捕獲任何類型的異常"<< endl;
}

int divisor(int a, int b) 
{
	if (b == 0)
		throw string("除數不能為0");    
	return a / b;
}
 
int main()
{
	try
	{
		divisor(1, 0);   
	}
	catch (string str)    //把throw的內容賦值給str    str="除數不能為0"
	{
		cout << str << endl;
	}
}

int divisor(int a, int b) 
{
	if (b == 0)
		throw "除數不能為0";    //拋出異常  解析為char* 類型 寫catch時不能直接當作string
	if(b==1)
		throw "除數不能為1";    /* 不同問題的拋出,不能用固定類型(int、char...), 可以選擇
                                  拋出不同字符串處理 string1,string2,string3... 通過傳
                                  參的方式去描述問題 */
	if(b==2)
		throw string("除數不能為2");  //需構造無名參數作捕獲對象處理--->需要自己觸發
	return a / b;
}
 
int main()
{
	try
	{
		divisor(1, 0);       //直接觸發異常
	}
	catch (const char* str)  //拋出的是char* 類型,不能當作string
	{
		cout << str << endl;
	}
	try
	{
		divisor(1, 2);
	}
	catch (string str)    //如果要捕獲string類型,需要自己構造一個string對象返回
	{
		cout << str << endl;    //直接輸出str
	}
}

class Error 
{
public:
	Error(const char* str = "未知錯誤") :str(str) {}
	const char* what()const 
	{
		return str.c_str();
	}
protected:
	string str;
};
 
void insertArray(int array[], int* curNum, int posData,int maxLength) 
{
	if (*curNum >= maxLength)  //3>=3
	{
		throw  Error("數組下標溢出！");
	}
	//0 1 2
	array[*curNum] = posData;  //array[3]=3
	(*curNum)++;
}
 
int main(){
 
    try
	{
		int array[3] = { 0,0,0 };
		int curNum = 0;
		for (int i = 0; i < 4; i++) 
		{
			insertArray(array, &curNum, i, 3);
		}
	}
	catch (Error str) 
	{
		cout << str.what() << endl;
	}
 
    return 0;
}

 #include<exception>    //父類(基類)

#include <exception>
#include <iostream>
using namespace std;
class Exception 
{
public:
	Exception(const char* ptr="UNKNOW") :ptr(const_cast<char*>(ptr)){} /*構造函數 干掉            
                                                                         常屬性*/
	virtual const char* what() const    //父類是虛函數 且不存在異常
	{
		return ptr;
	}
protected:
	char* ptr;
};
//子類繼承父類    
class Bad_alloc :public Exception
{
public:
	Bad_alloc(const char* _Message = "bad exception") :Exception(_Message) {} /*調用父類 
                                                           的構造函數拋出bad exception*/
protected:
};
//子類繼承父類    調用父類構造函數
class Run_time :public Exception
{
public:
	Run_time(const char* _Message = "run_time error") :Exception(_Message) {}
protected:
};
 
int main() 
{
	try 
	{
		while (1) 
		{
			int* p = new int[1024*1024*10];//一直做內存申請,不做釋放,最后一定會內存申請失敗
		}
	}
	catch (bad_alloc& object) /* 內存申請失敗,調用bad_alloc 標準庫中的異常,創建一個對象接收一            
                                 下,子類中的what()方法調用父類中的what()方法打印 */
    {
 
		cout << object.what() << endl;
	}
	return 0;
}
/*輸出*/
 
bad allocation    //調用時拋出 bad allocation 是子類對象調用繼承下來的what()方法
 
//一般寫代碼出現莫名的中斷,原因是不做異常處理,引發了abort函數中斷程序,一般這種錯誤都是特殊錯誤