1. 用于類層次結(jié)構(gòu)中基類（父類）和派生類（子類）之間指針或引用的轉(zhuǎn)換。
   • 進(jìn)行上行轉(zhuǎn)換（把派生類的指針或引用轉(zhuǎn)換成基類表示）是安全的；
     • Base *base=static_cast(base);
     • 把Child轉(zhuǎn)為Base * ,是向上轉(zhuǎn)化,安全!
   • 進(jìn)行下行轉(zhuǎn)換（把基類指針或引用轉(zhuǎn)換成派生類表示）時，由于沒有動態(tài)類型檢查，所以是不安全的。
     • Child * child=static_cast(child)
     • 將Base轉(zhuǎn)為Child * ,是向下轉(zhuǎn)換,不安全!
2. 用于基本數(shù)據(jù)類型之間的轉(zhuǎn)換，如把int轉(zhuǎn)換成char，把char轉(zhuǎn)換成int。這種轉(zhuǎn)換的安全性也要開發(fā)人員來保證:double b = static_cast(int a);

1. dynamic_cast主要用于類層次間的上行轉(zhuǎn)換和下行轉(zhuǎn)換；不支持基礎(chǔ)數(shù)據(jù)類型.
2. 在類層次間進(jìn)行上行轉(zhuǎn)換時，dynamic_cast和static_cast的效果是一樣的；
3. 在進(jìn)行下行轉(zhuǎn)換時，dynamic_cast具有類型檢查的功能，比static_cast更安全；

該運算符用來修改對象的const屬性
不能直接對非指針和非引用的變量使用const_cast操作符去直接移除它的const.

1. 常量指針被轉(zhuǎn)化成非常量指針，并且仍然指向原來的對象；

const int* p = _NULL_;          //p本來是常量指針
int* np = const_cast(p);  //取出const,將常量指針被轉(zhuǎn)化成非常量指針

2. 非常量指針被轉(zhuǎn)換成常量指針，并且仍然指向原來的對象；

int* pp = _NULL_;                                 //p本來是非常量
const int* npp = const_cast(pp);      //加上const,將非常量指針轉(zhuǎn)換為常量指針

3. 引用同理.
4. 不能對非指針或非引用的變量進(jìn)行常量轉(zhuǎn)換!

1. 這是最不安全的一種轉(zhuǎn)換機制，最有可能出問題。
2. 主要用于將一種數(shù)據(jù)類型從一種類型轉(zhuǎn)換為另一種類型。它可以將一個指針轉(zhuǎn)換成一個整數(shù)，也可以將一個整數(shù)轉(zhuǎn)換成一個指針.

將[問題檢測]和[問題處理]相分離
由[問題檢測代碼]可以拋出(throw)一個對象給[問題處理代碼]，通過這個對象的類型和內(nèi)容，實際上完成了兩個部分的通信，通信的內(nèi)容是“出現(xiàn)了什么錯誤”。

try{
	.....//要試圖執(zhí)行的部分
}catch(捕獲類型){
	//throw;向上拋出
	......//異常處理
}//如果沒有任何處理異常的地方,那么成員調(diào)用Terminate函數(shù),終止程序

(1)在方法中

void TestFunction**(){**
cout **<<** "開始拋出異常..." **<<** endl**;**
//throw 10; //拋出int類型異常
//throw 'a'; //拋出char類型異常
//throw "abcd"; //拋出char*類型異常
//throw myException();//拋出自定義異常(匿名對象)
}

(2)在main中

try{
		TestFunction();
	}
	catch (int){
		cout<< "拋出Int類型異常!"<< endl;
	}
	catch (char){
		cout<< "拋出Char類型異常!"<< endl;
	}
	catch (char*){
		cout<< "拋出Char*類型異常!"<< endl;
	}
	catch (string){
		cout<< "拋出string類型異常!"<< endl;
	}
	catch(MyException e){//拋出自定義異常
		e.printError();
	}
	//捕獲所有異常
	catch (...){
		cout<< "拋出其他類型異常!"<< endl;
	}

異常被拋出后，從進(jìn)入try塊起，到異常被拋擲前，這期間在棧上構(gòu)造的所有對象，都會被自動析構(gòu)。析構(gòu)的順序與構(gòu)造的順序相反，這一過程稱為棧的解旋(unwinding).

(1)只能拋出int類型異常:void func() throw(int){}
(2)能拋出類型A,B,C及其子類型的異常:void func() throw(A,B,C){}
(3)不拋任何類型異常:void func() throw(){}
(4)如果一個函數(shù)拋出了它的異常接口聲明所不允許拋出的異常,unexcepted函數(shù)會被調(diào)用，該函數(shù)默認(rèn)行為調(diào)用terminate函數(shù)中斷程序。

1. 如果 MyException e, 會多開銷一份數(shù)據(jù),調(diào)用拷貝構(gòu)造。
2. 如果MyExcepiton* e,不new 提前釋放對象;new自己管理delete
3. 推薦MyException&e 容易些而且就一份數(shù)據(jù)

(1)系統(tǒng)標(biāo)準(zhǔn)庫

(2)自己編寫異常類

1. 繼承標(biāo)準(zhǔn)異常類。
2. 該重載父類的what函數(shù)和虛析構(gòu)函數(shù)。
3. 因為棧展開的過程中，要復(fù)制異常類型，那么要根據(jù)你在類中添加的成員考慮是否提供自己的復(fù)制構(gòu)造函數(shù)。
   ①編寫自己的異常類

class MyOutOfRange:public exception                //繼承標(biāo)準(zhǔn)異常類
{
public:
	MyOutOfRange(const string  errorInfo)          //有參構(gòu)造string類型
	{
		this->m_Error = errorInfo;
	}
	MyOutOfRange(const char * errorInfo)           //有參構(gòu)造char *類型
	{
		this->m_Error = string( errorInfo);
	}
	virtual  ~MyOutOfRange()                        //重載虛析構(gòu)函數(shù)
	{
	}
	virtual const char *  what() const               //重載what函數(shù)
	{
		return this->m_Error.c_str() ;               //string轉(zhuǎn)char *的方法.c_str()
	}
	string m_Error;                                  //錯誤信息
};

②異常檢測

if (age<= 0 || age >150)
{
//拋出異常 越界
//throw  out_of_range("年齡必須在0~150之間");          //標(biāo)準(zhǔn)庫中的越界異常
//throw length_error("長度異常");                     //標(biāo)準(zhǔn)庫中的長度異常
throw MyOutOfRange(("我的異常 年齡必須在0~150之間"));   //自己編寫的異常
}

③異常處理

try
	{
		Person p(151);                 //這里年齡越界
	}
	catch ( out_of_range & e )         //標(biāo)準(zhǔn)庫中的越界異常
	{
		cout<< e.what()<< endl;
	}
	catch (length_error & e)            //標(biāo)準(zhǔn)庫中的長度異常
	{
		cout<< e.what()<< endl;
	}
	catch (MyOutOfRange e)               //自己編寫的異常
	{
		cout<< e.what()<< endl;
	}

(1)標(biāo)準(zhǔn)I/O:標(biāo)準(zhǔn)設(shè)備的輸入和輸出
![[Pasted image 20221017091745.png]]
![[Pasted image 20221017091803.png]]
(2)文件I/O: 以外存磁盤文件為對象進(jìn)行輸入和輸出
![[Pasted image 20221017092011.png]]
(3)(字符)串I/O:對內(nèi)存中指定的空間進(jìn)行輸入和輸出,通常指定一個字符數(shù)組作為存儲空間

1. cin.get():讀取輸入的第一個字符
2. cin.get(ch):等價于ch=cin.get()讀取輸入的第一個字符
3. cin.get(buf,1024):讀取輸入的長度為1024的字符串到buf數(shù)組中;且不會把換行符拿走(遺留在緩沖區(qū)中)
4. cin.getline():讀取輸入的一行字符,會把換行符拿走并且扔掉
5. cin.ignore():忽略一個字符
6. cin.ignore(2):忽略兩個字符
7. cin.peek():將輸入的第一個字符查看一眼,再放回緩沖區(qū),可用于判斷
8. cin.putback():將字符放回緩沖區(qū),可用于判斷
9. cin.fail():標(biāo)志位,0為正常,1為異常:

while(){
	....
	cin.clear();//重置標(biāo)志位
	cin.sync(); //清空緩沖區(qū)
	cout<<"標(biāo)志位是:"<

ofstream ofs;
ofs.open("./test.txt",ios:out | ios:trunc);
//ofs.is_open();判斷能否打開成功
ofs<<"write something here"<

ifstream ifs;
ifs.open("./test.txt",ios:in);
//ifs.is_open();判斷能否打開成功

//第一種右移讀文件方式,推薦
char buf[1024];
while(ifs>>buf){
	cout<