C++譚版期末復(fù)習(xí)

前言

好好復(fù)習(xí)，簡單看看語法

從C到C++

C++的輸入輸出

• cin cout cerr clog

const定義常變量

函數(shù)

• 函數(shù)聲明
• 函數(shù)重載（函數(shù)參數(shù)的個數(shù)或類型不同）
• 函數(shù)模板
  • template<typename T>
  • T的類型也要一致
• 帶默認參數(shù)的函數(shù)
• 內(nèi)聯(lián)函數(shù) inline

變量的引用

• NOTES
  • 一定要初始化
  • 從一而終
  • 只能引用變量
  • 不能建立void類型的引用 void &a = 1
  • 不能建立引用的數(shù)組 char &a[3] = "asd"
  • const int &p = (可以是常量或表達式)
• 應(yīng)用
  • 作為函數(shù)參數(shù)

作用域運算符 ::

字符串變量 string類

• 常用運算
  • +合并
  • = 賦值（覆蓋）
  • == != > < >= <= 比較
  • s[i] 訪問
• 字符串?dāng)?shù)組 string st[4]

動態(tài)內(nèi)存分配/撤銷

• 分配 new 類型 [初值]
  • 分配一個變量 int *t = new int(1)
  • 分配一個數(shù)組 int *s = new int[5]
  • 返回類型 指針
• 撤銷 delete［］指針變量
  • 變量 delete t
  • 數(shù)組 delete[] s

類和對象的特性

概述

• 面向?qū)ο蟮奶攸c：封裝 繼承 多態(tài)
• 類是對象的抽象而對象則是類的具體表現(xiàn)形式
• 多態(tài)：由繼承而產(chǎn)生的相關(guān)的不同的類，其對象對同一消息會作出不同的晌應(yīng)。

類的聲明和對象的定義

• 類的聲明

  class lins {
     public:
     private:
     protected:
  }
  

• 定義對象

  1. lins ls1;
  2. class lins ls2;
  3. class lins{} ls3;
  4. class {} ls4;
  

• class與struct區(qū)別
  • 若不用public，private限制，class默認private，struct默認public

類的成員函數(shù)

• 類外定義 void lins::display(){}
• 內(nèi)置成員函數(shù) inline void lins::display(){}
• 成員函數(shù)的存儲方式
  • 同一類的不同對象，共用成員函數(shù)，不會跟成員數(shù)據(jù)一樣開辟新的空間存儲，且函數(shù)通過this指針來區(qū)別不同的對象

對象成員的引用

• 通過對象名和成員運算符訪問對象中的成員

  • ls.a
  • ls.display()

• 通過指向?qū)ο蟮闹羔樤L問對象中的成員

  class lins ls, *p;
  p = &ls;
  p->display(); 
  

• 通過對象的引用訪問對象中的成員

  class lins ls;
  lins &p = &ls;
  p.display(); 
  

類的封裝性和信息隱蔽

• 公用接口與私有實現(xiàn)的分離
• 類聲明和成員函數(shù)定義的分離

類和對象的使用

構(gòu)造函數(shù)

• 對象初始化
  • 類里面的成員變量是不能直接賦初值的，因為類是一種抽象類型，沒有分配存儲空間。
  • 所以初始化需在創(chuàng)建對象的時候lins ls1={1,2} //表示給lins中兩個成員賦了值，同等對象的賦值
• 利用構(gòu)造函數(shù)初始化

  class lins {
    public:
    lins();
    lins(int, int); //帶參數(shù)，且可重載
    lins(int, int = 1); //帶默認參數(shù)
    lins(int a, int b): aa(a), bb(b){}; //帶參數(shù)表
    int a;
  }
  lins::lins(){ a = 0; } //構(gòu)造函數(shù)
  //對于有指針的類，一定要在構(gòu)造函數(shù)內(nèi)初始化？？？
  //如果不初始化指針的指向是隨機的，出現(xiàn)了野指針，不安全，也不利于非空判斷
  
  NOTES:
    lins l1;//調(diào)用構(gòu)造函數(shù) 
    lins l2 = l1;//復(fù)制l1的值不會調(diào)用構(gòu)造函數(shù)
  

• 帶參數(shù)的構(gòu)造函數(shù)
  • 帶參數(shù)的構(gòu)造函數(shù)中的形參，其對應(yīng)的實參是在建立對象時給定的，如：lins l1(1,2)
• 帶參數(shù)表的構(gòu)造函數(shù)
  • 如：lins::lins(int a, int b): aa(a), bb(b){}
  • 如果有數(shù)組成員，必須在{}內(nèi)，不能通過參數(shù)表

析構(gòu)函數(shù)

• 四種情況
  • 局部對象、全局對象：在其作用域結(jié)束時調(diào)用析構(gòu)
  • 靜態(tài)(static)對象：在main結(jié)束或調(diào)用exit時調(diào)用析構(gòu)
  • new對象：調(diào)用delete時，先調(diào)用析構(gòu)
• 調(diào)用構(gòu)造與析構(gòu)的順序
  • 先構(gòu)造的后析構(gòu)，后構(gòu)造的先析構(gòu)

對象數(shù)組-對象指針

1. 對象數(shù)組

   注意二義性
   class lins{
    lins(int a,int b,int c):aa(a),bb(b),cc(c){};
    int aa, bb, cc;
   }
   
   lins ls1[3] = {1,2,3}; //一個數(shù)據(jù)給一個對象
   lins ls2[3] = {
    lins(1,1,1),
    lins(2,2,2),
    lins(3,3,3)
   }
   

2. 對象指針
   • 指向?qū)ο蟮闹羔?lins *p
   • 指向?qū)ο蟪蓡T的指針

     1. 指向?qū)ο髷?shù)據(jù)成員
      int *p;
      p = &t.a;
      cout << *p << endl;
     
     2. 指向?qū)ο蟪蓡T函數(shù)
      void(lins::*p)();
      p = &lins::fun;
      // p = &t.fun; 錯誤！因為函數(shù)地址是公用的，在對象外的空間
      (*p) (); //調(diào)用fun函數(shù)
     

   • 指向當(dāng)前對象的this指針

共用數(shù)據(jù)的保護

1. 常對象
   • const lins ls(); = lins const ls();
   • NOTES：
     • 在定義常對象時，必須同時對之初始化,之后不能再改變
     • 常對象只能調(diào)用它的常成員函數(shù)
     • 常成員函數(shù)可訪問常對象中的數(shù)據(jù)成員，但不允許修改常對象中數(shù)據(jù)成員的值
     • mutable int a; 可修改
2. 常對象成員
   • 常數(shù)據(jù)成員：只能通過構(gòu)造函數(shù)的參數(shù)初始化表進行初始化
   • 常成員函數(shù)：void fun() const;
   • note：常成員函數(shù)不能調(diào)用另一個非const成員函數(shù)
3. 指向?qū)ο蟮某Ｖ羔?
   • lins * const p; --指向不能變，值可以變
   • 不能指向常對象
4. 對象的常指針
   • const lins *p; --指向?qū)ο蟮闹挡荒茏?，指向可以?/li>
   • 可以指向常對象
5. NOTE：非const能變?yōu)閏onst，反之不能
6. 對象的常引用
   • void fun(const lins &ls);
   • 經(jīng)常用常指針和常引用作函數(shù)參數(shù)

對象的動態(tài)建立和釋放

• lins *p = new lins; 創(chuàng)建一個lins對象，調(diào)用構(gòu)造函數(shù)，返回一個地址給p
• 用new建立的動態(tài)對象一般是不用對象名的，是通過指針訪問的，它主要應(yīng)用于動態(tài)的數(shù)據(jù)結(jié)構(gòu)，如鏈表。
• delete p; 釋放內(nèi)存空間之前自動調(diào)用析構(gòu)函數(shù)。

對象的賦值和復(fù)制

1. 賦值
   • lins l1,l2; ... l2 = l1;
   • 只對其同類的數(shù)據(jù)賦值，不對函數(shù)賦值
   • 數(shù)據(jù)成員中不能包括動態(tài)分配的數(shù)據(jù)，否則在賦值時可能出現(xiàn)嚴(yán)重后果
2. 復(fù)制
   • 復(fù)制構(gòu)造函數(shù)：也是構(gòu)造函數(shù)，但它只有一個本類對象的參數(shù)。編譯系統(tǒng)提供一個默認的復(fù)制構(gòu)造函數(shù)。
   • lins::lins(const lins &l);
   • lins l2(l1); lins l2 = l1, l3 = l1; 等價，均復(fù)制了一個l1
   • 調(diào)用情況

     1. lins l1 = l2;
     
     2. void fun(lins lt){};
        fun(l1); //調(diào)用復(fù)制構(gòu)造函數(shù)創(chuàng)建lt
     
     3. lins fun(){ return l1; } 
        lins l2 = fun();//返回時調(diào)用復(fù)制構(gòu)造函數(shù)
     

靜態(tài)成員

1. 靜態(tài)數(shù)據(jù)成員
   • static int a;
   • 靜態(tài)數(shù)據(jù)成員不屬于某一個對象，靜態(tài)數(shù)據(jù)成員在對象之外單獨開辟空間。
   • 程序編譯時被分配空間的，到程序結(jié)束時才釋放空間。
   • 靜態(tài)數(shù)據(jù)成員可以初始化，但只能在類體外進行初始化。int lins::a = 1;
   • 如果未對靜態(tài)數(shù)據(jù)成員賦初值則編譯系統(tǒng)會自動賦予初值0。
   • 引用
     • 對象名 l1.a;
     • 類名 lins::a;
     • 私有靜態(tài)數(shù)據(jù)成員不能在類外直接引用，必須通過公用的成員函數(shù)引用
   • 公用靜態(tài)數(shù)據(jù)成員與全局變量的不同，靜態(tài)數(shù)據(jù)成員的作用域只限于定義該類的作用域內(nèi)
2. 靜態(tài)成員函數(shù)
   • static int fun();
   • 類外調(diào)用公用的靜態(tài)成員函數(shù)，lins::fun();或l.fun();
   • 主要用來訪問靜態(tài)數(shù)據(jù)成員而不訪問非靜態(tài)成員。無this指針，如要訪問通過l.a;的方式。

友元

1. 友元函數(shù)
   • 將普通函數(shù)聲明為友元函數(shù) friend void display(lins &);
   • 友元成員函數(shù)
     • 需要類的提前引用聲明
     • friend void lins::display(lins &); 表明lins類中的display函數(shù)能訪問本類中的成員
   • 可以被多個類聲明為“朋友”
2. 友元類
   • friend lins; 表明類lins中的所有成員都可以訪問本類中的成員
   • 友元的關(guān)系是單向的而不是雙向的
   • 友元的關(guān)系不能傳遞

類模板

• 聲明：template <class T1, class T2>
• 應(yīng)用：類模板名 <參數(shù)類型> 對象名(參數(shù)表); = lins <int> ls(1,2);
• 成員函數(shù)在類外定義需加上模板聲明

  template <class T>
  class compare {
  public:
    T max();
  private:
    T x, y;
  };
  
  template <class T>
  T compare<T>::max(){
      return (x > y) ? x : y;
  }
  

運算符重載

重載方法

• 實質(zhì)：函數(shù)的重載
• 函數(shù)類型 operator 運算符(形參) { 處理 }
• 原理

  class lins{
    public:
     lins operator + (lins &);
  }
  lins lins::operator + (lins &c2) {};
  
  c3 = c1 + c2;
  c3 = c1.operator + (c2); //等價
  

重載運算符規(guī)則

1. 僅能對已有運算符重載
2. 不允許重載的（五個）
   • . 、 * 、 :: 、 sizeof 、 ? :
3. 不能改變運算符運算對象（即操作數(shù)）的個數(shù)，結(jié)合性，優(yōu)先級
4. 重載函數(shù)不能有默認的參數(shù)
5. 重載的運算符必須和類的對象一起使用，其參數(shù)至少有一個是類對象（或類對象的引用）
6. 類的運算符一般都需要重載，但= &不用

類的運算符重載

1. 重載函數(shù)作為類的成員函數(shù)
2. 重載函數(shù)作為普通函數(shù)，在聲明為友元函數(shù)

• Note：對于雙目運算符，(1)僅需一個參數(shù)，因為還一個this，而(2)需要兩個參數(shù)
• 習(xí)慣規(guī)定
  • 賦值運算符=、下標(biāo)運算符[]、函數(shù)調(diào)用運算符()、成員運算符->必須作為成員函數(shù)
  • 流插入<<和流提取運算符>>、類型轉(zhuǎn)換運算符不能定義為類的成員函數(shù)，只能為友元
  • 一般單目為成員函數(shù)，雙目為友元函數(shù)（雙目需要交換律）

重載雙目

class lins{
  private:
    int x;
  public:
    friend bool operator > (lins &l1, lins &l2);

    //或者
    bool operator > (lins &l2) {
      return this.x > l2.x;
    }
}

bool operator > (lins &l1, lins &l2){
  return l1.x > l2.x;
}

重載單目

特殊++，--
1. ++i  前置
2. i++  后置 多一個int參數(shù)，本身無意義

class lins {
  private:
    int x;
  public:
    //前置
    lins operator ++ () {
      x++;
      return *this;
    }
    //后置
    lins operator ++ (int) {
      lins t(*this);
      x++;
      return t;
    }
}

重載<<和>>

• istream& operator >> (istream&,自定義類&);
• ostream& operator << (ostream&,自定義類&);
• Note：只能用友元的方式重載，成員函數(shù)方式會有this參數(shù)且是第一個參數(shù)。
  • 去掉自定義類參數(shù)后，不能正常使用cout << ls ;，因為第一個參數(shù)是this(ls)，第二個參數(shù)是ostream(cout)，順序反了所以錯誤，只能通過成員函數(shù)ls.operator<<(cout);來使用。
  • 不去掉自定義類，參數(shù)太多，順序也不對。
• 總結(jié)：對于雙目中那些需要需要滿足交換律的運算符，必須用友元方式重載。

不同數(shù)據(jù)類型間的轉(zhuǎn)換

• 編譯器自動完成的 -- 隱式轉(zhuǎn)換
  • int a = 1.5 + 1;
• 自己指定的 -- 顯式轉(zhuǎn)換
  • C：int a = (int)1.5;
  • C++：int a = int(1.5);
• 轉(zhuǎn)換構(gòu)造函數(shù)（沒什么意義）
  • lins(double r){real = r; imag = 0;}將double型的參數(shù)r轉(zhuǎn)換成lins類的對象，將r作為復(fù)數(shù)的實部，虛部為0。
• 類型轉(zhuǎn)換函數(shù)
  • operator 類型名() {實現(xiàn)轉(zhuǎn)換的語句}
  • operator int() {return a;}將對象轉(zhuǎn)化為int型數(shù)據(jù)，值為a

繼承與派生

概述

• 繼承：繼承基類內(nèi)容
• 派生：派生新內(nèi)容
• 派生類的聲明 class lins1: public lins{}
• 組合
  • 子對象可以是基類對象，也可以是另一個類的對象
  • 組合：在一個類中以另一個類的對象作為數(shù)據(jù)成員
  • 繼承是縱向的，組合是橫向的

派生類的構(gòu)成

1. 從基類接收成員
   • 除構(gòu)造，析構(gòu)函數(shù)外，都會接受。
   • 很容易產(chǎn)生冗余（可通過虛函數(shù)解決）
2. 調(diào)整從基類接收的成員
   • 改變訪問屬性
   • 創(chuàng)建同名函數(shù)來覆蓋(注意不是重載)
3. 在聲明派生類時增加的成員

• Note：派生類是抽象基類的具體實現(xiàn)

派生類成員的訪問屬性

1. 公用繼承 public
   • 基類的公有、保護成員在派生類中保持原有訪問屬性
   • 基類私有成員仍為基類私有
2. 私有繼承 private
   • 基類的公有、保護成員在派生類中成了私有成員
   • 基類私有成員仍為基類私有
3. 受保護繼承 protected
   • 基類的公有、保護成員在派生類中成了保護成員
   • 基類私有成員仍為基類私有

• 保護成員：可以在當(dāng)前類與派生類內(nèi)調(diào)用，不可在類外調(diào)用

派生類的構(gòu)造函數(shù)和析構(gòu)函數(shù)

• 簡單的派生類的構(gòu)造函數(shù)

  • 調(diào)用構(gòu)造函數(shù)：基類 -- 派生類
  • 形式：

    lins1(int n, string nam, int a, string ad):lins(n,nam){
     對lins1的剩余成員賦值 
    }
    

• 有子對象的派生類的構(gòu)造函數(shù)

  • 調(diào)用構(gòu)造函數(shù)：基類 -- 子對象 -- 派生類
  • 形式：

    lins1(int n, string nam, int n1, string nam1, int a, string ad):lins(n,nam), monitor(n1,nam1){
     對lins1的剩余成員賦值 
    };
    lins monitor;//monitor為lins基類的一個對象，子對象：對象中的對象
    

  • 子對象：對象中的對象

• 多層派生時的構(gòu)造函數(shù)

  • 從基類往下調(diào)用構(gòu)造函數(shù)

• 派生類的析構(gòu)函數(shù)

  • 在執(zhí)行派生類的析構(gòu)函數(shù)時，系統(tǒng)會自動調(diào)用基類的析構(gòu)函數(shù)和子對象的析構(gòu)函數(shù)，對基類和子對象進行清理。
  • 順序：后構(gòu)造的，先析構(gòu)

多重繼承

• 聲明方式：class D:public A, private B, protected C{類D新增加的成員}

• 構(gòu)造函數(shù)

  • D（總參數(shù)表）：A構(gòu)造(參數(shù)表)，B構(gòu)造(參數(shù)表)， C構(gòu)造(參數(shù)表) {};
  • 調(diào)用順序：基類構(gòu)造調(diào)用按照聲明時的順序

• 二義性問題

  • 多個基類中有同名成員：添加::來明確
  • 多個基類和派生類有同名成員：會屏蔽基類中的成員，而執(zhí)行派生類中成員
  • N->A N->B A,B->C：C中調(diào)用A或B中繼承N的成員需要::來明確

• 虛基類

  • 形式
    • class 派生類名: virtual 繼承方式 基類名
    • class lins1: virtual public lins {}
  • 作用：在繼承間接共同基類時只保留一份成員（解決第三類二義性問題）
  • 初始化：虛基類A的初始化由派生類D直接給出（避免沖突）
  • Note
    • 一般而言派生類只對直接基類初始化
    • 對于B,C對A的初始化會被忽略

基類與派生類的轉(zhuǎn)換

長的可以賦值給短的，短的指針可以指向長的（短的只能接受/訪問部分）

• 派生類對象可以向基類對象賦值（只給基類的部分），反之不行
• 派生類對象可以替代基類對象向基類對象的引用進行賦值或初始化

  A a;
  B b;
  A& r = a; //r與a共用一段存儲單元
  A& r = b; //變?yōu)?r與b共用一段存儲單元
  

• 如果函數(shù)的參數(shù)是基類對象或基類對象的引用，相應(yīng)的實參可以用派生類對象
• 指向基類對象的指針變量可以指向派生類對象

多態(tài)性與虛函數(shù)

多態(tài)性

由繼承而產(chǎn)生的相關(guān)的不同的類，其對象對同一消息會作出不同的晌應(yīng)。

表現(xiàn)：具有不同功能的函數(shù)可以用同一個函數(shù)名，這 樣就可以用一個函數(shù)名調(diào)用不同內(nèi)容的函數(shù)。

分類：

• 靜態(tài)多態(tài)性 -- 編譯時的多態(tài) -- 通過函數(shù)重載實現(xiàn)
• 動態(tài)多態(tài)性 -- 運行時的多態(tài) -- 通過虛函數(shù)實現(xiàn)

利用虛函數(shù)實現(xiàn)多態(tài)性

作用：允許在派生類中重新定義與基類同名的函數(shù)并且可以通過基類指針或引用來訪問基類和派生類中的同名函數(shù)

虛函數(shù)的使用

• virtual void display();
• 定義派生虛函數(shù)：在派生類中重新定義此函數(shù)，函數(shù)名、函數(shù)類型、函數(shù)參數(shù)個數(shù)和類型必須與基類的虛函數(shù)相同，根據(jù)派生類的需要重新定義函數(shù)體
• 定義指向基類對象的指針變量：使它指向同一類族中需要調(diào)用該函數(shù)的對象。
• 通過該指針變量調(diào)用此虛函數(shù)，此時調(diào)用的就是指針變量指向的對象的同名函數(shù)。

Note：使用虛函數(shù)，系統(tǒng)要有一定的空間開銷。當(dāng)一個類帶有虛函數(shù)時，編譯系統(tǒng)會為該類構(gòu)造一個虛函數(shù)表（virtual function table，簡稱 vtable），它是一個指針數(shù)組，存放每個虛函數(shù)的人口地址。系統(tǒng)在進行動態(tài)關(guān)聯(lián)時的時間開銷是很少的，因此，多態(tài)性是高效的。

虛析構(gòu)函數(shù)：

• 普通析構(gòu)函數(shù)只會調(diào)用本類的析構(gòu)，不會調(diào)用基類的
• 虛析構(gòu)函數(shù)會先調(diào)用派生類的析構(gòu)函數(shù)，然后調(diào)用基類析構(gòu)
• 當(dāng)基類的析構(gòu)函數(shù)為虛函數(shù)時，無論指針指的是同一類族中的哪一個類對象，系統(tǒng)都會采用動態(tài)關(guān)聯(lián)，調(diào)用相應(yīng)類的析構(gòu)函數(shù)，對該對象進行清理工作。

純虛函數(shù)與抽象類

純虛函數(shù)

• virtual void display() = 0;
• 基類中將某一成員函數(shù)定為虛函數(shù)，并不是基類本身的要求，而是派生類的需要，在基類中預(yù)留了一個函數(shù)名，具體功能留給派生類根據(jù)需要去定義

抽象類

• 本身不生成對象。只用作基類去建立派生類。
• 凡是包含純虛函數(shù)的類都是抽象類。因為純虛函數(shù)是不能被調(diào)用的，包含純虛函數(shù)的類是無法建立對象的。

輸入輸出流

C++的輸入輸出

• 標(biāo)準(zhǔn)的輸入輸出 -- 標(biāo)準(zhǔn)I/O
• 文件的輸入輸出 -- 文件I/O
• 字符串輸入輸出 -- 串I/O

cin cout 是 iostream 的對象

C++的流庫

• 基類：ios streambuf
• 派生：
  • istream ostream iostream "iostream"
  • ifstream ofstream fstream "fstream"
  • 字符串派生

標(biāo)準(zhǔn)輸出流

1. cout cerr和clog流
2. 標(biāo)準(zhǔn)類型數(shù)據(jù)的格式輸出
3. 用流成員函數(shù)put輸出字符 cout.put("a");

標(biāo)準(zhǔn)輸入流

1. cin流
2. 用于字符輸入的流成員函數(shù) cin.get(); cin.getline();
3. istream 類的其他成員函數(shù)

文件流

文件可分為：ASCII碼、二進制

文件流類與文件流對象

• ifstream ofstream fstream
• "fstream" 頭文件

文件的打開與關(guān)閉

1. 打開磁盤文件

   ofstream outfile; //／定義ofstream類（輸出文件流類）對象outfile 
   outfile.open("f1.txt", ios::out); //使文件流與 f1.txt文件建立關(guān)聯(lián) 
   
   open的一般形式： 
   文件流對象.open(磁盤文件名, 輸入輸出方式); 
   
   參數(shù)
   ios::in, ios::out, ios::out||ios::binary, ios::in||ios::binary
   

2. 關(guān)閉磁盤文件 outfile.close();

對ASCII文件的操作

• << >>
• 文件流的put get getline 等成員函數(shù)

  int a[5];
  ofstream outfile;
  outfile.open("f1.txt", ios::out);
  for (int i = 0; i < 5; i++)
  {
   cin >> a[i];
   outfile << a[i] << " "; //通過 << 操作文件
  }
  outfile.close();
  
  int b[5];
  ifstream infile;
  infile.open("f1.txt", ios::in);
  for (int i = 0; i < 5; i++)
  {
   infile >> a[i]; //通過 >> 操作文件
   cout << b[i] << " ";
  }
  infile.close();
  

對二進制文件的操作

• 用成員函數(shù)read和write讀寫二進制文件
  • istream& read(char* buffer, int len);
  • ostream& write(const char* buffer, int len);
• 與文件指針有關(guān)的流成員函數(shù)
• 隨機訪問二進制數(shù)據(jù)文件

字符串流

C++工具

異常處理

所謂異常處理指的是對運行時出現(xiàn)的差錯以及其他例外情況的處理。

方法：檢查(try)、拋出(throw)和捕捉(catch)

• try-catch塊

  try{  //可能出現(xiàn)異常的、需要檢查的語句或程序段
    被檢查的語句 //含有或內(nèi)部函數(shù)含有throw
  } 
  catch (異常信息類型 變量名){  //若無錯誤則不執(zhí)行
    進行異常處理的語句
  }
  

• try塊發(fā)生異常，則throw語句拋出異常信息。執(zhí)行throw語句后，流程立即離開本函數(shù)，轉(zhuǎn)到其上一級的函數(shù)。在throw中拋出什么樣的數(shù)據(jù)由程序設(shè)計者自定，可以是任何類型的數(shù)據(jù)（包括自定義類型的數(shù)據(jù)，如類對象）
• 異常信息提供給try-catch結(jié)構(gòu)，系統(tǒng)會尋找類型匹配的catch子句。比如：throw a(a為int型)，有catch(int){}，則匹配。
• catch(...)表示可捕獲任何類型的信息

在函數(shù)聲明中進行異常情況指定

• double triangle(double, double) throw(int, double);
• 表示只能拋出int double型的異常信息

析構(gòu)函數(shù)：若try塊中定義了對象，而throw又拋出了異常，此時需要結(jié)束本層而返回，本層的對象也要被清理，執(zhí)行析構(gòu)函數(shù)，然后匹配到catch執(zhí)行語句。

命名空間

由來：引用不同文件，如果不同的文件中有相同的名稱，編譯會出錯。

命名空間：一個由程序設(shè)計者命名的內(nèi)存區(qū)域。程序設(shè)計者可以根據(jù)需要指定一些有名字的空間域，把一些全局實體分別放在各個命名空間中，從而與其他全局實體分隔開來

關(guān)鍵字：namespace

namespace ls1 { //命名空間成員
  int a,
  double b;
  class lins{

  };
} //注意后面沒有分號
ls1::a; //訪問

使用命名空間解決名字沖突

使用命名空間成員的方法

• ls1::a;
• 別名：namespace ls = ls1; ls::a;
• using
  • using ls1::lins;表明在using的作用域中使用ls1中l(wèi)ins的成員不需要加::
  • using namespace ls1;表明在using的作用域中使用ls1中的成員不需要加::

標(biāo)準(zhǔn)命名空間std