

           9

           ࢠ , ⮬  뢠 .
            - ⮭ 稫

       ⮩  ᠭ 堭 ࠡ⪨ ᮡ 権  ,
      ᭮뢠騥  , ᯮᮡ ࠡ⪨ 訡. 堭 ⮨
       ᪥ ᮡ 樨,   墠 ᯥ樠
      ࠡ稪. 뢠 ࠢ 墠 ᮡ 権 
      ࠢ ॠ樨  墠祭   ᮡ 樨.
       㯯 ᮡ 権  ।  ந
      . 뢠 ᯮᮡ, ᯮ騩   ࠡ
      ᮡ 権,  ᯥ稢   ⮥ 
      짮⥫ ࠢ ᠬ.

   9.1 ࠡ⪠ 訡

   ⥫ ⥪ ᯮᮡ 㦨 ᪨ 訡,  
   ।⠢   饬 砥   ॠ  .
   짮⥫ ⥪ ᯮᮡ  ॠ  ⠪ 訡,
      ᨫ  㦨. ᫨   ,  ᠬ ࠧࠫ 
    訡  ᢮ ணࠬ,    諮  
     㭪.  襭 ⮩ ஡   
   ⨥ ᮡ 樨 .

    쪮  ⮬  ⠭⨧樨 ++ ᮡ 樨 뫨
   祭  ⠭ 몠,   ६ ᠭ ⮩   
    諨  設⢮ ॠ権.

    ⮣   ⮬,  㭪,  㦨 訡  
    ࠢ  , ᪠ ᮡ , 뢠, 
   ࠭ ஡   ⮩ 㭪樨,  אַ  ।
   뢠 . ᫨ 㭪 ⠭  ࠡ 訡 ண
   ,   㪠  ,  ⮢ 墠 
   ᮡ .
        ᬮਬ  ⢥ ਬ    Vector 
   ।⠢  ࠡ뢠 ᮡ 樨, 맢 室 
   ࠭ ᨢ:

                 class Vector {
                   int* p;
                   int  sz;
                 public:
                   class Range  {  };  //   ᮡ 樨

                   int& operator[](int i);

                   // ...
                 };

    ।,  ꥪ  Range  ᯮ짮 
    ᮡ 樨,  ᪠   ⠪:

                 int& Vector::operator[](int i)
                 {
                   if (0<=i && i<sz) return p[i];
                   throw Range();
                 }

    ᫨  㭪樨 ।ᬮ७ ॠ  訡 ⨬ 祭
    ,    㭪樨,  ன  訡  墠뢠,
        try.      ࠡ稪 ᮡ
    樨:

             void f(Vector& v)
             {
              // ...

              try {
               do_something(v);  // ᮤঠ⥫쭠 , ࠡ  v
              }
              catch (Vector::Range) {
              // ࠡ稪 ᮡ 樨 Vector::Range

              // ᫨ do_something()  㤠筮,
              // 㦭 - ॠ஢  

              //    ⮫쪮  ⮬ 砥, 
              // 맮 do_something() ਢ  맮 Vector::operator[]()
              // - ⨬ 祭 

              }

              // ...
            }

  ࠡ稪 ᮡ 樨 뢠 

             catch ( /* ... */ ) {
               // ...
             }

     ᯮ짮 ⮫쪮 ࠧ ᫥ , 稭饣 㦥
   ᫮ try,  ࠧ ᫥ 㣮 ࠡ稪 ᮡ 樨. 㦥
     ᫮ catch. ᫥    ᪮ ᠭ, ஥
   ᯮ 筮 ᠭ ଠ ࠬ஢ 㭪樨,  ,
      ⨯ ꥪ⮢,   ⠭ ࠡ稪, ,
   ,  ࠬ஢ (. $$9.3). ᫨  do_something()  
    맢   㭪樨 ந 訡  ( 
   ꥪ Vector),  ࠡ稪 墠 ᮡ   㤥
   믮 , ࠡ뢠 訡. ਬ, । ᫥
   㭪権 ਢ   ࠡ稪  f():

            void do_something()
            {
              // ...
              crash(v);
              // ...
            }

            void crash(Vector& v)
            {
               v[v.size()+10];  // ⢥ 뢠 訡 
            }

       ᪠  墠 ᮡ 樨 । ᬮ
   楯窨 맮  窨 ᪠ ᮡ 樨  㭪樨,  ன
    墠뢠.  ⮬ ⠭ ﭨ ⥪,
   ᮮ⢥饥 㭪樨, 墠⨢襩 訡,   室  ᥩ
   楯窥 맮   ꥪ⮢ 㭪権  ⮩ 楯窨 뢠
   . ஡  ᠭ  $$9.4.
      ᫨  ᬮ ᥩ 楯窨 맮, 稭  ⨢襩
   ᮡ  㭪樨,  㦨 室騩 ࠡ稪, 
   ணࠬ 蠥. ஡  ᠭ  $$9.7.
      ᫨ ࠡ稪 墠⨫ ᮡ ,   㤥 ࠡ뢠
    㣨, ⠭   , ࠡ稪  
   ᬠਢ. 묨 ᫮, ⨢஢ 㤥 ⮫쪮  ࠡ稪,
    室  ᠬ ᫥ 뢠襩 㭪樨, ᮤঠ饩
   ᮮ⢥騥 ࠡ稪.  襬 ਬ 㭪 f() 墠
   Vector::Range, ⮬  ᮡ   墠  
    뢠饩 f() 㭪樨:

            int ff(Vector& v)
            {
              try {
                    f(v);         //  f() 㤥 墠祭 Vector::Range
              }
              catch (Vector::Range) { //      
                 // ...
              }
            }

   9.1.1 ᮡ 樨  ࠤ樮 ࠡ⪠ 訡

    ᯮᮡ ࠡ⪨ 訡   ࠬࠬ 룮 ⫨砥 
    ࠤ樮 ᯮᮡ. ᫨,   ᤥ 
   樨 Vector::operator[]()  㦥 ⨬ 祭
   :
       [1]  ணࠬ;
       [2]  祭, ࠪ㥬  "訡";
       [3]  ଠ쭮 祭  ⠢ ணࠬ 
           । ﭨ;
       [4] 맢 㭪,   ॠ樨  ⠪ 訡.
     ਠ [1] (" ணࠬ") ॠ  㬮砭  ⮬
   砥,  ᮡ   뫠 墠祭.  設⢠
   訡   㦭 ᯥ  ॠ.
     ਠ [2] (" 祭 "訡"")  ॠ
    ᥣ, ᪮  ᥣ 㤠 । 祭 "訡".
   ,  襬 ਬ  楫  ⨬ 祭 
   १ 樨 樨. ᫨  뤥 ⠪ ᮡ
   祭,    ਠ  ࠢ 뢠 㤮,
   ᪮ ஢   祭 室   맮. 
     㤢 ࠧ ணࠬ. ⮬  㦥 
   訡  ਠ । ᯮ ᫥⥫쭮.
      ਠ [3] ("⠢ ணࠬ  । ﭨ")
     ⮪,  뢠 㭪   
   ଠ쭮 ﭨ ணࠬ. ਬ,   㭪
   ⠭⭮ ⥪   ᨣ樨  訡 ⠭
   ᮮ⢥饥 祭  쭮 ६ errno. ,
    ணࠬ 짮⥫ 筮  筮 ᫥⥫쭮
   ஫ errno,   १   訡,
   맢 ⥬,  ⠭ 㭪樨    祭.
   ஬ ⮣, ᫨  ணࠬ  ࠫ ᫥,
   ᯮ짮  쭮 ६  ᨣ樨  ࠧ
   訡  ਢ  .
     ࠡ⪠ ᮡ 権  ।砫   砥,
     ⠭ ਠ [4] ( "맢 㭪 ॠ樨 
   訡"). ⬥⨬, ,  ᫨ ᮡ 樨  ।ᬮ७,
     㭪樨 ॠ樨  訡   ࠧ ᯮ짮
   ⮫쪮    ᫥ ਠ⮢. 㦤 㭪権
   ॠ権  ᮡ 樥 㤥 த  $$9.4.3.
     堭 ᮡ 権 ᯥ譮  ࠤ樮
   ᯮᮡ ࠡ⪨ 訡   ,  ᫥ 
   , ᨢ  ॢ 訡 襭.  堭
     ⤥  ணࠬ,  ன ࠡ뢠
   訡,  ⠫쭮  , ⥬ ᠬ ணࠬ ⠭ 
   ⭮     ࠡ ࠧ ࢨ ணࠬ.
   ⢥ ⮬ 堭 ॣ ᯮᮡ ࠡ⪨ 訡
   頥 ⢨  ࠧ쭮 ᠭ묨 ﬨ
   ணࠬ.
       ⮬ ᯮᮡ ࠡ⪨ 訡   ணࠬ  
    : ⠭⭠ ॠ  訡 (ᮡ  訡
    筮 㭪樨) ⮨  襭 ணࠬ. ࠤ樮
   뫠 ॠ த ணࠬ  ,   -
    ᠬ. ⮬ ᯮᮡ, 騩  ᮡ ,
    ணࠬ  "㯪"  ⮬ ᫥,  ॡ
    ᨫ     ଠ쭮 믮.   -⠪
   , 祬   १    ⠤
   ࠧ ணࠬ (    ,  ணࠬ
    襭  । 祣  ॢ饬 짮⥫).
   ᫨ 襭 ணࠬ  ਥ ॠ樥, 
   ᬮ஢ ࠤ樮 ॠ   墠  ᮡ
   権   ᮡ 権, ਭ ᯥ樠쭮
    ($$9.3.2).
      堭 ᮡ 権  ᬠਢ  ᪨
    堭 ஫ ⨯  ஢ન 筮
    ⠤ ࠭樨.  ⠪ 室   ⠭
   ⠤ ஥஢ ணࠬ,  ॡ  প
    믮 ணࠬ, 祬  ணࠬ  . ,
    १   ।᪠㥬 ணࠬ,  㤥 
   ந  ணࠬ ⥬,  㤥 ⭥ 㣨 ணࠬ⠬ 
      㤥 ࠡ ࠧ ࢨ ணࠬ. 
   ᪠,  堭 ᮡ 権 ন,
    㣨 ।⢠ ++, "訩" ⨫ ணࠬ஢,
     ⠪ 몠,  ,  ਬ ⮫쪮   
   ꥬ   ଠ쭮 ஢.
         ᮧ,  ࠡ⪠ 訡 ⠥ 㤭
   祩, ,  堭 ᮡ 権  ண,
   祬 ࠤ樮 ᯮᮡ,   ࠢ 筮 ஢
    ࠢ  ﬨ, ᪠騬 ⮫쪮  ।
   ࠢ.

   9.1.2 㣨 窨 ७  ᮡ 樨

   "ᮡ " -    ⨩,   ࠧ 
    ࠧ .  ++ 堭 ᮡ 権 ।祭 
   ࠡ⪨ 訡.  ⭮,  ।祭  ࠡ⪨ 訡
    ணࠬ,   ᨬ ᮧ ⮢.
       堭 ⠭  ᮡ 樨, 騥 ⮫쪮 
   ᫥⥫쭮 믮 ணࠬ (ਬ, ஫ ࠭
   ᨢ). ᨭ஭ ᮡ 樨 ⠪, ਬ,  뢠
    ,  ।⢥ ࠡ뢠   ⮣
   堭.  ࠧ ⥬  㣨 堭,
   ਬ, ᨣ,     ᬠਢ, ᪮ 
    ⭮ ⥬.
      堭 ᮡ 権  樥  쭮
   ।祩 ࠢ    ᬠਢ  ਠ 
   return. ⮬ ᮡ 樨  ᯮ짮  楫, 
    易  ࠡ⪮ 訡 ($$9.5). -⠪ ᭮
   祭 堭 ᮡ 権  ⥬ ⮩  㤥
   ࠡ⪠ 訡  ᮧ ⮩稢  訡 ணࠬ.

   9.2 祭 ᮡ 権

   ⢥,  ணࠬ  ᪮쪮 ࠧ ᪨
   訡.  訡  ᮯ⠢  ᮡ묨 ﬨ, 騬
   ࠧ . ,   Vector 筮 室 
    ᮮ  訡  : 訡   訡,
   맢 室騬   ࠬ஬:

           class Vector {
             int* p;
             int sz;
           public:
             enum { max = 32000 };
             class Range { };  // ᮡ  
             class Size { };   // ᮡ  " ࠧ"
             Vector(int sz);
             int& operator[](int i);

             // ...
          };

    뫮 ᪠,  樨 ᪠ ᮡ 
   Range, ᫨   室騩   祭 .
    ᪠ ᮡ  Size, ᫨  
   ⨬ ࠧ :

          Vector::Vector(int sz)
          {
            if (sz<0 || max<sz) throw Size();
            // ...
          }

   짮⥫  Vector  ࠧ   ᮡ 樨,
   ᫨  ஢塞  (..    try) 㪠
   ࠡ稪   権:

          void f()
          {
            try {
                use_vectors();
            }
            catch (Vector::Range) {
                // ...
            }
            catch (Vector::Size) {
                // ...
            }
          }

    ᨬ  ᮡ 樨 㤥 믮 ᮮ⢥騩
   ࠡ稪. ᫨ ࠢ    ஢ ࠡ稪,
   ᫥騬 㤥 믮 ,   ᫥ ᯨ᪠
   ࠡ稪:

          void f()
          {
            try {
               use_vectors();
            }
            catch (Vector::Range) {
               // ࠢ  
               // ஡ :
               f();
            }
            catch (Vector::Size) {
               cerr << "訡   Vector::Size";
               exit(99);
            }
            //   , ᫨   뫮 ᮡ 権
            //  ᫥ ࠡ⪨ ᮡ 樨 Range
         }

   ᮪ ࠡ稪  ४⥫,    ⥫
   ࠡ稪  break  㦭. ⠪ ᯨ᪠ ࠡ稪
   ⫨祭  ᨭ⠪ ਠ⮢ case ४⥫ 筮 
   ⮩ 稭, 筮 ⮬, ⮡ ,  
   ࠡ稪 । ᢮   (. $$9.8).
       易⥫쭮  ᮡ 樨 墠뢠   㭪樨:

         void f1()
         {
           try {
             f2(v);
           }
           catch (Vector::Size) {
           // ...
           }
         }

         void f2(Vector& v)
         {
           try {
              use_vectors();
           }
           catch (Vector::Range) {
           // ...
           }
         }

    f2() 墠 ᮡ  Range,  
   use_vectors(),  ᮡ  Size 㤥 ⠢  f1().
      窨 ७ 몠 ᮡ  ⠥ ࠡ⠭ ࠧ
    室  ⥫  ࠡ稪. ⮬  ᮡ 樨,
   ᪠  믮 ⮣ ࠡ稪,  ࠡ뢠
    㭪, 맢  㭪,  ᮤন ஢塞 .
     ᫥饬 ਬ   ᪮筮 横:

          try {
              // ...
          }
          catch (input_overflow) {
             // ...
             throw input_overflow();
          }

    input_overflow (९  ) -  쭮 .
     ࠡ稪 ᮡ 権   묨:

          try {
             // ...
          }
          catch (xxii) {
            try {
               // ᫮ ॠ
            }
            catch (xxii) {
               // 訡   ᫮ ॠ樨
            }
          }

   , ⠪  । 뢠 㦭   ணࠬ,
     ᥣ   ᢨ⥫⢮ 宣 ⨫.

   9.3  ᮡ 権

   ᮡ  墠뢠  ᢮ ⨯. ,
   ᪠   ⨯,  ꥪ. ᫨  㦭 । 
   ଠ  窨 ᪠  ࠡ稪,   ⮣  ᫥
     ᪠ ꥪ. ਬ, ⨬ 㦭 
   祭 , 室饥  ࠭ :

          class Vector {
             // ...
          public:
             class Range {
             public:
               int index;
               Range(int i) : index(i) { }
            };
            // ...
            int& operator[](int i)
            // ...
         };

         int Vector::operator[](int i)
         {
           if (o<=i && i <sz) return p[i];
           throw Range(i);
         }

   ⮡ ᫥ ⨬ 祭 ,  ࠡ稪
   㦭   ꥪ, ।⠢饬 ᮡ :

         void  f(Vector& v)
         {
           // ...

          try {
              do_something(v);
          }
          catch (Vector::Range r ) {
             cerr << "⨬ " << r.index << '\n';
             // ...
          }
          // ...
        }

     ᪮ ᫥ 㦥 ᫮ catch   
   ᠭ   筠 ᠭ ଠ쭮 ࠬ 㭪樨.
     㪠뢠    ⨯ ࠬ (.. ᮡ
   樨)      䠪᪮, .. 饭,
   ᮡ 樨. ᯮ,   蠡 ⨯    롮
     ᮡ 権.   ᮧ  蠡 
    ᢮  ᮡ 樨:

         template<class T> class Allocator {
            // ...
            class Exhausted { }
            // ...
            T* get();
        };

        void f(Allocator<int>& ai, Allocator<double>& ad)
        {
           try {
               // ...
           }
           catch (Allocator<int>::Exhausted) {
              // ...
           }
           catch (Allocator<double>::Exhausted) {
             // ...
           }
         }

    㣮 ஭, ᮡ    饩  
   ᮧ  蠡 ᮢ:

         class Allocator_Exhausted { };

         template<class T> class Allocator {
            // ...
            T* get();
         };

         void f(Allocator<int>& ai, Allocator<double>& ad)
         {
           try {
              // ...
           }
           catch (Allocator_Exhausted) {
              // ...
           }
         }

    ᯮᮡ  ᮡ 樨 ।⥫쭥, ᪠ 㤭.
   롮   祭 ᬠਢ 蠡.

   9.3.1 㯯஢ ᮡ 権

   ᮡ 樨 ⢥ ࠧ ࠧ  ᥬ⢠.
   ⢨⥫쭮, 筮 ।⠢ ᥬ⢮ Matherr,  ஥
   室 Overflow (९), Underflow ( 稬) 
    㣨 ᮡ 樨. ⢮ Matherr ࠧ
   ᮡ 樨,   ᪠ ⥬᪨ 㭪樨
   ⠭⭮ ⥪.
       ᯮᮡ  ⠪ ᥬ⢠ ᢮  ।
   Matherr  ⨯,  祭 ண  Overflow 
    ⠫:

           enum { Overflow, Underflow, Zerodivide, /* ... */ };

           try {
               // ...
           }
           catch (Matherr m) {
               switch (m) {
               case Overflow:
                    // ...
               case Underflow:
                    // ...
               // ...
               }
               // ...
           }

   㣮 ᯮᮡ । ᯮ짮 ᫥  㠫
   㭪権, ⮡   ४⥫  祭  ⨯.
   ᫥   ᥬ⢠ ᮡ 権:

            class Matherr { };
            class Overflow: public Matherr { };
            class Underflow: public Matherr { };
            class Zerodivide: public Matherr { };
            // ...

    뢠 ⠪,  㦭 ࠡ ᮡ  Matherr
    ᨬ  ⮣,     ⮣ ᥬ⢠
   ந諠. ᫥  ᤥ  :

            try {
               // ...
            }
            catch (Overflow) {
               // ࠡ⪠ Overflow   ந 樨
            }
            catch (Matherr) {
                // ࠡ⪠  ⫨筮  Overflow 樨
            }

       ⮬ ਬ Overflow ࠧࠥ ⤥쭮,   㣨 ᮡ
   樨  Matherr ࠧ   騩 砩. 筮,
   㭪, ᮤঠ catch (Matherr),  㤥   
   ᮡ   墠뢠.      뫠, 
   室  ࠡ稪 ।   㤥 Matherr. 筮 
    ࠧ ,  㦭. ᫨   ⠪, ᮡ  
   墠  뫪 (. $$9.3.2).
      ᪮ 㯮冷稢 ᮡ 権   
   ஫  ᮧ ᭮  ணࠬ. ⢨⥫쭮, 
   ⠪ 㯮冷稢 ,  㦭 ࠡ  ᮡ
   樨 ⠭⭮ ⥪ ⥬᪨ 㭪権.  ⮣
   ਤ  ᪮筮    ᮡ 樨:

            try {
                // ...
            }
            catch (Overflow) { /* ... */ }
            catch (Underflow) { /* ... */ }
            catch (Zerodivide) { /* ... */ }
            // ...

     ⮫쪮 ⮬⥫쭮,   ᭮, ᪮  
   - ᮡ . ஬ ⮣, 室 ᫨
    ஢塞   ᮡ 樨 ࠪ᪨ ࠭,
   ,  ᥬ⢮ ᮡ 権 ⥪ , 
   ணࠬ 짮⥫  訡.  ,  
     ᮡ 樨  ⥪ ⥬᪨ 㭪権
   ਤ ࠭᫨஢   ணࠬ,  ᮤঠ
   ࠡ稪  ᮡ 権  Matherr.  饬 砥 ⠪
   ࠭ ਥ.     
    ॡ騥 ࠭樨  ணࠬ. ᫨ ⠪
    ,  ॡ, ⮡ ᥣ 
   㯥 室 ⥪   让 ணࠬ,  ⮡  
   뫨 ࠢ    让 ணࠬ, 室 ⥪
   ன  .  ᠬ , 짮⥫   㬠
    ७ ன⢥ ⥪.   ஡ ࠭樨
    ᮯ஢  ਢ  ⮬,  ᫥ ᮧ
   ࢮ ᨨ ⥪ 㤥     
   ᮡ 樨.  ⠪ 襭  室 ࠪ᪨  
   ⥪.
            ,  ᮡ 樨 㦭
   ।   ᮢ (. ⠪ $$9.6.1). ,  ᢮
   ।, 砥,  ᮡ 樨   童 ᪮쪨
   㯯:

           class network_file_err  // 訡 䠩 ⥬  
             : public network_err, // 訡 
               public file_system_err { // 訡 䠩 ⥬
               // ...
           };

   ᮡ  network_file_err  墠  㭪,
   ࠡ뢠 ᮡ 樨 :

           void f()
           {
             try {
                 // - 
             }
             catch (network_err) {
                 // ...
             }
           }

    ⠪  墠  㭪, ࠡ뢠 ᮡ 樨
   䠩 ⥬:

           void g()
           {
              try {
                  // - 㣨 
              }
              catch (file_system_err) {
                  // ...
              }
            }

     , ᪮ ⠪ ⥬ ࢨ  ࠡ 
      ஧祭,   砥,  ᮧ⥫ 㭪樨
   g()     ,   㭪 㤥 믮
    ⥢ ०.
       ⬥⨬,   饥 ६  ⠭⭮ ⢠
   ᮡ 権  ⠭⭮ ⥬᪮ ⥪ 
   ⥪ -뢮.  ⮢ ANSI  ISO  ⠭⨧樨
   ++  㦭  ⠪ ⢮     ᫥ ᯮ짮
     .
       ᪮  ࠧ 墠  ᮡ 樨
   (. $$9.3.2),  ⥫쭮 室 ᮧ  ⮩
   楫 騩,    ᮡ 権, . , ᫨
    ᮡ 樨  ந묨  ⮣ 
   Exception (ᮡ ),   䥩  ᯮ짮
   ⠭  ॣ (. $$9.6). ᫨  ᯮ 騩
     Exception, 㡥,    祣  ஬
   㠫쭮 .  ⨢ 砥 ⠪  
   㯨  ⨢稥  । ⠭⮬.

   9.3.2 ந ᮡ 樨

   ᫨  ࠡ⪨ ᮡ 権  ᯮ㥬  ᮢ,
   , ⢥,  ࠡ稪  ࠧ ⮫쪮 
    ଠ樨, ।  ᮡ .  ᪠,
   ,  ࠢ, ᮡ  墠뢠 ࠡ稪
     ,   ࠡ稪 , ᮮ⢥饣
    ⮩ ᮡ 樨.   墠 ࠡ稪 ᮡ
   樨 ᥬ᪨ ⭮   祭 ࠬ
    㭪樨.  , ଠ ࠬ 樠
   祭 䠪᪮ ࠬ.  砥,  饭
   ᮡ  ""  ᮡ 樨, 
   ࠡ稪. ਬ:

             class Matherr {
               // ...
               virtual void debug_print();
             };

             class Int_overflow : public Matherr {
             public:
                char* op;
                int opr1, opr2;;
                int_overflow(const char* p, int a, int b)
                   { cerr << op << '(' << opr1 << ',' << opr2 << ')'; }
             };

             void f()
             {
               try {
                   g();
               }
               catch (Matherr m) {
                   // ...
               }
             }

    室  ࠡ稪 Matherr ᮡ  m  ꥪ⮬
   Matherr,  ᫨  饭  g() 뫠 饭 Int_overflow.
    砥,  ⥫쭠 ଠ, । 
   Int_overflow, 㯭.
        筮, ⮡    ⥫쭮 ଠ樨 
   ᯮ짮 㪠⥫  뫪. ⮬  뫮  ⠪:

             int add(int x, int y)   // ᫮ x  y  ஫
             {
               if (x > 0 && y > 0 && x > MAXINT - y
                || x < 0 && y < 0 && x < MININT + y)
                   throw Int_overflow("+", x, y);

                //   ,   ஢ઠ
                //  ९  ⥫ १,
                //   x  y  ࠧ 

                return x + y;
              }

              void f()
              {
                 try {
                    add(1,2);
                    add(MAXINT,-2);
                    add(MAXINT,2);  //   - ९
                 }
                 catch (Matherr& m) {
                    // ...
                    m.debug_print();
                 }
               }

    ᫥ 饭  add ਢ   ᮡ 樨,
   ,  ᢮ ।, ਢ  맮 Int_overflow::debug_print().
   ᫨  ᮡ  ।  祭,    뫪, 
   뫠  맢 㭪 Matherr::debug_print().
       । 뢠 ⠪,  墠⨢ ᮡ , ࠡ稪
   蠥,   ⮩ 訡  祣  ᬮ .  ⠪
   砥 ᠬ ⢥  ᮡ   ᭮  ,
      㬥 ࠧ 㣮 ࠡ稪:

                void h()
                {
                  try {
                      // - 
                  }
                  catch (Matherr) {
                    if (can_handle_it) { // ᫨ ࠡ⪠ ,
                       // ᤥ 
                    }
                    else {
                       throw;  //   墠祭
                               // ᮡ 樨
                    }
                  }
                }

     뢠   throw  ࠬ஢.
    ⮬ ᭮ ᪠ 室 ᮡ ,  뫠
   墠祭,     ,   ⠭ ࠡ稪
   Matherr. 묨 ᫮, ᫨ 뫠 饭 Int_overflow, 뢠
   h() 㭪   墠   Int_overflow, ᬮ 
   ,   뫠 墠祭  h()  Matherr  饭 ᭮:

                 void k()
                 {
                   try {
                     h();
                     // ...
                   }
                   catch (Int_overflow) {
                     // ...
                   }
                 }

        ஦ 砩 १᪠.    㭪権,
     ...  ࠡ稪 砥 " ࠬ", ⮬
     catch (...) 砥 墠  ᮡ 樨:

                 void m()
                 {
                    try {
                       // - 
                    }
                    catch (...) {
                       // ਢ   冷
                       throw;
                    }

                 }

    ਬ   ⠪: ᫨  믮 ᭮ 
   m()  ᮡ , 믮 ࠡ稪, 
   믮 騥 ⢨  ࠭ ᫥⢨ ᮡ 樨,
   ᫥  ⢨ ᮡ , 맢 , ᪠
   ୮.
      ᪮ ࠡ稪  墠 ந ᮡ 樨
   ᪮쪨 ⨯, 冷,  ஬  ࠡ稪  ஢塞
   , ⢥. ࠡ稪  墠 ᮡ
     浪  ᠭ. ਢ ਬ:

                try {
                   // ...
                }
                catch (ibuf) {
                   // ࠡ⪠ ९  
                }
                catch (io) {
                   // ࠡ⪠  訡 -뢮
                }
                catch (stdlib) {
                   // ࠡ⪠  ᮡ 樨  ⥪
                }
                catch (...) {
                   // ࠡ⪠  ⠫ ᮡ 権
                }

         ᮡ 樨  ࠡ稪 ᮮ⢥ ⨯ 饭
   ᮡ 樨  ᫥ : ᫨  ⨯ ᮢ, 
   ன ⨯  ⨯ 㯭   饭 樨,
      㪠⥫  ⠪ ,  ⨯  樨
   ⮦ 㪠⥫ ($$R.4.6).
        ᪮ ࠭ ⭠  ᮢ,  ᯮᮡ
   㦨 ⠪  訡,  ࠡ稪  catch (...) 㪠
    ᫥,   ࠡ稪 樨  
   । ࠡ稪 ந  ⮣  樨
   ($$R15.4).   , ᫥騩 ࠡ稪 ( ࠡ稪)
      饭, ᪮  "᪨" 
   ࠡ稪.


   9.4  ᮢ

   ᫨  ன 㭪樨 ॡ । , ਬ,
   㦭  䠩, ⢥     ᢮
   , ⠭  ࠢ 㯠  ..,  쭥襩
   ࠡ ⥬ 筮 뢠 ࠩ , ⮡  뫨
   ᢮ 騬 ࠧ. 筮 ⠪ "騩 ᯮᮡ"
   ॠ 㭪,  ன ந室  ᮢ  ᢮
    । 室. ਬ:

              void use_file(const char* fn)
              {
                FILE* f = fopen(fn,"w");

                // ࠡ⠥  f

                fclose(f);
              }

     룫廊  ଠ쭮   ,    ,
      訡, ந襤襩 ᫥ 맮 fopen()   맮
   fclose(),  ᮡ ,  १ ன 
   멤  use_file(),    fclose().

    ⮨ ᪠,    ஡    몠, 
   ন ᮡ 樨. , 饭  㭪樨 longjump()
    ⠭⭮ ⥪    ⠪  
   ᫥⢨.

   ᫨  ᮧ ⮩稢  訡 ⥬,  ஡
   ਤ .   ਬ⨢ 襭:

              void use_file(const char* fn)
              {
                FILE* f = fopen(fn,"w");
                try {
                    // ࠡ⠥  f
                }
                catch (...) {
                    fclose(f);
                    throw;
                }
                fclose(f);
              }

     㭪樨, ࠡ  䠩 f, 饭  ஢塞
   ,  ஬ 墠뢠  ᮡ 樨, 뢠
   䠩  ᮡ  ᪠ ୮.
       ⮪ ⮣ 襭   ᫮, ஬
    ⥭樠쭮 ⥫쭮.  ⮬  类 ᫮
    ஬ 襭 ॢ 訡,    ᨫ ⠫
   ணࠬ.  ,   ਥ 襭.  饬
    ஡  㫨஢ ⠪:

             void acquire()
             {
               //   1
               // ...
               //   n

               // ᯮ짮 ᮢ

               // ᢮  n
               // ...
               // ᢮  1
             }

    ࠢ 뢠 , ⮡  ᢮  ⭮
    ࠢ  ᠬ 浪.  祭 ᨫ쭮  冷
   ࠡ  묨 ꥪ⠬, ᮧ묨 ࠬ 
   㭨⮦묨 ࠬ. ⮬    ஡  
   ᢮ ᮢ, ᫨ 㤥 ᯮ짮 室騥 ꥪ
   ᮢ  ࠬ  ࠬ. ਬ,  ।
    FilePtr,  㯠  ⨯ FILE* :

             class FilePtr {
                FILE* p;
             public:
                FilePtr(const char* n, const char* a)
                  { p = fopen(n,a); }
                FilePtr(FILE* pp) { p = pp; }
                ~FilePtr() { fclose(p); }

                operator FILE*() { return p; }
             };

   ந ꥪ FilePtr  ,  ꥪ ⨯ FILE*, ,
   稢 㦭  fopen() ࠬ.   砥 
   ꥪ 㤥 㭨⮦  室    , 
     ஥ 䠩.   ਬ ᦨ  ⠪
   㭪樨:

             void use_file(const char* fn)
             {
               FilePtr f(fn,"w");
               // ࠡ⠥  f
             }

    㤥 뢠 ᨬ  ⮣, 稫  㭪
   ଠ쭮,  ந襫  ᮡ 樨.

   9.4.1   

   ᠭ ᯮᮡ ࠢ ᠬ 筮 뢠 " ᮢ
   ⥬ 樠樨".  㭨ᠫ ਥ, ⠭ 
   ᢮⢠ ஢  ஢   ⢨ 
   堭 ᮡ 権.
      ꥪ  ⠥ ஥,   訫 믮 
   . 쪮 ᫥ ⮣  ⪠ ⥪,
   ᮯ஢ 맮  ꥪ. ꥪ, 騩 
    ꥪ⮢, ஥  ⮩ ⥯,   ஥
    ꥪ.
       ᠭ   ࠭஢,  ꥪ
   ஥   ࠢ쭮. ᫨   㤠 ᤥ ,
    , ᪮쪮  , ⠭ ﭨ ⥬,
   ஥ 뫮  砫 ஥.   ஢ 뫮 
   쭮 ᥣ 㤮⢮    ᫮ - ࠢ쭮
    祭 ꥪ⮢,    ⠢ ꥪ
    " ஥" ﭨ. ⮣  , ᫨
   ਬ  ஥ 童 ᯮᮡ " ᮢ ⥬
   樠樨".
      ᬮਬ  X,  ண ॡ  :
   䠩 x   y (..  ࠢ 㯠  祬-).
       ⪫  ਢ   ᮡ
   樨. ⮡  ᫮ ࠡ ணࠬ,  ॡ,
   ⮡   X   蠫 ⥬,   
   䠩 㤮⢮७,    .  ।⠢  
   ᮢ  㤥 ᯮ짮 ꥪ  ᮢ FilePtr 
   LockPtr (⢥, 뫮  筮  , ᫨ x  y
     ).   룫廊  樠
   ।⠢饣  ꥪ:

             class X {
               FilePtr aa;
               LockPtr bb;
               // ...
               X(const char* x, const char* y)
                  : aa(x),      //  `x'
                  bb(y)         //  `y'
               { }
               // ...
             };

   ,   뫮    ꥪ⮢,  㦥
   ࠡ, 易  ᠬ,    ॠ.
   짮⥫  易 ᫥  室 ⠪ ࠡ⮩. ਬ,
   ᫨ ᫥ ஥ aa   ஥ bb  ᮡ
   ,  㤥 맢 ⮫쪮  aa,   bb.
         砥,  ᫨ ண ਤন ⮩ ⮩
   奬  ᮢ,   㤥  浪.   
   ,  ᮧ⥫   㦭 ᠬ  ࠡ稪
   ᮡ 権.
         ॡ 뤥   ᢮  ࠪ७ ᠬ
   ந 冷  ᮢ. ਬ ⠪ ᮢ 㦥
   ⭮ 砫  ⮩ :

               class X {
                 int* p;
                 // ...
               public:
                 X(int s) { p = new int[s]; init(); }
                 ~X() { delete[] p; }
                 // ...
               };

    ⨯ ਬ ᯮ짮 ᢮ ,   ᮢ㯭 
   ᮡ묨 ﬨ   ਢ   ௠ .
   ⢨⥫쭮, ᫨  init() 饭 ᮡ ,  ⢥
     㤥 ᢮.   㤥 뢠, ᪮
   ஥ ꥪ  뫮 襭.    ਠ
   ⮣ ਬ:

                template<class T> class MemPtr {
                public:
                   T* p;
                   MemPtr(size_t s) { p = new T[s]; }
                   ~MemPtr() { delete[] p; }
                   operator T*() { return p; }
                }

                class X {
                   MemPtr<int> cp;
                   // ...
                public:
                   X(int s):cp(s) { init(); }
                   // ...
                };

    㭨⮦ ᨢ,   㪠뢠 p, ந室 
    MemPtr. ᫨ init()  ᮡ , ⢥ 
   㤥 ᢮   맮   
   ஥  ꥪ cp.
        ⬥⨬ ⠪,  ⠭⭠ ⥣ 뤥   ++
   ࠭,  ᫨ 㭪樨 operator new()  㤠 뤥 
    ꥪ,       㤥 뢠. 
   砥,  짮⥫   ,   
      맢  饣 ꥪ.
        ᪨ ⥫ 室, ॡ騥  ࠡ⪨
   ᮡ 権,   ᠬ       , 
    ᢥ  . ,    ୮  ࠭
   ॠ 몠. ⮬ 㤥 ࠧ㬭   ७ 横
   ணࠬ   ᯮ짮  ६ ᮢ
    ࠬ.

   9.4.2 ।०

     ணࠬ   ⮩稢  ᥬ  訡.  
     ⮫쪮 묨, ⮡ ࠢ ⪨
       ᠭ ᯮᮡ " ᮢ ⥬
   樠樨".  ⢮ ணࠬ,   
   室   믮  .   ᠬ 室饩
   ॠ樥   訡 㤥  ४饭 
   (᫥ 뤠 ᮮ⢥饣 ᮮ饭). ᢮ 
   ॡ ᮢ   ⥬,  짮⥫
    ந   ணࠬ   室騬
   室묨 묨.  奬 ।祭  ,  
   ⠪ ਬ⨢ ॠ   訡 ਥ.
   ਬ, ࠧࠡ稪 ⥪ 筮   ࠢ  饭
    ⮬, ᪮쪮 ⮩稢  訡,   ணࠬ,
   ࠡ  ⥪. ⮬   뢠  ᪨
   訡  ᢮      筮 㭪樨
    짮⥫ ணࠬ. ⮤ " ᮢ ⥬
   樠樨"  ᮢ㯭  ᮡ묨 ﬨ, ᨣ騬
    訡,  ਣ  ᮧ  ⥪.

   9.4.3 ௠ 

       ஡ ணࠬ஢:  , ᫨ 
   㤠 㤮⢮   ? ਬ,  ।饬
   ਬ  ᯮ 뢠   fopen() 䠩  訢 
    樨 new  ᢮ ,  뢠  ⮬,
    ⠪ 䠩   ,  ᢮   ௠.
    襭 ⠪ த ஡  ணࠬ⮢   ᯮᮡ:
        : 짮⥫   ᢮  
        .
       襭:  ⥫   ⥬, ᫨
        ,  ᮡ .
    ᯮᮡ ।   ਥ 
   ᮤ⢨ 짮⥫,  ஬ 짮⥫   ⮢
   ࠢ쭮 ॠ஢  ⪠  뤥 ᮢ.  設⢥
   砥 ᫥ ᯮᮡ     ন 
   ⥬ ࠧ ࠧ ஢ ࠪ樨.
        ++  ᯮᮡ ঠ 堭 맮 㭪権, 
   ன - 堭 ᮡ 権.  ᯮᮡ 
   த஢  ਬ ॠ樨  ᯮ짮 樨
   new:

              #include <stdlib.h>

              extern void* _last_allocation;

              extern void* operator new(size_t size)
              {
                void* p;

                while ( (p=malloc(size))==0 ) {
                   if (_new_handler)
                      (*_new_handler)();  // ⨬  
                   else
                      return 0;
                }
                return _last_allocation=p;
              }

   ᫨  new()    ᢮ ,  頥
    ࠢ饩 㭪樨 _new_handler(). ᫨  _new_handler() 
   뤥  ꥬ ,  ଠ쭮. ᫨ , 
   ࠢ饩 㭪樨     new, ..
    ᪮ 横. ⮬ ࠢ 㭪 
    ᮡ   ।⠢ ࠢ 
   ணࠬ, ⨢襩  new:

              void my_new_handler()
              {
                try_find_some_memory();   // ⠥ 
                                          // ᢮ 
                if (found_some()) return; // ᫨  ,   浪
                throw Memory_exhausted(); //  ᪠ ᮡ
                                          //  "௠_"
              }

   -  ணࠬ   ஢塞   ᮮ⢥騬
   ࠡ稪:

              try {
                  // ...
              }
              catch (Memory_exhausted) {
                  // ...
              }

        㭪樨 operator new() ᯮ짮 㪠⥫  ࠢ
   㭪 _new_handler,  ࠨ ⠭⭮ 㭪樥
   set_new_handler(). ᫨ 㦭 ந  ᮡ⢥ ࠢ
   㭪,   ⠪

             set_new_handler(&my_new_handler);

   墠  Memory_exhausted  ᫥騬 ࠧ:

             void (*oldnh)() = set_new_handler(&my_new_handler);

             try {
                // ...
             }
             catch (Memory_exhausted) {
                // ...
             }
             catch (...) {
                set_new_handler(oldnh);  // ⠭ 㪠⥫ 
                                         // ࠢ 㭪
                throw();      //   ᮡ 樨
             }

             set_new_handler(oldnh); // ⠭ 㪠⥫ 
                                     // ࠢ 㭪

    㯨  , ᫨  ࠢ饩 㭪樨 ਬ
   ᠭ  $$9.4 ⮤ " ᮢ ⥬ 樠樨" 
    ࠡ稪 catch (...).
        襭, ᯮ騬 my_new_handler(),  窨 㦥
   訡  㭪樨,  ன  ࠡ뢠,  ।
    ଠ樨. ᫨ 㦭 । - , 
   짮⥫   ᢮ ࠢ 㭪  .
     㭪樨, 㦨襩 訡, 㦭    
   ꥪ ⮣ .  ᯮᮡ, ᯮ騩 ꥪ-㭪樨,
   ਬ  $$10.4.2  ॠ樨 ஢. ᮡ, 
   ஬ ᯮ 㪠⥫  㭪  ꥪ-㭪 
   ⮣, ⮡  ࠢ饩 㭪樨, 㦨饩  ,
   ந " 맮" 㭪樨 ᨢ襩  ,
   筮 뢠   맮 (callback).
        ⮬ 㦭 ,  祬  ଠ樨 ।
    㦨襩 訡 㭪樨  㭪,   ࠢ,
   ⥬  ᨬ  ⨬  㭪ﬨ.  饬 砥
    ᢮   ⠪ ᨬ, ᪮ 类
       㭪権 ਤ   ⮬ 㣮 㭪樥,
   , ,  ⮦ ਤ . ,   ᬥ訢
   ⤥  ணࠬ. 堭 ᮡ 権 
   ࠭ ࠧ쭮 ⮢ , 祬  堭 맮
   ࠢ 㭪権,   㭪, ॡ .
       饬 砥 ࠧ㬭 室 ⮨  ⮬, ⮡ 뤥
   ᮢ 뫮 ஢ ( ᮮ⢥⢨  ஢ﬨ ࠪ樨).
    ⮬ 㦭  ⮣, ⮡ 㭪樨  ஢ ᥫ
    ࠢ饩 㭪樨, 뢠  㣮 ஢.  ᮧ
    ணࠬ ⥬ 뢠,   ६ 㤠
   ⥬ ࠧ   ⮬ ࠢ.

   9.4.4 ᮡ 樨  

   ᮡ 樨  ।⢮ ᨣ஢  ந室 
    訡. ᪮   頥 ⠪
   祭, ஥   ஢ 뢠 㭪, 
   ᫥騥  (..  ᯮ騥 ᮡ 樨) ᯮᮡ
   ᨣ樨:
       [1]  ꥪ  ଠ쭮 ﭨ  ,
            짮⥫ ஢  ﭨ.
       [2] ⠭ 祭 쭮 ६, ஥
           ᨣ,  ᮧ ꥪ  㤠.
   ᮡ 樨   䠪,  ᮧ ꥪ  㤠,
   ।   :

           Vector::Vector(int size)
           {
              if (sz<0 || max<sz) throw Size();
              // ...
           }

    㭪樨, ᮧ饩 ,  墠 訡, 맢
   ⨬ ࠧ஬ (Size())     ॠ஢:

           Vector* f(int i)
           {
             Vector* p;
             try {
               p = new Vector v(i);
             }
             catch (Vector::Size) {
               // ॠ  ⨬ ࠧ 
             }
             // ...
             return p;
           }

      ࠢ ᮧ  㭪 ᯮᮡ ࠢ쭮
   ॠ஢  訡.  ᠬ ࠡ稪 ᮡ 樨 
   ਬ -  ⠭ ᯮᮡ ⨪ 
   ⠭ ᫥ 訡.   墠 ᮡ 樨
    ࠢ饩 㭪樨   ᢮   稭 訡. ᫨
     ᮡ 樥 । 뢠騥  ,  ꥬ
   ,  㦭 ஢   訡, . ᭮
    ࠡ⪨ 訡  ⮬, ⮡ ᯥ   㤮
   ᯮᮡ ।   室 窨 㦥 訡  ⮣
   ,  ᫥   ᫥ ⠭.
       ᮡ " ᮢ ⥬ 樠樨" - ᠬ 
    ᨢ 襭  ⮬ 砥,   , ॡ騥
     .     ᢥ  뤥
   ᪮쪨 ᮢ  ୮ ਬ塞,  ⮬, ᯮᮡ,
   ⠭   .

   9.5 ᮡ 樨    訡

   ᫨ ᮡ  , 뫠 墠祭   
   宣 ⢨  室 ணࠬ,  ⮨   뢠
   訡?   ⮫쪮 ⮬,  ணࠬ 㬠  
     訡,  堭 ᮡ 権  ।⢮
   ࠡ⪨ 訡.  㣮 ஭, ᮡ 樨 
   ᬠਢ      ࠢ. ⢥न
    ਬ஬:

           class message { /* ... */ };   // ᮮ饭

           class queue {        // ।
              // ...
              message* get();   //  0, ᫨ । 
              // ...
           };

           void f1(queue& q)
           {
             message* m = q.get();
             if (m == 0) {  // । 
                // ...
             }
             // ᯮ㥬 m
           }

    ਬ   ⠪:

           class Empty { }  // ⨯ ᮡ 樨 "_।"

           class queue {
               // ...
               message* get();  //  Empty, ᫨ । 
               // ...
           };

           void f2(queue& q)
           {
             try {
                message* m = q.get();
                // ᯮ㥬 m
             }
             catch (Empty) {  // । 
                // ...
             }
           }

    ਠ  ᮡ 樥   - ५. 
   訩 ਬ ⮣,  㤭 ᪠,   
   ⠪  訡. ᫨ ।    ⮩
   (..  뢠 ⮩ 祭 ।, ᪠  ࠧ  ),
    ⢨  砥 ⮩ ।  ᬠਢ 
   ⠭,   㭪樨 f2()   ᮡ  㤥
   ⠪, ண      ਤন (.. ࠡ⪠ ᮡ
   権  ࠡ⪠ 訡). ᫨ ।  뢠 ⮩,
    ਭ  ⮬ 砥 ⢨ ࠧ   ⢥
   ଠ쭮 室 ணࠬ,  ਤ ⪠  ⠪ 鸞
    ᮡ ,  㭪 f2()  ९:

             class queue {
               // ...
               message* get();  //  Empty, ᫨ । 
               int empty();
               // ...
             };

             void f3(queue& q)
             {
               if (q.empty()) { // । 
                  // ...
               }
               else {
                  message* m = q.get();
                  // ᯮ㥬 m
               }
             }

   ⬥⨬,  뭥  㭪樨 get() ஢ ।  
    ⮫쪮  ᫮,   ।  ࠫ 饭.
        ⠪   ⪠  鸞,  ࠡ⪠ ᮡ
   樨  ࠡ⪠ 訡.   ਤন ⠪ 窨
   ७, ணࠬ ⪮ ࠧ   : 筠 
     ࠡ⪨ 訡.  ணࠬ  ⭠.  ᮦ,
    ॠ  ஢ ⪮ ࠧ , ⮬
    ணࠬ  ( 㤥) ࠦ  䠪. ⨬,
   । 뢠 ⮩ ⮫쪮  ࠧ (⠪  , ᫨ 㭪
   get() ᯮ  横,   ।    横).
     ।   祬- ࠭  訡.
   ⮬, ᯮ  祭  । ᮡ ,
    塞 ।⠢  ᮡ   訡.  㣮
   ஭, ⢨, ਭ  砥 ⮩ ।,  ⫨
    ⢨, ਭ  室 横 (..  筮 砥).
        堭 ᮡ 権   ஢,
   祬 ⠪   ࠢ   if  for.
   筮   ⮬    ⮫ 䥪⨢, ᫨ ᮡ
    ⢨⥫쭮 . ⮬ ᮡ 樨 ᫥
   ᯮ짮 ⮫쪮  ⮬ 砥,   襣 襭  
   ࠤ樮묨 ࠢ騬 ࠬ,  , , .
   ਬ,  砥 ⮩ ।  ४᭮ ᯮ짮 
   ᨣ樨  ⮬ 祭,   㫥 祭 㪠⥫ 
   ப message,  ᮡ    㦭. , ᫨ 
     queue  砫  㪠⥫ 祭 ⨯ int, 
       ⠪ 祭, 饣  ।.
    ⠪ 砥 㭪 get() ⠭ ⭮ 樨
   樨  $$9.1,   ਢ⥫쭮 ।⠢  ।
     ᮡ 樨. ᫥ ᮮࠦ ᪠뢠, 
    ᠬ 饬 蠡 ⨯  । ਤ  祭 ⮩
   । ᯮ짮 ᮡ ,  ࠡ  । 㭪
   㤥 ⠪:

            void f(Queue<X>& q)
            {
              try {
                 for (;;) {  // ``᪮ 横''
                             // 뢠 ᮡ 樥
                     X m = q.get();
                     // ...
                 }
              }
              catch (Queue<X>::Empty) {
                   return;
              }
            }

   ᫨ ਢ 横 믮  ࠧ,  ,  ᥩ
   , 㤥  䥪⨢, 祬  横  ஢મ
   ᫮  ।. ᫨   믮 ⮫쪮 ᪮쪮
   ࠧ,   横  猪 䥪⨢.
        । 饣  ᮡ  ᯮ  ᯮᮡ
     㭪樨 get(). ᯮ짮 ᮡ 権  ᯮᮡ
       ᯮᮡ 襭 㭪権 ᪠.
   ᮡ  室  ४ᨢ 㭪権 ᪠  ॢ. ,
   ਬ ᮡ 樨  ⠪ 楫,  ३ ࠭ ࠧ㬭
     ࠧ㬨⥫ ணࠬ. -⠪ ,  
   ⢨⥫쭮 ࠢ,  ਤন ⮩ 窨 ७, 
   ࠡ⪠ ᮡ 樨  ࠡ⪠ 訡. ࠡ⪠ 訡 
   ᠬ ᢮ த ⨥ ᫮, ⮬ 業  
   ⮤,   ᭮ ।⠢ 訡  몥  ᯮᮡ
    ࠡ⪨.

   9.6  䥩

     墠 ᮡ 樨 ࠦ  ⭮襭
   㭪権. ⮬     ᠭ 㭪樨 ⢮
   ᮡ 権,    :

             void f(int a) throw (x2, x3, x4);

    ⮬ ᠭ 㪠,  f()   ᮡ 樨
   x2, x3  x4,  ⠪ 樨  ந   ⨯, 
     樨   ᪠. ᫨ 㭪  ᢮
   ᮡ 樨,    । ࠭ 类 뢠饩 
   㭪樨,  , ᫨ ⠥   ᮡ , 
    ਢ  맮 㭪樨 unexpected().
   ⠭⭮ ।祭 unexpected() ⮨  맮 㭪樨
   terminate(), ,  ᢮ ।, 筮 뢠 abort().
   ஡   $$9.7.
          ।

            void f() throw (x2, x3, x4)
            {
              // - 
            }

   ⭮ ⠪ ।

            void f()
            {
              try {
                // - 
              }
              catch (x2) {  //  
               throw;
              }
              catch (x3) {  //  
               throw;
              }
              catch (x4) {  //  
               throw;
              }
              catch (...) {
               unexpected();
              }
            }

       २⢮   ᮡ 権 㭪樨   ᠭ
   ।  ᯮᮡ,  ந室 ஢ઠ 
   ᮡ 樨  ⥫ 㭪樨,  ⮫쪮   ⪮ .
      ⮬,  ᠭ 㭪樨 室   䥩,
       뢠 㭪権.  㣮 ஭,
   । 㭪樨     㭨ᠫ쭮 㯭.
    ᫨    室 ⥪   㭪権,
   筮      .
      ᫨  ᠭ 㭪樨  㪠  ᮡ 樨, ⠥,
        ᮡ .

            int f();  //    ᮡ 

   ᫨ 㭪  㤥 ᪠  ᮡ 権,  
   ,  㪠 ⮩ ᯨ᮪:

            int g() throw (); //  ᪠  ᮡ 権

    뫮  筮, ⮡  㬮砭 㭪  ᪠
    ᮡ 権.  ⮣ 諮  뢠 ᢮ ᮡ
   樨 ࠪ᪨   㭪樨 ,  ࠢ,
   ॡ   ࠭樨,  ஬ ⮣ ९⢮  饭
    㭪ﬨ, ᠭ묨  㣨 몠.  १ ணࠬ
   ⠫  ६ ⪫ 堭 ᮡ 権  ᠫ 
   譨 , ⮡  . 짮⥫ ⠫  ⠪
   ணࠬ 묨, ᪮    ,   뫮
    ᮢ襭 ࠢ.

   9.6.1  ᮡ 樨

   ᫨  ᠭ ᮡ 権 ⭮  筮 쥧, 
   १⮬   맮 unexpected(),  ⥫쭮  
   , ஬ ⫠.  맮 unexpected() , ᫨ 
   ࣠  ᮡ 樨  ᠭ 䥩. 
   㣮 ஭, 맮 unexpected()  墠  ᤥ 
   ।.
         ᫨  Y  ࠧࠡ⠭,   ᮡ 樨
     ⮫쪮 ந묨  , ᪠ Yerr. ⮬,
   ᫨  ᠭ

             class someYerr : public Yerr { /* ... */ };

    㭪, ᠭ 

             void f() throw (Xerr, Yerr, IOerr);

   㤥 ।  ᮡ  ⨯ Yerr 뢠饩 㭪樨.
    ⭮, ࠡ⪠ ᮡ 樨 ⨯ someYerr  f() ᢥ 
   ।  뢠饩 f() 㭪樨.
         뢠 砨,  砭 ணࠬ  
    ᮡ 樨  ᫨誮 ண 襭.
   ⨬ 㭪 g() ᠭ  ⥢ ०  ।
   ⥬. ⢥,  g() 祣 ⭮  ᮡ ,
   易  , ⮬      뢠
   unexpected().   ᯮ짮 g()  । ⥬
   㦭 ।⠢ ࠡ稪 ⥢ ᮡ 権  ९
   g(). ᫨ ,  ९ g()   ⥫쭮,
   ஡  , ८। ⢨ 㭪樨 unexpected().
    ⮣ 㦨 㭪 set_unexpected(). 砫  ।
   ,    ਬ  㭪権 unexpected()
   ⮤ " ᮢ ⥬ 樠樨" :

             typedef void(*PFV)();
             PFV set_unexpected(PFV);

             class STC {   //   ࠭  ⠭
               PFV old;    // 㭪権 unexpected()
             public:
               STC(PFV f) { old = set_unexpected(f); }
               ~STC() { set_unexpected(old); }
             };

     । 㭪,    襬 ਬ 
   unexpected():

             void rethrow() { throw; }  // १  ⥢
                                        // ᮡ 権

   ,   ਠ 㭪樨 g(), ।祭  ࠡ
    ⥢ ०:

             void networked_g()
             {
              STC xx(&rethrow); // ⥯ unexpected() 뢠 rethrow()
              g();
             }

    ।饬 ࠧ 뫮 ,  unexpected() ⥭樠쭮
   뢠  ࠡ稪 catch (...).   襬 砥
   易⥫쭮 ந   ᮡ 樨. 
   ,  ᮡ   ᪠, ਢ  맮
   terminate(). ᪮ ࠡ稪 catch (...) 室  ⮩
    ,  ன 뫠 饭 ⥢ ᮡ ,
   ᪮ 横   .
         , 쭮 ᭮, 襭,   
   ᮡ   "뢠 ":

            void muddle_on() { cerr << " 砥 ᮡ 樨\n"; }
            // ...
            STC xx(&muddle_on);  // ⥯ ⢨ unexpected() ᢮
                                 //    ᮮ饭

    ८। ⢨ unexpected()  ଠ쭮
     㭪樨, 㦨襩  ᮡ .
   ᬮ  ᢮ 祢 ᭮,  襭 ᯮ.
   ਬ,  " "  ᮡ 樨   
   ⥬  ⫠ 㣨  .  室  
      ⫠  ࠧ ⥬, ७ᥭ  몠
   ணࠬ஢  ᮡ 権. -⠪,  ࠢ ,
   ᫨ 訡    ࠭.
        㣮 襭,  맮 unexpected() ८ࠧ
     ᮡ 樨 Fail (㤠):

            void fail() { throw Fail; }
            // ...
            STC yy(&fail);

    ⠪ 襭 뢠 㭪   ஡ ࠧ 
    १ 뢠 㭪樨:  㭪樨 
    ᯥ譮 (..  ଠ쭮),  㤠筮 (..
    Fail). 祢 ⮪ ⮣ 襭  ⮬, 
    뢠 ⥫쭠 ଠ,   ᮯ஢
   ᮡ . 祬,  室   , ᫨
   । ଠ   Fail.

   9.7 墠祭 ᮡ 樨

   ᫨ ᮡ  饭   墠祭,  뢠 㭪
   terminate().   뢠,  ⥬ প ᮡ
   権 㦨,   ⥪ 襭,  
     ࠡ⪨ ᮡ 樨  稢 ⥪ 뢠
   ,   ⠥  ᢮ ࠡ, ⨢ ᮡ
   .
        ⢨ terminate() ᢮  믮 ᠬ ᫥
   㭪樨,   ࠬ  set_terminate():

              typedef void (*PFV)();
              PFV set_terminate(PFV);

   㭪 set_terminate() 頥 㪠⥫   㭪, 
   뫠   ࠬ  ।饬 饭  .
         室 ⠪ 㭪樨  terminate()  ⥬,
      堭 ᮡ 権 ॡ 
    ਥ. ਬ, terminate()  ᯮ짮 
   ४饭 , , ,   ୮ ᪠ ⥬.
    㭪 㦨 ७ ।⢮, ஥ ਬ, 
   ⪠ ⥣ ࠡ⪨ 訡, ⠭  ᮡ
   樨,  ᠬ ६ ਬ ⥣   ஢.
         㭪 unexpected() ᯮ  室,   ⮫
   쥧 ,  ,  㭪 ⨫ ᮡ ,
    㪠   ᠭ. ⢨ 㭪樨 unexpected() ᢮
    믮 ᠬ ᫥ 㭪樨,   ࠬ 
   㭪樨 set_unexpected().
          㬮砭 unexpected() 뢠 terminate(),  ,  ᢮
   ।, 뢠 㭪 abort(). ।,  ⠪ ᮣ襭
   ந 設⢮ 짮⥫.
         ।,  㭪 terminate()  頥 
   ⨢   㭪.
         ,  맮 abort() ᢨ⥫  ଠ쭮
   襭 ணࠬ.  ଠ쭮 室  ணࠬ
   ᯮ 㭪 exit().  頥 祭, ஥
   뢠 㦠饩 ⥬ ᪮쪮 ४⭮ 稫 ணࠬ.

   9.8 㣨 ᯮᮡ ࠡ⪨ 訡

   堭 ᮡ 権 㦥  ⮣, ⮡   
   ணࠬ  뫮 ᮮ      ࢮ
   "ᮡ 樨".  ⮬ ।,   ணࠬ
   ᠭ ᨬ   㣠,   ⮩ , 
   ࠡ뢠 ᮡ ,  ᫥ ॠ 
   訡.
            ஥ ࠡ稪 ᮡ 樨? ਢ
   ᪮쪮 ਠ⮢:

             int f(int arg)
             {
                try {
                   g(arg);
                }
                catch (x1) {
                   // ࠢ 訡  
                   g(arg);
                }
                catch (x2) {
                   // ந ᫥   १
                   return 2;
                }
                catch (x3) {
                   // । 訡
                   throw;
                }
                catch (x4) {
                   //  x4   ᮡ 
                   throw xxii;
                }
                catch (x5) {
                   // ࠢ 訡  த  ᫥饣 
                }
                catch (...) {
                   // ⪠  ࠡ⪨ 訡
                   terminate();
                }
                // ...
              }

   ,   ࠡ稪 㯭 ६   ,
   ᮤঠ饩 ஢塞  ⮣ ࠡ稪. ६,
   ᠭ  㣨 ࠡ稪  㣨 ஢塞 ,
   筮, 㯭:

               void f()
               {
                 int i1;
                 // ...
                 try {
                    int i2;
                    // ...
                 }
                 catch (x1) {
                    int i3;
                    // ...
                 }
                 catch (x4) {
                    i1 = 1;   // ଠ쭮
                    i2 = 2;   // 訡: i2  
                    i3 = 3;   // 訡: i3  
                 }
               }

   㦭  ⥣  䥪⨢ ᯮ짮 ࠡ稪 
   ணࠬ.   ணࠬ  ᮣᮢ ᯮ짮
   ᮡ 樨      ࠡ⪨ 訡. 堭
   ࠡ⪨ ᮡ 権    ᢮ ,
   ⮬ ⠪  ਤন 饩 ⥣.  ।,
    ⥣ ࠡ⪨ 訡  ࠧࠡ뢠  ᠬ
   ࠭ ⠤ ஥. ஬ ⮣,  ⥣ 
    ⮩ ( ࠢ  ᫮ ᥩ ணࠬ)  ᭮.
   ᫥⥫쭮 ஢ ᫮ ⥣  ⠪ ᫮
    ᢮ த  ணࠬ஢,  ⠭ ᫥
   訡, 㤥  .
        ० ᥣ ⮨ ࠧ ⪠  ⮣,   ।⢮
     ਥ  ਬ  ࠡ⪨  訡. 
   ⮫쪮 ᫮ ⥬. 筠 ⥬,  ⮩稢
    訡,  ந  ஢.   ஢
    ࠡ뢠 ⮫쪮  訡, ᪮쪮  
    襭  ⥬, ⠢ ࠡ 㣨 訡 
   ᮪ ஢. 祭 terminate() ঠ ⠪ 室,
   ।⠢  ७ 室  ⠪ ,
    襭 ᠬ 堭 ࠡ⪨ ᮡ 権,  
    ᯮ ,  ᮡ  
   墠祭. 㭪 unexpected() ।祭  室 
   ⠪ ,   ࠡ⠫ ᭮  ᠭ  ᮡ
   権 ।⢮ .  ।⢮  ।⠢  ࠭,
   .. ⥭, 㦠  㭪,  ९
   ࠭ 訡. ⪠ ஢   㭪樨 
   ஫, ⮡  ࠭,  㭪  ᯥ譮 ,
     㤠筮,    ।  ४
   ᯮᮡ,   ਭ ᯥ. 稭 ⮣   ࠧ묨
    ࠧ ணࠬ,    ணࠬ   ᫥騥:
     [1] ࠡ,  㦭 ஢, ⮡ ࠭஢ 
          㭪樨, ᫨誮 ,  ⮬   㤠
         ஢ 筮 ᫥⥫쭮;
     [2]  ᫨誮 訥 ⥫ 室   ६,
           ⨬  ଠ쭮 ࠡ ⥬
         (㤥 ⥭ ⭮ ஢      訡,
            ﭭ  ஢ ६  ࠢ묨
          祭ﬨ);
     [3] ⠪ ࠭祭   稭 㭪樨, ᠭ 
         㣨 몠;
     [4] ⠪ ⨥      
         ⮫쪮 ᫮ ⥬,  ⠭ ⥫쭮
         㧪   饩 .
      , ࠧ ணࠬ  ⤥ ⥬,  
   ᯥ譮 ,  稢 㤠筮,   
   ।  ४ ᯮᮡ,  ,   
   룮.  ᢮⢮   ᭮ ⥪,
   ⥬  祢 㭪樨. ᠭ ᮡ 権 
   室  䥩 ⠪ ⥪  ⥬.
       室   ⨫ ॠ樨  訡 室
    㣮. ਬ,  ᫥ 맮 ⠭⭮ 㭪樨 
   ஢ 祭 errno , , ᪠ ᮡ ,
    , , 墠뢠 ᮡ   ⠭
   祭 errno । 室  ⠭⭮ 㭪樨  -ணࠬ:

               void callC()
               {
                 errno = 0;
                 cfunction();
                 if (errno) throw some_exception(errno);
               }

               void fromC()
               {
                 try {
                    c_pl_pl_function();
                 }
                 catch (...) {
                    errno = E_CPLPLFCTBLEWIT;
                 }
               }

    ⠪ ᬥ ⨫   ᫥⥫, ⮡ 
   ॠ樨  訡 뫮 .
       ࠡ⪠ 訡  , ᪮쪮  , ண
   ᪮ ⥬. ᫨  㭪樨 㦥 ᪠
   訡,   㦭     ⠭ 
   뤥 ᮢ  뢠饩 㭪樨.  ⠪ 饭 
    ⥬  横᪨ ᨬ,  १
   祣  㤭 ,    ᪮
   横   ࠡ⪨  ⠭ ᫥ 訡.
      ⮡  ணࠬ, ।祭  ࠡ⪨ 訡
   뫠  㯮冷祭, ⮨ ਬ ⠪ 騥 
   ਥ,  " ᮢ ⥬ 樠樨",  室 
   ⠪   饭,  "ᮡ 樨 
   訡".

   9.9 ࠦ

   1. (*2)   STC  蠡 ⨯,  
      ࠭  ⠭ 㭪樨 ࠧ ⨯.
   2. (*3)   CheckedPtrToT  $$7.10  蠡 ⨯, 
      ஬ ᮡ 樨 ᨣ  ᪨ 訡.
   3. (*3)  㭪 find  ᪠  ୮ ॢ 㧫
       祭  ⨯ char*. ᫨  㧥  , 騬
      祭 "hello",    㪠⥫  . 
      祭 㤠筮 ᪠ ᯮ ᮡ .
   4. (*1) ।  Int, ᮢ騩  ᥬ  ஥
      ⨯ int  ᪫祭 ⮣,   ९ 
       稬  ⮬  ᪠ ᮡ 樨.
      ᪠: . $$9.3.2.
   5. (*2) ७  ⠭⭮ 䥩    樮
      ⥬ ᭮ 樨  䠩: ⨥, ⨥, ⥭ 
      .    㭪樨  ++  ⥬  祭,
        㭪権  ,   砥 訡 ᪠ ᮡ
      樨.
   6. (*1)   । 蠡 ⨯ Vector  ᮡ묨
      ﬨ Range  Size. ᪠: . $$9.3.
   7. (*1)  横  ᫥ 㬬 ⮢ ,
      ।  ࠦ 6, 祬  ஢ ࠧ .
      祬  宥 襭?
   8. (*2.5) ⨬  Exception ᯮ    
      ᮢ,  ᮡ 樨.     ?
           짠?  㤮⢠  맢
      ॡ 易⥫쭮 ᯮ짮 ⮣ ?
   9. (*2)    蠡 ⨯,   ॠ
       맮.
   10. (*2)   Lock ()  - ⥬,
      ᪠饩 ࠫ쭮 믮.
   11. (*1)  । 㭪
           int main() { /* ... */ }
        ⠪, ⮡   墠뢠  ᮡ 樨,
      ८ࠧ뢠  ᮮ饭  訡  맮 abort().
      ᪠:  㭪樨 fromC()  $$9.8 ⥭   砨.

