
                

                        ஥ ⥪ -  ஥ 몠,
                              (䮫쪫  Bell Laboratories)
                        ...  .
                             - . 

    ᮤন ᠭ ࠧ ਥ,  묨
   ᮧ ⥪  몠 ++.  ⭮,  
  ᬠਢ  ⨯, ࠪ ⨯, 㧫 ,
  ࠢ騥   䥩 .  ⮣ 㦤
   ୮ 䥩    ਫ,
  ᯮ짮 ᪮ ଠ樨  ⨯  ⮤ ࠢ
  .  業  ⮬,  ᢮⢠ 
    ,    ᯥ䨪 몮 ।,
   ᯮ  ॠ樨 ⠪ ᮢ,   
  ।  㭪,   ।⠢ ⥪.

  13.1 

  ࠡ⪠ ⥪ 饣 祭 -  ࠧ  㤭
  , 祬 ᮧ 筮 ணࠬ. ணࠬ -  襭
  ⭮   ⭮  ਫ, ⮣ 
  ⥪  ।⠢  襭  ⢠ ,
  易   ﬨ ਫ.  筮 ணࠬ
  ⥫ ᨫ 饭   㦥, ⮣  
  ⥪  ᯥ譮 ᯮ짮  ࠧࠧ 㦥,
  ᮧ ⢮ ࠧ ணࠬ.   饩  
   ⥪, ⥬  襬 ᫥ 㦥  㤥
  ஢,  ⥬   ॡ   ४⭮, ,
  䥪⨢, 塞, ७ᨬ, ⨢稢,
  , ,  ᯮ짮  ..   ⥪
      , ⮬ 㦥 । ஬.
  ⥪  ᬠਢ  ᯥ樠,  ਠ
  ⮣,   ।饩   뢠 ⮬. 
  ᮢ  ஥஢  ᮯ஢ ⮢ ⠭
  ।쭮   ⥪, , ,  ⮤
  ஥ ⥪ 室 ਬ  ஥஢ ࠧ
  ⮢.
      뫮  ᫨誮 ᠬﭭ 㪠뢠  ᫥
  ஢ ⥪.  諮  ᯥ묨 ᪮쪮
  ࠧ ⮤,  ᠬ । ⠥  ⨢ ᨩ
   ᯥਬ⮢.  ⮫쪮 㦤   ᯥ
  ⮩   ।  ਥ, 訥 묨
   ᮧ ⥪.  ᫥ 뢠,  ⥪ ।祭
   ᮢ襭 ࠧ ⥩ ணࠬ஢, ⮬  室
  뢠,  -  ⮤   ਥ 
   ⥪. ⢨⥫쭮,   稭 ,  ⮤,
  訥 묨  ॠ樨 । ࠫ쭮
  ணࠬ஢   ୮ 樮 ⥬,
    ਥ묨  ᮧ ⥪, ।祭
   襭  ,  ⥪, ।⠢饩 ᪨
  䥩.
     ⨥  ++  ᯮ짮 ᠬ묨 ࠧ묨
  ᯮᮡ, ⮬ ࠧࠧ ⨫ ணࠬ஢ 
  ਢ  ᯮ浪.  ⥪  ᢥ ⠪
  ᯮ浪   ᯥ稢 ᮣᮢ ⨫ ணࠬ஢,
  ,  ࠩ , ᪮쪮 ⠪ ⨫.  室 
  ⥪  "।᪠㥬",      ॥
     ࠢ쭮 ᯮ짮.  뢠 
  "⨯" ᮢ,  㦤 騥  ᨫ  ᫠
  ஭:  ⨯ ($$13.2), ࠪ ⨯ ($$13.3),
  㧫  ($$13.4), 䥩  ($$13.8), ࠢ騥
   ($$13.9).    ᮢ ⭮   ⨩,
     ﬨ 몠.  ⨥ 頥
    ᭮ 樨 - .    
      ⮣  ᮢ, 室 
  ண  ந    ࠧ㬭-। .
     ⨣ , , ⨦ .  ,
     ᫥  ᮢ ࠥ ᢮ ஫ 
  ஥஢ ⥪ , ᫨ 뢠  饥 ਬ,
        ᢮   㣨.
      ⮩   ⨥ ୮ 䥩 ($$13.6),
  ⮡ 뤥  騩 砩    ᮢ.
     । ⨥ ઠ  ਫ ($$13.7).
     ᬠਢ ० ᥣ , ⭮騥 ண 
    ᫥ , , 筮, ᯮ
    ਤ .  ᯮ짮  ਤ 
    १⮬ ᮧ 襭, 襣  業
  ᮢ  ᮢ ࠧ ,   १⮬ 㡭 ६
  㪫  롮   (᫨誮  "⫮  롮"
  砥   㬠). 襭 ࠧࠡ稪
  ⥪  ᥣ ঠ   ᮢ ਤ
  .   ᮢ⮢ ᫥ ⨫ ணࠬ஢ ⮩ 
   ⥪,   ﬨ, 室묨 
  ஥㥬 ⥪. ⢠  ᮧ ⥪ 饣
  祭  ⮫쪮 襭 ணࠬ,   ᮧ⥫
  ⥪ ᫥⢨ 㤥 "㦤"    ᯮ짮,
  㬥஢  ᮯ஢ ᢮ ᮡ⢥ ᮧ.
      몥 ++ ᯮ ᪨ ⨯. , 
   室    , ।⢥
  ।⠢塞 㠫묨 㭪ﬨ,   ଠ
   ⨯.   ᤥ, ᠭ  $$13.5. , । 类
  ਢ쭮 ⥪ ⠥  ࠢ . ਥ 
  襭 ᬠਢ  $$13.10. ⢥,  ⮩  
  ᬮ  ⮤, 訥 묨  ᮧ ⥪.
  ⮬  ᫠  㣨 ⠬ ,  ᬮ७
  ᫥騥 : ࠡ  訡  ⮩稢  訡 ($$9.8),
  ᯮ짮 㭪樮 ꥪ⮢    맮 ($$10.4.2
   $$9.4.3) , ᯮ짮 蠡 ⨯  ஥ ᮢ
  ($$8.4).
      ⥬ ⮩  易  ᠬ, 騬 ⥩ࠬ,
  (ਬ, ᨢ  ᯨ᪨). 筮, ⠪ ⥩ 
   蠡 ⨯ ( 뫮 ᪠  $$1. 4.3 $$8). 
    饭   ਬ ᯮ ,
  ᮤঠ騥 㪠⥫  ꥪ ⨯ . ⮡  
  ணࠬ,  ᯮ짮 蠡 ⨯,     8.

  13.2  ⨯

     vector ($$1.4), Slist ($$8.3), date ($$5.2.2) 
  complex ($$7.3)  묨  ⮬ ᫥,   
   ।⠢ 쭮 ⮥ ⨥   室
  ஬ 権.  筮 ᮮ⢥⢨ 
  䥩ᮬ    ॠ樥.      (砫쭮)
   ।砫  ⢥   祭 ந ᮢ.
  筮  娨 ᮢ  ⨯  ᮡ类. 
   ⨯   ஢,  裡  㣨 ᠬ.
  ᫨ ॠ ⭮ ⨯ 㤠筠,  ࠡ騥   ணࠬ
  ࠢ  ࠧ  ᪮  ᤥ묨  ணࠬ,
    ᯮ  ᯥ樠쭠  饣 .
  , ᫨ ந諮 ⥫쭮  ॠ樨, 筮
    䥩, ⮡ ࠧ  . 䥩,
   ᢮ , 易     ⢥묨
    ⥪. 䥩  ᮪ ஢ ⠢
   ᢮   ॠ樨,   
  ࠪ⨪ ணࠬ.  ⮣,  ॠ 
  ⮫쪮  쭮 ᫠ ⢨⥫쭮 ⢥ ᮢ.
     ᮢ  ᯮ짮   室,
    ⠯ ࠭樨  믮,  맢
  ᯮᮡ  㣨, "室" ᠬ ணࠬ.
      ⮣,  㪠 ⠪ ᫮,  
  㤮⢮  ⨯:
     [1]  ࠦ  ⨥  ⮤  ॠ樨;
     [2]   ⠭  権,  ᯮ
          ᢮⢠    ॠ樨, ᯥ稢
         䥪⨢  ᪮  , ࠢ
          "묨 ணࠬ";
     [3]   ᨬ  㣨 ᮢ;
     [4]      ஢.
     ਢ  ᭮ 裡  짮⥫ 
  ணࠬ, ॠ饩  ⨯. ᫨  ॠ樨 ந諨
  , ணࠬ 짮⥫ ਤ ࠭᫨஢,
  ᪮   猪 ᮤঠ 맮 㭪権, ॠ㥬
  ⠭,  ⠪  ६ ⭮ ⨯.
       ⥩ ਫ  ⨯ ᯥ稢
  ᭮ ⨯, אַ  ।⠢  ++, ਬ:
   ᫠, , ᯨ᪨, , , 樠⨢
  ᨢ, ப ᨬ  ᨬ,  㣮 ( ᪮)
  䠢.  , 饬   ⨩,  ᠬ 
   ⠪   ᯨ᮪.  ⮣  ⢮ ᯨ
  ᮢ,    ᯥ樠  ।⠢
  - ᨨ  ᯨ᮪.   ᯨ
  ᮢ,  ⮬ ᫥: ᯨ᮪  ஭ ; ᯨ᮪ 
  ஭ ; ᯨ᮪  ஭ ,  ஬
   裡  ਭ ꥪ; ᯨ᮪  ஭ ,
   ஬  裡  ਭ ꥪ; ᯨ᮪  ஭
  ,  ண    䥪⨢ । 室
      ꥪ; ᯨ᮪  ஭ , 
  ண    䥪⨢ । 室    
  ꥪ  ..
       " ⨯" (CDT - concrete data type, ..
   ⨯ ) , 뫮 ࠭    ନ
  "ࠪ ⨯" (ADT - abstract data type, .. ࠪ ⨯
  ). ⭮襭  CDT  ADT 㦤  $$13.3.
      ⢥,   ⨯  ।祭  
  ࠦ ன 魮. , ⨯ slist  vector 
  ᯮ짮  ⢥ ୠ⨢ ॠ樨 
  ⢠,   몥    ࠦ. ⮬, ᫨
  ணࠬ  ࠡ  ⢮, ᯮ 
  ⨯    ।  ⢮,    롨
   ⨯ slist  vector.  ணࠬ 뢠 
  ନ ࠭ , ᪠, slist,  ᫨ ⮬ ।
  ᯮ짮 㣮 , ணࠬ ਤ ९뢠.
       ⥭樠쭮 㤮⢮  稥 
  "⢥"    権, ਬ ⠪, 
    ᨢ  㤠   ᯨ᪠. 
  樨 ।⠢  ⨬쭮 ਠ,  "⢥"
  権 ⨯ 樨 ᯨ᪠  㤠 ᨢ,  
   맢 ⠭. ਢ ਬ:

           void my(slist& sl)
           {
             for (T* p = sl.first(); p; p = sl.next())
             {
                //  
             }
             // ...
           }

           void your(vector& v)
           {
             for (int i = 0; i<v.size(); i++)
             {
               //  
             }
             // ...
           }

  ⢮ ⠪ "⢥"  ࠭ ⮤ ॠ樨
  権 ᯥ稢 䥪⨢ ணࠬ  ⥫쭮 砥
   ᠭ.  ⮬ ,  ॠ 맮 ⠭ 筮
   ⮫쪮   権 ⨯ 樨 ᨢ 
  祭 ᫥饣  ᯨ᪠,  뢠 ⥫
  䥪  ᪮ 믮 ணࠬ.   ⮨  ⮬,
   ࠣ ணࠬ, ᯮ騥  ᢮   樨,
  , ਬ,  ਢ  横,  룫拉 宦
    㣠,  ࠣ ணࠬ,    
  権 ᯮ ࠧ  ⨯,    
  㣠. 筮, ,  ᢥ 室 ࠣ ணࠬ
   .
       짮⥫, 騩  ன 㭪樨,  筮
  㪠 ⨯ ꥪ,   ࠡ⠥ 㭪, ਬ:

          void user()
          {
            slist sl;
            vector v(100);

            my(sl);
            your(v);

            my(v);    // 訡: ᮮ⢥⢨ ⨯
            your(sl); // 訡: ᮮ⢥⢨ ⨯
          }

  ⮡ ஢ ⪮ ⮣ ॡ, ࠧࠡ稪 ன
   㭪樨  ।⠢ ᪮쪮  ᨩ, ⮡ 
  짮⥫  롮:

          void my(slist&);
          void my(vector&);

          void your(slist&);
          void your(vector&);

          void user()
          {
            slist sl;
            vector v(100);

            my(sl);
            your(v);

            my(v);     // ⥯ ଠ쭮: 맮 my(vector&)
            your(sl);  // ⥯ ଠ쭮: 맮 your(slist&)
          }

  ᪮ ⥫ 㭪樨 ⢥   ⨯  ࠬ,
      㭪権 my()  your() ᨬ 
   㣠,    嫮⭮.
      ⮬ ᥣ   ⨯,  ᪠, 室
   ஥ ⨯. ⥫쭮 ஭ ⮣  ᭠
    짮⥫ ⨯   ᮧ⥫,  ⠪ 
  짮⥫ﬨ,  ᮧ ꥪ  ⨯,  짮⥫ﬨ,
    㭪樨, ࠡ騥  ⨬ ꥪ⠬. ⮡
  ࠢ쭮 ᯮ짮  ⨯, 짮⥫ 
  ࠧ   ⠫쭮. 筮   -
  㭨ᠫ ᢮, 묨     ⨯
  ⥪,     짮⥫, 뢠  
  ᢮⢠,   ᨫ  祭 ⤥ ᮢ. 
    ⭮ ணࠬ  䥪⨢  믮.
     ࠧ㬭 ,  . ஬ ⮣, 
  ⠪ 砩,  ⤥     
  ᯮ짮, 祬  騩 (ࠪ) .  ⠪
  뢠  ᠬ, ।⠢騬   ⨯ ,
  ⠪  ᨢ  ᯨ᪨.
        , 㪠,     뢠, ᪮쪮
  , ⠫ ॠ樨,    蠥 ࠪ⨪
  ணࠬ.    뢠 㭪樨-⠭.
  ᫨ ᤥ 묨 ६, 騥 童,   ᠭ
  public,  ।⢥ ࠡ     㭪権, 
  ⠭   祭  ६,   ᥣ
   ਢ  宬 १.  ⨯   -⠪
  騬 ⨯,    ணࠬ 祩  ᪮쪨 㭪ﬨ,
  묨 ࠤ 㤮⢠.

  13.3 ࠪ ⨯

   ⮩ ᯮᮡ ᫠   짮⥫ 
    ᮧ⥫,  ⠪  ணࠬ,   ꥪ
  ᮧ,  ணࠬ,    ᯮ, ⮨  
   ࠪ  ᮢ.   ।⠢
  䥩  ⢮ ॠ権  . ᬮਬ
   set, ᮤঠ騩 ⢮ ꥪ⮢ ⨯ T:

            class set {
            public:
               virtual void insert(T*) = 0;
               virtual void remove(T*) = 0;

               virtual int is_member(T*) = 0;

               virtual T* first() = 0;
               virtual T* next() = 0;

               virtual ~set() { }
            };

    । 䥩  ந ⢮ (set),
    ஥ ⨥ 樨  ⠬ ⢠.
   ⨯筮 ⢨   稥 㠫쭮
  , . ⠪ $$6.7. ᬮਬ ਬ:

            class slist_set : public set, private slist {
                slink* current_elem;
            public:
                void insert(T*);
                void remove(T*);

                int is_member(T*);

                virtual T* first();
                virtual T* next();

                slist_set() : slist(), current_elem(0) { }
            };

            class vector_set : public set, private vector {
               int current_index;
            public:
               void insert(T*);
               void remove(T*);

               int is_member(T*);

               T* first() { current_index = 0; return next(); }
               T* next();

               vector_set(int initial_size)
                 : array(initial_size), current_index(0) { }
            };

   ⭮ ⨯ ᯮ   
  ,   童 .  ᤥ   㤮⢠ ,  ⮬,
     ⨯   饭 䥩
   楫 ।⠢  אַ   ᢮ 童  ந
  ᮢ. ஬ ⮣,  ࠧ  ॠ樨  ᯮ짮
   ,   㠫 㭪樨   
  묨 ⨯. 쪮   ࠧ ந ᮢ
      魮 ८। () 㠫
  㭪  ॠ樨. 䥩 । ࠪ ᮬ.
       짮⥫   ᢮ 㭪樨  $$13.2
  ⠪ ࠧ:

             void my(set& s)
             {
               for (T* p = s.first(); p; p = s.next())
               {
                  //  
               }
               // ...
             }

             void your(set& s)
             {
               for (T* p = s.first(); p; p = s.next())
               {
                 //  
               }
               // ...
             }

  ⠫ 祢 室⢮   㭪ﬨ,  ⥯ 筮
   ⮫쪮      㭪権 my()  your(),
  ᪮  饭  slist_set  vector_set  ᨨ  ᯮ
  䥩, ।塞 ᮬ set:

             void user()
             {
               slist_set sl;
               vector_set v(100);

               my(sl);
               your(v);

               my(v);
               your(sl);
             }

   ⮣, ᮧ⥫ 㭪権 my()  your()  易  ᠭ
  ᮢ slist_set  vector_set,  㭪樨 my()  your() 
  ࠧ     ᠭ.    ࠭᫨஢
   - ,  ᫨   slist_set 
  vector_set  , ᫨ ।  ॠ  ᮢ.
   ࠦ   㭪,  ।⢥
  ᯮ  , ⨬ vector_set.  ⭮, 
  ᯮ짮 ࠤ樮 ਬ  䠩 
    ணࠬ  㭪ﬨ my()  your() 䠩 ।
  set.h,   䠩 slist_set.h  vector_set.h.
       筮 樨 樨 ࠪ⭮   
   㠫 㭪樨,  ⠪    童,
  ।⠢  (  ⮣ 㪠⥫  ⠡
  㠫 㭪権).   ⥬,   㠫쭮
  㭪樨  童, ।⠢饣 , ॡ ।
  饭  ,   ࠭稢  ॠ樨.
    室  ࠪ ᠬ    ࠤ樮
  ⮤, ᭮  ண ࠧ 䥩   ॠ権.
  ࠪ ⨯ 㦨  ⢥ 䥩,   ⨯
  ।⠢  ॠ樨.
       ࠧ 䥩   ॠ権 ।
  㯭 権,  "⢥묨"  -
   ॠ樨,   筮 騬, ⮡  
  䥩. ਬ, ᪮  ந쭮 ⢥ 
  㯮冷祭,  䥩 set   
  ஢,  ᫨  ॠ樨 ⭮ ⢠
  ᯮ ᨢ.  ਢ  襭 ࠪ⨪ ணࠬ
  - ⢨ 筮 ⨬樨. , ⠭  ࠢ
   ॠ 㭪権 ⠭ (᫨   -
   権,  騩 ⨯ ⥭ ࠭), ⮬
    樨 䥩,   맮
  㠫 㭪権.     ⨯   
  ࠪ ⨯  ਥ,  ᫨誮 ᮪.
       ⮣, ᫨  楫  㦨 ࠪ ⨯:
    [1] । ஥ ⨥ ⠪ ࠧ,   ணࠬ
         ⢮   ᪮쪮 ॠ権;
    [2] ਬ 㠫 㭪樨, ᯥ稢 筮 ᮪
        ⥯ ⭮  䥪⨢ 믮 ணࠬ;
    [3] ᢮   ᨬ  ॠ樨  㣨
        ᮢ;
    [4] ।⠢ ᠬ  ᥡ ᫥ ⨥.
   ᪠,  ࠪ ⨯   ⨯, 
   㣨 ⨯.    । - ,  ࠢ,
  㤭     짮⥫. ⥫ ⥪ 
  㪫  ⢥    ।⠢ ਠ   ⨯,
  ⥬ ᠬ 롮 ४뢠  짮⥫.    ᭮
  ,  ᮬ    . 筮 㤠祩
  稢 ⪠ ࠭ 魮 ࠪ⭮ ⨯, ⮡
  ᪮ ணࠬ, ࠡ  , ਡ  ᪮ ணࠬ,
  ⠭   ⨯.  ⮬ 砥 
  ᯮ짮 塞 ॠ樨  让 ࠭樨
  ணࠬ ᫥ ᥭ . ⮫  㤠筠 뢠
  ⪠  "魮"   ⨯, ⮡   
  魮 ⨩ ਡ  ࠪ ⨯.  ᭨
  䥪⨢  ਬ  ᮢ.    
   ⢮,    ୮ ⢮  ணࠬ.
    頥 ॠ ࠪ⭮ ⨯,  ᬥ訢
    ࠪ ᮬ  ᫥.
      ⬥⨬,   ,  ࠪ ⨯  ᮧ
  砫쭮     ஥  쭥襬 ந
  ᮢ. ஥ ந  ࠪ ⨯ ᮢ
  ᪮॥ 㦭   ॠ権, 祬  ࠧ ᠬ 
  䥩. 直   ࠪ ⨯ ।祭  ⪮
   䥪⨢ ।⠢  ணࠬ ⤥쭮 . ,
    㤠, । 뢠 訬 ⠬  ᮧ
     ,  易  , ᮢ. ⢨⥫쭮, ⪨
  ந ந, " ࠧ"     
  ࠪ ⨯, ⠪ , ப,  ᫠, ᯨ᪨ 
  樠⨢ ᨢ ਢ 筮  ஬ .
   ࠢ   ᫥ ᯮ짮  童   
  , ⮣   䥪⨢ ਬ,  뢠 ⠭ 
  ⨢稩  䥩  ॠ    ᮢ.
      ᮧ   ࠪ ⨯, 業 ᫥
  ᤥ  ⮬, ⮡ । ⮩, ॠ騩 
  த㬠 ⨥, 䥩. ⪨   ਫ
  , 㦠  ᠭ ᥢ묨 "묨" ᢮⢠,
  ਢ ⮫쪮  ᯮ浪  䥪⨢. ⨬  
   ᨫ ࠭஢ ୮ ᯮ짮 , 
   㭪-童  㠫쭮,  㬠 祬  
   㭪樨  ८।.
    祬   ⠫ ।  slist  vector  
  ந   set,  ⥬ ᠬ  ᮢ slist_set
   vector_set? 㣨 ᫮ 祬 㦭  ⨯,  㦥
  । ࠪ ⨯?  ।  ⢥:
     [1] 䥪⨢: ⠪ ⨯,  vector  slist  ᮧ
           室, 맢 ⤠ ॠ権
          䥩ᮢ (ࠧ 䥩  ॠ樨 ॡ
         楯 ࠪ⭮ ⨯).
     [2] ⢥ 䥩:  ࠧ   ᥣ
         ॠ  ந   .
     [3] ୮ ᯮ짮: 㦥 堭,  
         ᯮᮡ  襩 ⥪ ⨯, ࠧࠡ⠭
         "-  㣮 ".
  筮,   ⢥ 易.  ⢥ ਬ [2] ᬮਬ
  ⨥  権. ॡ । 
  権 ( 쭥襬 )   ⨯ ⠪, ⮡  
    뫮 ஦ ᫥⥫쭮 ꥪ⮢ ⮣ ⨯.
  ⢥  ⮣ 㦭 ᯮ짮 㦥 㯮訩  slist.
  ,   । 騩   slist,  
   set, ᪮ 騩   ᪠ 樨  
  ᫮ ꥪ⮢,   ⢠, ਬ, 室 ⮪
   㭪樨,   । 맮  ᫥饥 祭 樨.
    㦭  ⢮  ,   ⮦ ६
  ⥫쭮 㡫஢  ⨯,   祢묨
  ॠﬨ ࠧ    ஢.  ᪨
  ।⠢ ⥫  ᮢ ⠪:

    set  iter ।⠢ 䥩,  slist  stream
   묨 ᠬ  ।⠢ ॠ樨. 祢,
   ॢ   ᮢ , ।⠢ 騥
  䥩, ந ந  ⨯  ࠪ ᮢ.
   ⠪ 娨       ࠪ
  ⨥  ।⠢  饬 ࠪ⭮  .
  쭥襥 㦤 ⮩ ⥬ ᮤন  $$13.6.
        ਢ ਬ ⮣ ࠪ⭮ ⨯, 饣
  ஬ ꥪ⮢ ⨯ T:

           class iter {
              virtual T* first() = 0;
              virtual T* next() = 0;
              virtual ~iter() { }
           };

           class slist_iter : public iter, private slist {
              slink* current_elem;
           public:
              T* first();
              T* next();

              slist_iter() : current_elem(0) { }
           };

           class input_iter : public iter {
              isstream& is;
           public:
              T* first();
              T* next();

              input_iter(istream& r) : is(r) { }
           };

    ⠪ ࠧ ᯮ짮 ।  ⨯:

           void user(const iter& it)
           {
             for (T* p = it.first(); p; p = it.next()) {
                 // ...
             }
           }

           void caller()
           {
             slist_iter sli;
             input_iter ii(cin);

             //  sli

             user(sli);
             user(ii);
           }

   ਬ  ⨯  ॠ樨 ࠪ⭮ ⨯, 
   ᯮ짮   ᨬ  ࠪ ⨯  
   ⠪ ⨯  襭 䥪⨢ ணࠬ,
  . ⠪ $$13.5. ஬ ⮣,  ᯮ짮   ⨯
   ॠ樨 ᪮쪨 ࠪ ⨯.
      ࠧ $$13.9 뢠   .  
  ᨬ  ॠ樨,  ⠢ 騥 樨
  ꥪ, ।   樠樨     室
  믮 ணࠬ.

  13.4  

   ⢨⥫쭮  ᮢ ந, 室  ᮢᥬ 㣮
  楯樨 ந ᮢ, 祬 楯 䥩-ॠ,
   ᯮ짮  ࠪ ⨯.  ᬠਢ
   㭤 ஥.  , ᫨  ᭮ 室 ࠪ
  ,  ᪠ ஥ ।⠢  ணࠬ  ᠬ ।⠢
   ந ᮢ -  㭪樨. ਬࠬ 㧫
  ᮢ  㦨  rectangle ($$6.4.2)  satellite ($$6.5.1).
  筮  娨  ।⠢ ஥ 饥 ⨥, 
  ந  ।⠢  ਠ ⮣ .
     ꥬ  娨 ᮢ.  
  ࢨᮬ, ।⠢塞 묨 ᠬ, ᠬ ᯥ稢 ।
  ࢨ  ।⠢ 㠫 㭪樨  () 饭
  䥩, ⮡  쭥 ⠫ ᢮ 権 
  ந .
      㧫   ⮫쪮 ।⠢ ॠ
  䥩,    ᮬ (   
  ॠ樨  ⭮襭  ࠪ⭮ ⨯),   ᠬ 
  䥩,   㭪樨. ᬮਬ  ⢥ ਬ
   dialog_box,  ।⠢  ண   ࠭.
   ⮬    짮⥫      ᢮
  ⢥      "":

          class dialog_box : public window {
             // ...
          public:
             dialog_box(const char* ...); // 稢騩 㫥 ᯨ᮪
                                          // 祭 
             // ...
          virtual int ask();
         };

    ஫ ࠥ 㭪 ask()  ,   ண
  ணࠬ 㪠뢠 ᯮ㥬     ᫮ 祭.
  㭪 ask() ࠦ  ࠭   頥  ⮩  ⢥
  .  ।⠢ ⠪ ਠ ᯮ짮:

          void user()
          {
            for (;;) {
                // - 

                dialog_box cont("continue",
                                "try again",
                                "abort",
                                (char*) 0);
                switch (cont.ask()) {
                case 0:  return;
                case 1:  break;
                case 2:  abort();
                }
              }
            }

  ⨬   ᯮ짮 . , 
  ࠢ, 㦥  㧫     ਢ
  . ⨬ 㧫  ⫨  ࠪ ᮢ,
    । 㦭 .
     짮⥫  dialog_box (   ⮫쪮 ᮧ⥫ ⮣
  ) 뢠  ࢨ, ।⠢塞  묨 ᠬ.
   ᬠਢ ਬ ।,  
  ஥ ⠭⭮ ࠧ饭    ࠭. ᫨
  짮⥫  ࠢ ࠧ饭 ,  
  dialog_box  window ()  ।⠢ ⠪ ,
  ਬ:

            dialog_box cont("continue","try again","abort",(char*)0);
            cont.move(some_point);

   㭪   move() 뢠  ।
  㭪樨  ᮢ.
        dialog_box  訬 ⮬  ஥
  ந ᮢ. ਬ,  ࠧ㬭  ⠪ ,
   ஬, ஬      ,  
  ப ᨬ (᪠,  䠩).   dbox_w_str ந
   ந   ⮣  dialog_box:

            class dbox_w_str : public dialog_box {
                // ...
            public:
               dbox_w_str (
                const char* sl,  // ப  짮⥫
                const char* ...  // ᯨ᮪ 祭 
               );
               int ask();
               virtual char* get_string();
               //...
            };

   㭪 get_string()  ⮩ 樥,  
  ன ணࠬ 砥  짮⥫ ப. 㭪
  ask()   dbox_w_str ࠭,  ப  ࠢ쭮,
   ᫨ 짮⥫  ⠫  ப,  ⮣  ணࠬ
  頥 ᮮ⢥饥 祭 (0).

            void user2()
            {
              // ...
              dbox_w_str file_name("please enter file name",
                                   "done",
                                   (char*)0);
              file_name.ask();
              char* p = file_name.get_string();
              if (p) {
                 // ᯮ㥬  䠩
              }
              else {
                //  䠩  
              }
              //
            }

   ⮣ - 㧫  :
     [1] 뢠  ᢮      ॠ樨,
         ⠪   ।⠢ ࢨ 짮⥫  ᮢ;
     [2] ।⠢   䥩 (.. 䥩  訬
         ᫮ 㭪権-童) 짮⥫, 祬  ;
     [3] ᭮뢠   । (  ᪫⥫쭮) ᢮
         騩 䥩  㠫 㭪;
     [4]    ᢮ (  ᢥ)  ᮢ;
     [5]   ⮫쪮  ⥪ ᢮  ᮢ;
     [6] 㦨  ᮬ  ஥ ந ᮢ;
     [7]   ꥪ.
   ,  , 㧫   㤮⢮ ᫮
  1, 2, 6  7. ,   㤮⢮ ᫮ 6, 室
    ⨯      㧫 ᮬ.
  ,   㤮⢮ ᫮ 7, 室  ࠪ
  ⨯     ࠪ 㧫 ᮬ.  
  㧫 ᮢ  饭 童, ⮡ ।⠢ 
  ந ᮢ  ࠭祭 䥩.
       ᫥⢨ ᫮ 4:  ࠭樨 ᢮ ணࠬ
  짮⥫ 㧫    ᠭ  
    ᢥ  ᮢ,  ⠪ ᠭ
    ᮢ,  ,  ᢮ ।,   .
   ⮬ 㧫   ।⠢   ࠪ ⨯.
  짮⥫ ࠪ⭮ ⨯     ᮢ,
  ᯮ  ॠ樨 ⨯   ࠭樨 ᢮ ணࠬ
      ᠭ.


   13.5 ᪠ ଠ  ⨯

   뢠   ⨭ ⨯ ꥪ   ᯮ짮
   - . ᬮਬ 㭪 my(set&)  $$13.3.

             void my_set(set& s)
             {
                for ( T* p = s.first(); p; p = s.next()) {
                    //  
                }
                // ...
             }

     饬 砥,  ।⠢,- ⠫ ⭮,
    ࠬ ⢠ ।⠢ ᮡ ꥪ ⨯
  slist.  ⠪ ⠫ ⥭  ॡ ⮢, 
  ⥫쭮 䥪⨢  ᯨ᪮, 祬  ந
  .  १ ᯥਬ 㤠 ᭨,  
   ॡ  㧪 ⮬  ⥬. , 筮, 
     ணࠬ ⤥쭮 ਠ  slist. ⨢ 
  । ⨭ ⨯ ࠬ, 饣 ⢮, 㭪
  my(set&)   ⠪:

           void my(set& s)
           {
              if (ref_type_info(s) == static_type_info(slist_set)) {
                 // ࠢ  ।⠢ ⨯

                 // s ⨯ slist

                 slist& sl = (slist&)s;
                 for (T* p = sl.first(); p; p = sl.next()) {

                    // 䥪⨢ ਠ    list

                 }
            }
            else {

               for ( T* p = s.first(); p; p = s.next()) {

                    //  ਠ  ந쭮 ⢠

                }
            }
            // ...
         }

   ⮫쪮 ⠫ ⥭  ⨯ slist, ⠫
  㯭 । 樨  ᯨ᪠,   ⠫ 
  ॠ ᭮ 権 ⠭.
     ਢ ਠ 㭪樨  ⫨筮, ᪮
  slist -   ,  ⢨⥫쭮   ⤥쭮
  ࠧ ਠ,  ࠬ  slist_set. ᬮਬ
  ⥯ ⠪ ,  ⥫쭮 ⤥쭮 ࠧ ਠ 
   , ⠪     ந ᮢ. ⨬, 
    dialog_box  $$13.4  ⨬ 㧭,   
  ᮬ dbox_w_str. ᪮  ⢮  ந
  ᮢ  dbox_w_str,  ஢  ᮢ  
    訬 襭. ⢨⥫쭮, ந 
   ।⠢ ᠬ ࠧ ਠ  ப. ਬ,
   ந  dbox_w_str   । 짮⥫
  ਠ ப  롮, 㣮  ᯥ   ⠫
   .. , 㦭 ஢   ᮢ  ᥬ ந묨
   dbox_w_str ᠬ.  ⠪  ⨯筮  㧫 ᮢ, 
  ஢ઠ   । ⨯ ⨯筠  ࠪ ᮢ,
  ॠ㥬 묨 ⨯.

           void f(dialog_box& db)
           {
              dbox_w_str* dbws = ptr_cast(dbox_w_str, &db);
              if (dbws) {  // dbox_w_str
                 //   ᯮ짮 dbox_w_str::get_string()
              }
              else {

                // ``'' dialog_box
              }

              // ...
            }

     "" ਢ ptr_cast() ᢮ ன ࠬ
  (㪠⥫) ਢ  ᢮ ࢮ ࠬ (⨯)  ᫮, 
  㪠⥫ ஥  ꥪ ⨯, ண ᮢ  
  (  ந ᮬ   ⨯).  ஢ન
  ⨯ dialog_box ᯮ 㪠⥫, ⮡ ᫥ ਢ 
   뫮 ࠢ  㫥.
      ୠ⨢ 襭   뫪  dialog_box:

            void g(dialog_box& db)
            {
              try {
                  dbox_w_str& dbws = ref_cast(dialog_box,db);

                  //   ᯮ짮 dbox_w_str::get_string()

               }
               catch (Bad_cast) {

                  // ``'' dialog_box

               }

               // ...
            }

  ᪮  ਥ ।⠢ 㫥 뫪,  ன
   ࠢ, ᯮ ᮡ ,  訡
  ਢ (.. 砩,  ⨯   dbox_w_str). 
    ࠢ  १⮬ ਢ.
     稥 㭪権 ref_cast()  ptr_cast() 㦨 襩
  樥 ࠧ稩  뫪  㪠⥫ﬨ: 뫪 易⥫쭮
  뫠  ꥪ, ⮣  㪠⥫    뫠,
  ⮬  㪠⥫  㦭 ஢ઠ.

  13.5.1 ଠ  ⨯

   ++   ⠭⭮ ।⢠ 祭 ᪮ ଠ樨
   ⨯, ஬ 맮 㠫 㭪権.

    뫮 ᤥ ᪮쪮 ।  ७ ++  ⮬
  ࠢ.

  ஢ ⠪ ।⢮ 쭮    設⢥
   ⥪   ᪨ ᮢ  ⨯.
   । 襭, 饥 ⥬  ᢮⢮,
   ꥬ ଠ樨  ⨯  ந쭮 .  
  ॠ   맮 㠫 㭪権,   
  室  ७ ॠ樨 ++.
        筮 㤮 䥩   ।⢮, ⠢騬
  ଠ  ⨯,     ᫥ 権:

          typeid static_type_info(type) //  typeid   ⨯
          typeid ptr_type_info(pointer) //  typeid  㪠⥫
          typeid ref_type_info(reference) //  typeid  뫪
          pointer ptr_cast(type,pointer)  // ८ࠧ 㪠⥫
          reference ref_cast(type,reference)  // ८ࠧ 뫪

  짮⥫    ⨬ ﬨ,  ᮧ⥫
    ।ᬮ  ᠭ ᮢ ।
  "ᯮᮡ", ⮡ ᮣᮢ 樨  ॠ樥
  ⥪.
     設⢮ 짮⥫,   㦭 ᪠
  䨪 ⨯,  ࠭ ﬨ ਢ
  ptr_cast()  ref_cast().  ࠧ 짮⥫ ࠭ 
  쭥 ᫮⥩, 易  ᪮ 䨪樥
  ⨯. ஬ ⮣, ࠭祭 ᯮ짮 ᪮ ଠ樨
   ⨯  ᥣ ॢ 訡.
     ᫨ 筮 ,   ਢ 諠 ᯥ譮,
   㦥 ⨭ ⨯ (ਬ, ꥪ⭮-ਥ஢
  -뢮),   ᯮ짮 樨 ᪨ ᮢ  ⨯:
  static_type_info(), ptr_type_info()  ref_type_info().  樨
   ꥪ  typeid.  뫮   ਬ 
  set  slist_set, ꥪ  typeid  ࠢ. 
  設⢠   ᢥ   typeid 筮.  
  ,  㦭   ଠ  ⨯,  
  typeid  㭪 get_type_info():

            class typeid {
                friend class Type_info;
            private:
                const Type_info* id;
            public:
                typeid(const Type_info* p) : id(p) { }
                const Type_info* get_type_info() const { return id; }
                int operator==(typeid i) const ;
            };

  㭪 get_type_info() 頥 㪠⥫  騩 (const)
  ꥪ  Type_info  typeid. ⢥,  ꥪ
   :   ࠭஢,  ᪠ ଠ
   ⨯ ࠦ ᪨ ⨯ 室 ணࠬ. , ᫨
   믮 ணࠬ  ⨯  .
       㪠⥫  ꥪ  Type_info 짮⥫
  砥   ଠ樨  ⨯  typeid , ⥯ 
  ணࠬ 稭   ⭮ ⥬ ᪨
  ᮢ  ⨯    ᪮ ଠ樨  .
    ।⢠  室  ⠭ 몠,     
   த㬠 ம। .

  13.5.2  Type_info

    Type_info   ꥬ ଠ樨  ॠ樨
  樨 ptr_cast();   । ᫥騬 ࠧ:

            class Type_info {
                const char* n;       // 
                const Type_info** b; // ᯨ᮪  ᮢ
            public:
                Type_info(const char* name, const Type_info* base[]);

                const char* name() const;
                Base_iterator bases(int direct=0) const;
                int same(const Type_info* p) const;
                int has_base(const Type_info*, int direct=0) const;
                int can_cast(const Type_info* p) const;

                static const Type_info info_obj;
                virtual typeid get_info() const;
                static typeid info();
            };

   ᫥ 㭪樨   ।   ந
   Type_info .
      짮⥫      ꥪ Type_info, 
   ਢ  ⮫쪮   . ப, ᮤঠ
   ⨯,   ⮣, ⮡   ᪠ ଠ樨
   ⠡ , ਬ,  ⠡ ⫠稪.     ⠪
  ଠ樨  ꥪ Type_info  뤠  ᫥
  ᪨ ᮮ饭. ஬ ⮣, ᫨  ॡ
   ᪮쪮 ꥪ⮢ ⨯ Type_info,    㦨 㭨
  箬  ꥪ⮢.

            const char* Type_info::name() const
            {
              return n;
            }

            int Type_info::same(const Type_info* p) const
            {
              return this==p || strcmp(n,p->n)==0;
            }

            int Type_info::can_cast(const Type_info* p) const
            {
              return same(p) || p->has_base(this);
            }

    ଠ樨    ᯥ稢 㭪ﬨ
  bases()  has_base(). 㭪 bases() 頥 , 
  ஦ 㪠⥫    ꥪ⮢ Type_info,  
   㭪樨 has_base()  ।    
    㣮 .  㭪樨  易⥫ ࠬ
  direct,  뢠, ᫥  ᬠਢ   
  (direct=0),  ⮫쪮    (direct=1). ,
   ᠭ ,   㭪権 get_info()  info() 
    ଠ  ⨯  ᠬ  Type_info.
        ।⢮ ᪨ ᮢ  ⨯ ᮧ⥫쭮
  ॠ   ᮢᥬ  ᮢ.   
  ਢ離  । ⥪.    
   ⥪   . ,  ᥣ, ᮢ⮢
  짮⥫  譥 ᨬ  ⠫ ॠ樨.
      㭪 has_base()      饣 
  Type_info ᯨ᪠  ᮢ. ࠭ ଠ  ⮬, 
       㠫,  㦭, ᪮
   訡, 易  ࠭祭ﬨ 㯠  筮,
     ࠭樨.

          class base_iterator {
            short i;
            short alloc;
            const Type_info* b;
          public:
            const Type_info* operator() ();
            void reset() { i = 0; }

            base_iterator(const Type_info* bb, int direct=0);
            ~base_iterator() { if (alloc) delete[] (Type_info*)b; }
         };

   ᫥饬 ਬ ᯮ 易⥫ ࠬ  㪠,
  ᫥  ᬠਢ    (direct==0)  ⮫쪮 
    (direct==1).

        base_iterator::base_iterator(const Type_info* bb, int direct)
        {
          i = 0;

          if (direct) { // ᯮ짮 ᯨ᪠   ᮢ
             b = bb;
             alloc = 0;
             return;
          }

          // ᮧ ᯨ᪠   ᮢ:

          // int n = ᫮ 
          b = new const Type_info*[n+1];
          //     b

          alloc = 1;
          return;
        }

        const Type_info* base_iterator::operator() ()
        {
          const Type_info* p = &b[i];
          if (p) i++;
          return p;
        }

      樨 ᮢ  ⨯   ம।:

        #define static_type_info(T)  T::info()

        #define ptr_type_info(p)   ((p)->get_info())
        #define ref_type_info(r)   ((r).get_info())

        #define ptr_cast(T,p) \
           (T::info()->can_cast((p)->get_info()) ? (T*)(p) : 0)
        #define ref_cast(T,r) \
           (T::info()->can_cast((r).get_info()) \
               ? 0 : throw Bad_cast(T::info()->name()), (T&)(r))

  ।,  ⨯ ᮡ 樨 Bad_cast (訡_ਢ)
  ᠭ ⠪:

        class Bad_cast {
          const char* tn;
          // ...
        public:
          Bad_cast(const char* p) : tn(p) { }
          const char* cast_to() { return tn; }
          //  ...
        };

       ࠧ $$4.7 뫮 ᪠,   ம।
  㦨 ᨣ  ஡.  ஡  ⮬,  ⮫쪮
  ࠭  ।⢥   ࠫ ⨯,
   ம। 뢠 ᯥ䨪 ॠ樨.    ࠭
  ଠ樨  ᪨ ᮢ  ⨯ ।祭 ⠡
  㠫 㭪権. ᫨ ॠ ।⢥ ন
   䨪 ⨯,  ᬠਢ 樨 
  ॠ  ⢥, 䥪⨢  ⭮.  ⭮,
  祭  ॠ 㭪 ptr_cast(),  ८ࠧ
  㪠⥫  㠫    㪠⥫   ந
  .

  13.5.3  ᮧ ⥬ ᪨ ᮢ  ⨯

   ,   אַ ॠ ᪨ 
   ⨯,   ࠭ ⠪ ⥩ .  筮
  ⮬⥫쭠    ய  ࠧ, ⠪   
   ⮫쪮 ⠫ ⭮ 襭.
       set  slist_set  $$13.3 ᫥  ⠪, ⮡
     ࠡ 樨 ᮢ  ⨯. ० ᥣ, 
    set 㦭  㭪樨-童,  ᯮ
  樨 ᮢ  ⨯:

         class set {
           public:
             static const Type_info info_obj;
             virtual typeid get_info() const;
             static typeid info();

             // ...
        };

   믮 ணࠬ ⢥ ।⠢⥫ ꥪ ⨯
  set  set::info_obj,  । ⠪:

        const Type_info set::info_obj("set",0);

   ⮬ ⮣ । 㭪樨 ਢ:

       typeid set::get_info() const { return &info_obj; }
       typeid set::info() { return &info_obj; }
       typeid slist_set::get_info() const { return &info_obj; }
       typeid slist_set::info() { return &info_obj; }

  㠫쭠 㭪 get_info() 㤥 ।⠢ 樨
  ref_type_info()  ptr_type_info(),  ᪠ 㭪 info()
  -  static_type_info().
      ⠪ ஥ ⥬ ᮢ  ⨯ ᭮ 㤭
   ࠪ⨪ ⮨  ⮬, ⮡    ꥪ ⨯
  Type_info   㭪樨, 騥 㪠⥫   ꥪ,
  ।﫨 ⮫쪮  ࠧ.
      㦭 ᪮쪮   slist_set:

         class slist_set : public set, private slist {
            // ...
         public:
            static const Type_info info_obj;
            virtual typeid get_info() const;
            static typeid info();

            // ...
         };

         static const Type_info* slist_set_b[]
            = { &set::info_obj, &slist::info_obj, 0 };
         const Type_info slist_set::info_obj("slist_set",slist_set_b);

         typeid slist_set::get_info() const { return &info_obj; }
         typeid slist_set::info() { return &info_obj; }

  13.5.4 ७ ᪠ ଠ  ⨯

    Type_info ᮤন ⮫쪮  ଠ樨, 室
   䨪樨 ⨯   権 ਢ.  ᪮
   ᠬ  Type_info  㭪樨-童 info()  get_info(),
   ந ந   , ⮡  
  ।,  ꥪ Type_info   㭪樨. 
  ࠧ,    Type_info, 짮⥫  
   ଠ樨  ⨯   ꥪ⮢, 頥 㭪ﬨ
  dynamic_type()  static_type().    ⥫쭠
  ଠ  ᮤঠ ⠡ 童 ꥪ:

             struct Member_info {
               char* name;
               Type_info* tp;
               int offset;
             };

             class Map_info : public Type_info {
                Member_info** mi;
             public:
                static const Type_info info_obj;
                virtual typeid get_info() const;
                static typeid info();

                // 㭪樨 㯠
             };

   Type_info  室  ⠭⭮ ⥪. 
     㬮 室 ଠ樨,  ண
    ந , ।⠢騥  ଠ樨.
   ந   ।  ᠬ 짮⥫, 
  - 㦥 ணࠬ, ࠡ騥  ⥪⮬  ++,  ᠬ
  ࠭ 몠.


  13.5.5 ࠢ쭮  ࠢ쭮 ᯮ짮 ᪮
         ଠ樨  ⨯

  ᪠ ଠ  ⨯  ᯮ짮  
  ,  ⮬ ᫥ : ꥪ⭮ -뢮,
  ꥪ⭮-ਥ஢  ,  ⫠.  ⮦ ६
   ⭮ 訡筮 ᯮ짮 ⠪ ଠ樨.
  ⭮,  몥 㫠 ᯮ짮 ⠪ ।,
   ࠢ, ਢ  訡. ⮬  ।⢠  뫨
  祭  ++. 誮  ᮡ ᯮ짮 ᪮
  ଠ樥  ⨯, ⮣  ࠢ쭥 맢 㠫
  㭪. ᬮਬ  ⢥ ਬ  Shape  $$1.2.5.
  㭪 rotate  뫮  ⠪:

          void rotate(const Shape& s)
              // ࠢ쭮 ᯮ짮 ᪮
              // ଠ樨  ⨯

          {
            if (ref_type_info(s)==static_type_info(Circle)) {
               //  ⮩ 䨣 祣  
            }
            else if (ref_type_info(s)==static_type_info(Triangle)) {
               // 饭 㣮쭨
            }
            else if (ref_type_info(s)==static_type_info(Square)) {
               // 饭 
            }
            // ...
          }

  ᫨  ४⥫  ⨯   ᯮ㥬 
  ଠ  ⨯,  ⥬ ᠬ 蠥  ணࠬ ਭ樯
  쭮  栥 ᠬ 楫 ꥪ⭮-ਥ஢ ணࠬ஢.
   ⮬   襭 ॢ 訡: ᫨  ⢥
  ࠬ 㭪樨 㤥 । ꥪ ந  Circle ,
    ࠡ⠥ ୮ (⢨⥫쭮,   (Circle)
   ᫠,   ꥪ, ।⠢饣 ந , 
   ॡ).  뢠,  ணࠬ⠬, ᯨ⠭
   ⠪ 몠    ᪠, 㤭  ⮩ 誨.
  ⨫ ணࠬ஢  몮 ॡ  ।ᬮ⥫쭮,
    ᮧ ⥪ ⠪ ⨫   
  ०.
       , 祬  䥩  ⥬ ᪮
  ଠ樨  ⨯ 祭 ᫮  ਢ ptr_cast(),  
   is_base(),  ।⢥ ।  
  樨 has_base()   Type_info. ᬮਬ ⠪ ਬ:

              void f(dialog_box& db)
              {
                if (is_base(&db,dbox_w_str)) { //   db 
                                               //   dbox_w-str?
                   dbox_w_str* dbws = (dbox_w_str*) &db;
                   // ...
                }

                // ...
              }

  襭   ptr_cast ($$13.5)  ⪮,  ⮬  
    ᫮  ਢ ⤥  ஢ન  
  if,    訡, 䥪⨢  
  ୮ १.  १    
  । ,  ⥬ ᪮ 䨪樨 ⨯
  ᯮ,   ⨯  ந  㣮, 
  ࠭  䠪 ⥭, ਬ:

              class D;
              class B;

              void g(B* pb)
              {
                if (is_base(pb,D)) {
                   D* pb = (D*)pb;

                   // ...
                }

                // ...
              }

  ᫨ ࠭  ⭮ ᫥饥 ᠭ  D:

              class D : public A, public B {
                 // ...
              };

    訡, .. ࠢ쭮 ਢ 㪠⥫ pb  D*
  ॡ  祭 㪠⥫. 襭  樥 ptr_cast()
   ⠫  ⮩ 㤭, ᪮   ਬ
  ⮫쪮  ᫮,     室 ᠭ
    ࠬ஢. ਢ ਬ 뢠,  
  ਢ  ᠭ ᮢ   ᢮ , 
  饭  ⢥ 蠥 ᮢ⨬  몮 .

  13.6  䥩

   㦤 ࠪ ⨯ ($$13.3)  㧫  ($$13.4),
  뫮 ભ,   㭪樨   ॠ
   ᠬ    ந .    㣮
  ᯮᮡ ஥ ᮢ. ᬮਬ, ਬ, ᯨ᪨, ᨢ,
  樠⨢ ᨢ, ॢ  .. ⢥   
   ⨯,  뢠 ⥩ࠬ, ᮧ 騩 
  ,   ᯮ짮  ⢥ 䥩  
   ᫥ ⨯. 祢,  짮⥫  
   ⠫, 騥 ⭮ ⥩.  
  । 䥩  饭 ⥩ ਢ쭠.
  ।,  ⠪ ⥩ 㤥 ।  ࠪ
  ⨯, ⮣  樨   ।⠢?  ।⠢
  ⮫쪮  樨,     ⥩, ..
  祭  権,  ⠪ 䥩 㤥 ᫨誮
  㧪.  ᠬ ,  ,    ⠪
  祭 .  ⢥ ୠ⨢ 襭 
  ।⠢ ꥤ   権  ।ᬮ
   訡,   ⮬ 䥩  ꥪ
  ਬ "" . ꥤ 䥩ᮢ ᮢ,
  ।⠢  ⢮ ⨩, 뢠  䥩ᮬ.
  襬 "騩" ⥩ ꥪ⮢ ⨯ T:

            class container {
            public:
              struct Bad_operation { //  ᮡ 権
                  const char* p;
                  Bad_operation(const char* pp) : p(pp) { }
              };

              virtual void put(const T*)
                 { throw Bad_operation("container::put"); }
              virtual T* get()
                 { throw Bad_operation("container::get"); }

              virtual T*& operator[](int)
                 { throw Bad_operation("container::[](int)"); }
              virtual T*& operator[](const char*)
                 { throw Bad_operation("container::[](char*)"); }
              // ...
            };

  -⠪   ॠ権,  㤠筮 ।⠢ 
  ஢, ⠪  樨 ⨯ ᯨ, , ,  ⮨
  ᮢ    .
      ⬥⨬ ⠪ ࠧ稥:  ࠭⨨ ஢ન  ⠯
  ࠭樨  ࠪ⭮ ⨯ ᯮ  㠫
  㭪樨,   㦥 訡  ⠯ 믮 ᯮ
  㭪樨 ୮ 䥩, ᪠騥 ᮡ 樨.
       ᫥騬 ࠧ  ⥩, ॠ
   ⮩ ᯨ᮪  ஭ :

       class slist_container : public container, private slist {
       public:
         void put(const T*);
         T* get();

         T*& operator[](int)
             { throw Bad_operation("slist::[](int)"); }
         T*& operator[](const* char)
             { throw Bad_operation("slist::[](char*)"); }
         // ...
       };

  ⮡  ࠡ ᪨ 訡  ᯨ᪠
   樨 ஢.  뫮   
  ॠ  ᯨ᪠ 樨  ࠭  
  ଠ樥,  ।⠢ ᮡ 樨, 饭
    container:

        class vector_container : public container, private vector {
        public:
           T*& operator[](int);
           T*& operator[](const char*);
           // ...
        };

  ᫨  ஦,   ࠡ⠥ ଠ쭮:

        void f()
        {
          slist_container sc;
          vector_container vc;
          // ...
        }

        void user(container& c1, container& c2)
        {
          T* p1 = c1.get();
          T* p2 = c2[3];
          //  ᯮ짮 c2.get()  c1[3]
          // ...
        }

      訡  믮 ணࠬ  室
  ᯮ짮  ଠ  ⨯ ($$13.5)  ᮡ
  樨 ($$9). ਢ ਬ:

         void user2(container& c1, container& c2)
         /*
            㦥 訡 , ⠭ - 㤭 
         */
         {
           try {
               T* p1 = c1.get();
               T* p2 = c2[3];
               // ...
            }
            catch(container::Bad_operation& bad) {
              // ਥ堫!
              //   ⥯ ?
            }
          }

   㣮 ਬ:

          void user3(container& c1, container& c2)
          /*
            㦥 訡 ,
             ⠭  ० 㤭 
          */
          {
            slist* sl = ptr_cast(slist_container,&c1);
            vector* v = ptr_cast(vector_container, &c2);

            if (sl && v) {
               T* p1 = c1.get();
               T* p2 = c2[3];
               // ...
            }
            else {
               // ਥ堫!
               //   ⥯ ?
            }
          }

   ᯮᮡ 㦥 訡,    ਬ,
  ਢ  ணࠬ  "ࠧ"    ᪮
  믮. ⮬ 筮    訡
   ,  짮⥫    ⮫.    ⮣
   頥,   ஢ 㤭⥫쭮  ॡ
   ᨫ .
     ⮬, ᫨ 楫  ணࠬ  訬 ࠪ⨪,
   ॡ ᮪ ࠭⨨ ४⭮ ணࠬ, , ,
    ୠ⨢,   ᯮ짮  䥩.
  ஬ ⮣, ᯮ짮 ୮ 䥩 蠥
  筮 ᮮ⢥⢨  ᠬ  ﬨ,  ⮣
  稭   ந    㤮⢠
  ॠ樨.

  13.7 ઠ  ਫ

   ᫨  ᮢ,    ᮧ ⥪,
  楫  ஥஢  ୮ ᯮ짮 ਪ
  ணࠬ.  ।⠢ । "ந⥫ " 
      ந. ࠡ稪 ਪ ᯥ祭 ᮧ
  ઠ,     㭨ᠫ ந⥫ . 
  ஥஢ ਪ ணࠬ   ,  뢠饥
  襭:  ணࠬ,  ᠬ 㤥 ᮧ 騩 ઠ
   ਫ. ࠡ稪 ਪ ᯥ祭
   ⢥ ந⥫  㤥 ࠨ   ઠ
  ਪ ணࠬ. ,  ࠧ ઠ 
  ਫ,  ⮫쪮  䥩,   㤭
   ⨯  筮 ᫥ ᫮.  ਡ  ⮬
  ।,  ⠭  ਪ묨 ᠬ,   ⮬
    䠪᪨  ⮫쪮 ᠭ,   ⢨ 
  㭪ﬨ, ᠭ묨 ਪ묨 ணࠬ⠬.
        ਬ ᬮਬ 䨫, .. ணࠬ,  
  믮 ᫥騥 ⢨:  室 ⮪, ந
     樨, 뤠 室 ⮪  ।
   १. ਬ⨢ ઠ  䨫 㤥 
   । ⢠ 権,   ॠ
  ਪ ணࠬ:

           class filter {
           public:
             class Retry {
             public:
               virtual const char* message() { return 0; }
             };

           virtual void start() { }
           virtual int retry() { return 2; }
           virtual int read() = 0;
           virtual void write() { }
           virtual void compute() { }
           virtual int result() = 0;
         };

  㦭  ந ᮢ 㭪樨 ᠭ   㠫,
  ⠫ 㭪樨  . ઠ ᮤন ᭮ 横
  ࠡ⪨   ।⢠ ࠡ⪨ 訡:

         int main_loop(filter* p)
         {
           for (;;) {
               try {
                   p->start();
                   while (p->read()) {
                         p->compute();
                         p->write();
                   }
                   return p->result();
               }
               catch (filter::Retry& m) {
                 cout << m.message() << '\n';
                 int i = p->retry();
                 if (i) return i;
               }
               catch (...) {
                 cout << "Fatal filter error\n";
                 return 1;
               }
             }
           }

   ਪ ணࠬ   ⠪:

           class myfilter : public filter {
              istream& is;
              ostream& os;
              char c;
              int nchar;

           public:
              int read() { is.get(c); return is.good(); }
              void compute() { nchar++; };
              int result()
                  { os << nchar
                       << "characters read\n";
                       return 0;
                  }

              myfilter(istream& ii, ostream& oo)
                : is(ii), os(oo), nchar(0) { }
           };

   뢠  ᫥騬 ࠧ:

          int main()
          {
            myfilter f(cin,cout);
            return main_loop(&f);
          }

  騩 ઠ, ⮡ 뢠  ਬ  ॠ ,
   ᮧ  ࠧ   ।⠢ 
   㭪権, 祬  襬 ⮬ ਬ.  ࠢ, ઠ
  ࠧ ॢ 㧫 ᮢ. ਪ ணࠬ ⠢
  ⮫쪮 , 㦠騥 ﬨ  ⮬ ஢ ॢ,
   祬 ⨣ 魮  ࠧ묨 ਪ묨
  ணࠬ  頥 ୮ ᯮ짮  㭪権,
  ।⠢塞 ઠᮬ.  ઠ  ᯮᮡ⢮
  ⥪,   ।   , ਬ,
  ⠪  scrollbar ($$12.2.5)  dialog_box ($$13.4). ᫥ ।
  ᢮ ਪ ᮢ ணࠬ  ᯮ짮  .

  13.8 䥩 

     ᠬ   ᮢ 筮 뢠 -  "஬"
  䥩 .    믮 - 让
  ࠡ,  ,   뢠  䥩. 
  䥩᭮  ᯮᮡ   㭪 
  । ⥪. ⮨⢮ 䥩 ᮢ  ⮬,
     ᮢ⭮ ᯮ짮  㭪,  
    ⪨ ࠬ. ⢨⥫쭮,  뢠,  㭪
  ᬮ ᠬ  ᥡ   㤮⢮ ᠬ ࠧ .
     䥩   ⮬    ॡ 樨 .
  ᯮ ᠭ 蠡 ⨯ Splist  $$8.3.2:

            template<class T>
            class Splist : private Slist<void*> {
            public:
              void insert(T* p) { Slist<void*>::insert(p); }
              void append(T* p) { Slist<void*>::append(p); }
              T* get() { return (T*) Slist<void*>::get(); }
            };

   Splist ८ࠧ ᯨ᮪  饭 㪠⥫
  ⨯ void*   㤮 ᥬ⢮  ᮢ, ।⠢
  ᯨ᪨. ⮡ ਬ 䥩 ᮢ  뫮 ᫨誮 ,
  㦭 ᯮ짮 㭪樨-⠭.  ਬ, 
  ਢ,   㭪権-⠭ ⮫쪮 
  ⨯,  室    ᪮ 믮 ணࠬ
   .
     ⢥,   䥩 ࠪ
   ,  ।⠢ ࠪ ⨯, ॠ㥬
  묨 ⨯ ($$13.3), ⠪   ࠢ騥 
   ࠧ 13.9.    ᬠਢ ,   
   祭 - ⮫쪮  樨 䥩.
     ᬮਬ  ᫨ﭨ  娩 ᮢ  
  ⢥ ᫥.    砥 
  , .. 樨,     ᯮ 㠫
  㭪樨   , ந騥 ᮢ襭 ࠧ 樨?
       " ",  ன 
   짮⥫ ࣠    饣  (
  Window):

            class Window {
               // ...
               virtual void draw();
            };

            class Cowboy {
               // ...
               virtual void draw();
           };

           class CowboyWindow : public Cowboy, public Window {
              // ...
           };

   ⮩   CowboyWindow ।⠢    ࠭
   ࠢ ⢨ ப  . 祢, 
    㭪権, ।   Window 
  Cowboy, ⮬ ।⥫쭥 ᯮ짮 ⢥ ᫥,
  祬 뢠 Window  Cowboy  童. ⥫  ।
  ⨬ 㭪  ⢥ ࠬ ꥪ ⨯ CowboyWindow,  ॡ
   ணࠬ 㪠 - ᯥ䨪権 ꥪ. 
   ࠧ   ,  㭪樨   CowboyWindow:
  Cowboy::draw()  Window::draw().
        CowboyWindow   ⮫쪮  㭪  
  draw(),  ᪮  㭪 ࠡ⠥  ꥪ⠬ Cowboy
   Window  祣    CowboyWindow,   CowboyWindow
    (८।)  㭪 Cowboy::draw(), 
  㭪 Window_draw().   㭪樨    -
  draw() ࠢ쭮, ᪮,  ᯮ  ,  
   㭪樨 draw() ࠧ    ८। .
      , ⥫쭮, ⮡   CowboyWindow ᫥㥬
  㭪樨 Cowboy::draw()  Window::draw()  ࠧ 筮
   .
       襭 ⮩  㦭  ⥫  
  Cowboy  Window.    
   㭪権 draw()  ࠭,   맮
    Cowboy  Window ਢ  맮 㭪権  묨 :

           class CCowboy : public Cowboy {
              virtual int cow_draw(int) = 0;
              void draw() { cow_draw(i); } // ८। Cowboy::draw
           };

           class WWindow : public Window {
              virtual int win_draw() = 0;
              void draw() { win_draw(); } // ८। Window::draw
           };

     䥩 ᮢ CCowboy  WWindow 
  ।  CowboyWindow  ᤥ ॡ㥬 ८।
  㭪権 cow_draw()  win_draw:

           class CowboyWindow : public CCowboy, public WWindow {
             // ...
             void cow_draw();
             void win_draw();
           };

  ⬥⨬,   ⢨⥫쭮 㤭   ⮬, 
    㭪権 draw()   ⨯ ࠬ஢. ᫨  ⨯
  ࠬ஢ ࠧ砫,   ࠢ ࠧ襭 筮
   ॣ㧪 ࠭஢ ,  㤭⥩  , ᬮ 
  稥 ࠧ 㭪権   .
         ᯮ짮 䥩᭮  
  । ⠪ ७ 몠, ⮡ ॡ㥬 
  室  䥪⨢     ᯮᮡ.
   ⠪ 砨  筮 ।,   ᫠ १୮
  ॣ㦠 , ।⠢ ᯥ樠 ।⢠  
  ⤥쭮 .  ⭮, 砩    ᫨ﭨ 娩
  ᮢ 쭮 ।, ᮡ ᫨ ࠢ 
  ⥬, ᪮쪮  ணࠬ ᮧ .  砨
     ᫨ﭨ 娩 ᮢ  ࠧ
  ⥩ (  襬 ਬ:   樮 ⥬).
  ﭨ ⠪ ࠧத  ᮢ ᥣ  ,
   ࠧ襭        ᠬ 㤭
  .   ஡ - ࠧ ⥣ ࠡ⪨
  訡, 樠樨, ࠢ . ਬ, 易
    ,  ਢ ⮬,  । 襭:
   䥩 ᮢ  㭪ﬨ-室, - 
   㣨 ਬ. ਬ,     
   ⮫쪮 ,   ⨯ ࠬ஢  頥 祭,
  ⠢ । ᪨ ஢ન  ..
     㭪樨-室 CCowboy::draw()  WWindow_draw 
  㠫묨,   ⨬   ⠭ .
  ,  ,  ࠭ ᯮ ⠪ 㭪樨
   㤠   楯窨 맮.
     䥩 㭪樨 㦠  ᯮᮡ 䥩 
  ᠬ 짮⥫.    䥩 ᮡ 樨,
  ࠧᠭ  ᥩ ணࠬ. ⨬   vector  $$1.4.
   ⠪ ஢,    ᨢ, 
  뢠  . ᫨ 짮⥫  ࠡ 
   ᮢ, ⫨   0..size-1, 㦭 ᤥ
  ᮮ⢥騥 ᯮᮡ, ਬ, ⠪:

            void f()
            {
              vector v(10);  //  [0:9]

              //   v   [1:10]:

              for (int i = 1; i<=10; i++) {
                 v[i-1] = ... //    

              }
              // ...
            }

  襥 襭   vec c ந묨 ࠭栬 :

            class vec : public vector {
              int lb;
            public:
              vec(int low, int high)
                 : vector(high-low+1) { lb=low; }

              int& operator[](int i)
                 { return vector::operator[](i-lb); }

              int low() { return lb; }
              int high() { return lb+size() - 1; }
            };

   vec  ᯮ짮  ⥫ 権, 室
   ࢮ ਬ:

            void g()
            {
              vec v(1,10);  //  [1:10]

              for (int i = 1; i<=10; i++) {
                  v[i] = ...

              }
              // ...
            }

  祢, ਠ  ᮬ vec 來  ᭥.
     䥩    㣨   ਬ,
  ਬ, 䥩  ணࠬ  ++  ணࠬ  㣮
  몥 ($$12.1.4)  䥩  ᮡ묨 ⥪ ++.

  13.9 ࠢ騥 

  楯 ࠪ⭮   䥪⨢ ।⢮  ࠧ
  䥩   ॠ樨.  ਬ﫨  楯  砫
  ﭭ   䥩ᮬ,  ࠪ ⨯,
   ॠ樥, ।⠢  ⨯. , 
  ४ ࠪ    -筨 
  㣮, ਬ, ᫨ ௠ ⢮ ( set), 
  ३  ⮪.
      ,   ࠡ⠥  ꥪ⠬ ࠪ⭮ ⨯  
  㪠⥫  뫮,   २⢠ 㠫
  㭪権. ணࠬ 짮⥫ 稭    ᮢ
  ॠ樨. ⢨⥫쭮,   ࠧ ꥪ,  
  ࠪ⭮ ⨯  ࠧ ꥪ  ⥪, ।  ࠬ
   祭  ࠧ  ᪨. ᫨ ࠡ  ꥪ⠬
  ࣠ १ 㪠⥫  뫪,   ।
   ४뢠  짮⥫ ($$13.10).
       㣮 ࠭祭, 易  ᯮ짮 ࠪ
  ⨯. ꥪ ⠪  ᥣ  । ࠧ,
   , ࠦ騥 ॠ쭮 ⨥,  ॡ 
  ࠧ ࠧ஢.
      ࠭ ਥ ८  㤭⥩,  ,
  ࠧ ⤥ ꥪ   : ࠢ,  ।
  䥩 ꥪ,  ᮤঠ⥫,  ன 室 
     ਡ⮢ ꥪ.    ﬨ
  ॠ   㪠⥫  ࠢ饩   ᮤঠ⥫
  . 筮  ࠢ饩  ஬ 㪠⥫ 
   㣨 ,   .   ⮬,  ⠢ ࠢ饩
       ᮤঠ⥫쭮 ,  
  ⮫쪮 ,   ᢮ ࠡ  ᠬ ꥪ⠬,
     㪠⥫ﬨ  뫪  .

          ࠢ            ᮤঠ⥫쭠 

   ਬ஬ ࠢ饣   㦨  string 
  $$7.6.   ᮤন 䥩, ஫ 㯠  ࠢ
    ᮤঠ⥫쭮 .  ⮬ ਬ ࠢ 
  ᮤঠ⥫쭠  ।⠢ 묨 ⨯,  
  ᮤঠ⥫쭠  ।⠢ ࠪ ᮬ.
      ୥  ࠪ⭮ ⨯ set  $$13.3.  
  । ࠢ騩   ⮣ ⨯,     
   ?    set  । ࠢ騩
    ॣ㧪 樨 ->:

           class set_handle {
              set* rep;
           public:
              set* operator->() { return rep; }

              set_handler(set* pp) : rep(pp) { }
           };

    ᫨誮   ࠡ  ⢠,  ।
  ꥪ ⨯ set_handle  ꥪ⮢ ⨯ set&  set*,
  ਬ:

           void my(set_handle s)
           {
             for (T* p = s->first(); p; p = s->next())
             {
                // ...
             }
             // ...
           }

           void your(set_handle s)
           {
             for (T* p = s->first(); p; p = s->next())
             {
               // ...
             }
             // ...
           }

           void user()
           {
             set_handle sl(new slist_set);
             set_handle v(new vector_set v(100));

             my(sl);
             your(v);

             my(v);
             your(sl);
           }

  ᫨  set  set_handle ࠧࠡ뢠 ᮢ⭮,
  ॠ  ᫠ ᮧ :

           class set {
           friend class set_handle;
           protected:
             int handle_count;
           public:
             virtual void insert(T*) = 0;
             virtual void remove(T*) = 0;

             virtual int is_member(T*) = 0;

             virtual T* first() = 0;
             virtual T* next() = 0;

             set() : handle_count(0) { }
           };

  ⮡  ᫮ ꥪ⮢  ⨯ set,  ࠢ饬
   㦭 㢥稢  㬥 祭 稪
  set_handle:

           class set_handle {
             set* rep;
           public:
             set* operator->() { return rep; }

           set_handle(set* pp)
              : rep(pp) { pp->handle_count++; }
           set_handle(const set_handle& r)
              : rep(r.rep) { rep->handle_count++; }

           set_handle& operator=(const set_handle& r)
           {
              rep->handle_count++;
              if (--rep->handle_count == 0) delete rep;
              rep = r.rep;
              return *this;
            }

            ~set_handle()
               { if (--rep->handle_count == 0) delete rep; }
          };

  ᫨  饭   set 易⥫쭮  १
  set_handle, 짮⥫   ᯮ  ।
    ꥪ ⨯ set.
       ࠪ⨪  室  㪠⥫  ᮤঠ⥫
    ࠢ饣   짮 ।⢥ .
  , ਬ, । ⠪ 㪠⥫ 㭪樨,  祣
     ࠢ饬 . ᫨ 㭪  㭨⮦ ꥪ,
     稫 㪠⥫,  ᫨   ࠭ 㪠⥫
   쭥襣 ᯮ짮 ᫥ ,  訡 
   .    ४祭 ࠢ饣 
    ᮤঠ⥫ :

            class set_handle {
              set* rep;
            public:
              // ...

            set* get_rep() { return rep; }

            void bind(set* pp)
            {
              pp->handle_count++;
              if (--rep->handle_count == 0) delete rep;
              rep = pp;
            }
         };

    ந  set_handle ᮢ 筮  
  ᮡ ᫠, ᪮  -  ⨯  㠫
  㭪権. 㣮  - ந ࠢ騩   ᥬ⢠
  ᮢ, ।塞  .  ਥ 㤥
  ᮧ ந  ⠪ ࠢ饣 .  ਥ 
  ਬ   㧫 ᮢ, ⠪   ࠪ ⨯.
     ⢥  ࠢ騩   蠡 ⨯:

          template<class T> class handle {
             T* rep;
          public:
             T* operator->() { return rep; }
             // ...
          };

    ⠪ 室 ॡ ⢨ 
  ࠢ騬  "ࠢ塞" ᠬ. ᫨ ࠢ騩  ࠢ塞
   ࠧࠡ뢠 ᮢ⭮, ਬ,   ᮧ
  ⥪,     ⨬. ,   㣨
  襭 ($$13.10).
         ॣ㧪 樨 -> ࠢ騩  砥
   ஫  믮 - 権  
  饭  ꥪ. ਬ,    
  ᯮ짮 ꥪ⮢ १ ࠢ騩 :

          template<class T>
             class Xhandle {
               T* rep;
               int count;
             public:
               T* operator->() { count++; return rep; }

               // ...
             };

  㦭  ᫮ 孨, ᫨ ॡ 믮 樨 
  ।, ⠪  ᫥ 饭  ꥪ. ਬ,  ॡ
  ⢮  ஢  믮 権  
    㤠  . ,  ,  ࠢ饬 
  室 㡫஢ 䥩  ꥪ⠬ ᮤঠ⥫쭮 :

             class set_controller {
               set* rep;
               // ...
             public:

               lock();
               unlock();

               virtual void insert(T* p)
                 { lock(); rep->insert(p); unlock(); }
               virtual void remove(T* p)
                 { lock(); rep->remove(p); unlock(); }

               virtual int is_member(T* p)
                 { return rep->is_member(p); }

               virtual T* first() { return rep->first(); }
               virtual T* next() { return rep->next(); }

               // ...
             };

   㭪樨-室  ᥣ 䥩 ⮬⥫쭮 ( 
    訡),   㤭    蠥
  ࠪ⨪  ணࠬ.
     ⨬,    㭪樨  set ᫥ ஢. 
  뢠  , ⨯ 砩,  樨   ᫥
  饭  ꥪ  믮   ,  ⮫쪮  
  㭪権-童. ஢  権,    
    樮 ⥬,  筮  
  ⢥  ࠫ ० 믮.
     ८।  㭪樨 䥩  ࠢ饬 , 
  稫  ࠢ  ਥ ॣ㧪 樨 ->, 
  २⢮,  ⥯  ந ந
   set_controller .  ᮦ,     
  ⮨⢠ ࠢ饣 , ᫨  ந ᠬ 
   童, ।⠢騥 .  ᪠, 
  ணࠬ ꥬ,  ࠧ  ࠢ塞묨 ᠬ
  㬥蠥    ணࠬ ꥬ ࠢ饣 .


  13.10 ࠢ 

   ஥஢ ⥪   ணࠬ  訬 ६
     祢 ᮢ 易  ࠢ .
   饬 砥 ᮧ⥫ ⥪  ,   㦥 
  㤥 ࠡ. 㤥  ⠬   ⮫쪮 祭,  
  墠⪠ ⠭ 쥧 ஡,   쥧 宩 ⠭
   室, 易  ࠢ ?
        ᭮ ᮢ ࠢ   㫨஢
  ⠪: ᫨ 㭪 f() ।  頥 㪠⥫  ꥪ, 
    㭨⮦  ꥪ?  室 ⢥   易
    :    ꥪ   㭨⮦? ⢥  
   ᮡ   ᮧ⥫  짮⥫ ⠪ ⥩஢,
   ᯨ᪨, ᨢ  樠⨢ ᨢ.  窨 ७
  ᮧ⥫ ⥪ 묨  ⢥: "⥬"  "  ,
   ꥪ    ᯮ".  ⥬ 㭨⮦
  ꥪ, 筮 ,    ᡮમ ,   
  ⥬,  ।,  ꥪ    ᯮ,
   㭨⮦ , 뢠 ᡮ騪 .
      ᮦ, ᯮ짮 ᡮ騪     ᮡ
   室  ६   , 뢠 
  㭪権, ।  প, 㤭 뢠
  ⥩ ணࠬ  ࠧ 몠   ᫮ ⥬.
   짮⥫    ᥡ ⮣.

   ,  ணࠬ  ᯥ , ᪮쪮  ࠢ
  ,  ⮬   ⤠  짮⥫. ணࠬ
    ⮦ , ᪮쪮  ࠢ ,  ⮬ 
   ⠢  ⥬.

  ⮬  設⢥ ணࠬ  ++  室 뢠
   ᡮ騪   㦭 । ᢮ ⥣ ࠧ饭
  ꥪ⮢  ᢮ ,    ⥬.  ॠ樨
  ++  ᡮ騪  -⠪ .
      ᬮਬ ᠬ  奬 ࠢ   ணࠬ
   ++.  ⮣  operator new()  ਢ 㭪
  ࠧ饭,  operator delete() -   㭪:

          inline size_t align(size_t s)
          /*
               ⮩ 㭪樨 ࠧ饭 㦭
             ࠢ , ⮡  ꥪ
              뫮 ந 㪠⥫
             ந쭮 ⨯
          */
          {
            union Word { void* p; long double d; long l; }

            int x = s + sizeof(Word) - 1;
            x -= x%sizeof(Word);
            return x;
          }

          static void* freep; // ந start  ᢮ 

          void* operator  new(size_t s) //   㭪 ࠧ饭
          {
            void* p = freep;
            s = align(s);
            freep += s;
            return p;
          }

          void operator delete(void*) { }  // 

  ᫨  ᪮筠,   襭  ᡮ騪  
  直 ᫮⥩   室.  室  ਬ
   ⥪,  ࠭ ⭮,  ࠧ 㤥
  ᯮ짮 ,   ணࠬ,  ⥪,
  㤥  讥 ६ .  ᯮᮡ 뤥 
  쭮 室  ணࠬ,  ॡ ࠭祭 ꥬ
    ꥬ, ய樮 ࠧ 室 ⮪ .

  13.10.1 騪 

     ᬠਢ  ஢ ᪮筮
     ࠭祭 ࠧ.   ⮬, 
  ⢥  ⨯ :   ᡮ騪  뢠
     ꥪ⮢,    ᯮ? ࠢ
  ⢥ - , ᪮, ᫨ ࠧ饭  ᢮  ꥪ
    㤠,    㤥  㭨⮦. 室  ⮣, 
  delete  ᬠਢ    맮  (  
  - ᮮ饭 ⥬,   ꥪ  ᯮ짮).  
  , ᫨ ⢨⥫쭮 ॡ 㭨⮦ ࠧ饭  ᢮
   ꥪ,    㤠? ⨬,  
  ᪨  ⮬᪨ ꥪ⮢ ⠪   ⠥, -
      뢠 ᥣ. , 㭨⮦
  ꥪ " ६ ᡮન "   
  樥  ।᪠㥬 १⮬.   ᮢ
    ६  ᫥ ᯮ짮 ꥪ  "殬
  ணࠬ",  ,   ﭨ 㤥 ணࠬ   
  ⭮.

    ᯮ짮 窨, ⮬  㤭 筮 ।,
   ⠪  ணࠬ. (ਬ. ॢ.)

  㤭 ࠢ쭮 ணࠬ஢ ⠪ 樨    ⠪ ,
   .
      㭨⮦ ꥪ⮢, ᫨ ६ ⮩ 樨 筮  ,
      ணࠬ 㦨   㭨⮦. 
   ࢥ஬ . ᫨ ꥪ 室 㭨⮦   ணࠬ,
       樠⨢ ᨢ   
  㪠⥫  㭪 "⪨". ᫨ ꥪ 㤠  樥,
   㫨.  㭨⮦ ᠬ ࢥ ( 
  ணࠬ) 뢠 㭪樨 ⪨   ⠢ .
   襭 室   ᡮન , ᪮  ᬠਢ
    ஢ ᪮筮 .  ᡮ騪  㦭
      襭:  㤠 ꥪ,  ⢥
  ⠢襩 뫪   㤥 뫪, 室  ᨢ ᠬ
  ࢥ,  (⠭⭮ 襭)  㤠 ꥪ  
  ணࠬ, ᪮ -⠪ 뫪   .
       ࢥ   ॠ  樠⨢ ᨢ ($$8.8):

           class Register {
               Map<void*, void (*) (void*)> m;
           public:
               insert(void* po, void(*pf)()) { m[po]=pf; }
               remove(void* po) { m.remove(po); }
           };

           Register cleanup_register;

  , ﭭ 騩  ࢥ,  룫拉 ⠪:

           class X {
             // ...
             static void cleanup(void*);
           public:


            X()
            {
              cleanup_register.insert(this,&cleanup);
              // ...
            }


            ~X() { cleanup(this); }

             // ...
           };

           void X::cleanup(void* pv)
           {
             X* px = (X*)pv;
             cleanup_register.remove(pv);
             // ⪠
           }

   ⮡   Register     ⨯,  ᯮ짮
   㭪-童  㪠⥫ ⨯ void*.

  13.10.2 ⥩  㤠

  ⨬,     ᪮筮   ᡮ騪 .  
  ।⢠ ࠢ   뢠 ᮧ⥫
  ⥩, ਬ,  Vector?   ⠪  ⮢,
   int, 祢,   ஢   ⥩. ⮫ 
  祢,   㣨 ⨯, ⠪,  ࠪ  Shape,
   ⥩ ᫥ ࠭ 㪠⥫. ⥫ ⥪
   ।ᬮ  ਠ. ਢ ᮪ 祢
  襭:

             template<class T> Vector {
                T* p;
                int sz;
             public:
                Vector(int s) { p = new T[sz=s]; }
                // ...
             };

  ᫨ 짮⥫  㤥   ⥩  㪠⥫ 
  ꥪ ᠬ ꥪ ⨯ Shape,   襭 室  
  ਠ⮢.

             Vector<Shape*> vsp(200);  // ଠ쭮
             Vector<Shape> vs(200);    // 訡  ࠭樨

   , ࠭ ᫥  ᮧ ᨢ ꥪ⮢
  ࠪ⭮   Shape.
     , ᫨ ᯮ 㪠⥫, ᮧ⥫ ⥪ 
  짮⥫  ,  㤥 㤠 ࠭
   ⥩ ꥪ. ᬮਬ ਬ:

             void f()
                  // ⨢稢 ᯮ짮 ।
                  // ࠢ 
             {
               Vector<Shape*> v(10);
               Circle* cp = new Circle;
               v[0] = cp;
               v[1] = new Triangle;
               Square s;
               v[2] = &s;
               delete cp; //  㤠 ꥪ,   ஥
                          // 㪠⥫, 室騥  ⥩
              }

  ᫨ ᯮ짮 ॠ  Vector  $$1.4.3, ꥪ
  Triangle  ⮬ ਬ ᥣ ⠭  襭 ﭨ
  (   㪠⥫), ᫨ ⮫쪮  ᡮ騪 .
    ࠢ   -  ४⭮. ᬮਬ ⠪
  ਬ:

              void g()
              // ४⭮ ᯮ짮 । ࠢ 
              {
                Vector<Shape*> v(10);
                Circle* cp = new Circle;
                v[0] = cp;
                v[1] = new Triangle;
                Square s;
                v[2] = &s;
                delete cp;
                delete v[1];
              }

     ᬮਬ ⥯ ⠪  , ᫥  㤠
  ᥭ   㪠⥫:

             template<class T> MVector {
               T* p;
               int sz;
             public:
               MVector(int s);
               ~MVector();
               // ...
             };

             template<class T> MVector<T>::MVector(int s)
             {
               // ஢ઠ s
               p = new T[sz=s];
               for (int i = 0; i<s; i++) p[i] = 0;
             }

             template<class T> MVector<T>::~MVector()
             {
               for (int i = 0; i<s; i++) delete p[i];
               delete p;
             }

  짮⥫  뢠,  ᮤঠ騥  MVector 㪠⥫
   㤠.  ᫥,  ᫥ 㤠 MVector 짮⥫
       㪠⥫  ꥪ⠬, ᨢ訬  
  ⥩.   㭨⮦ MVector     
  㪠⥫  ᪨  ⮬᪨ ꥪ, ਬ:

             void h()
             // ४⭮ ᯮ짮 । ࠢ 
            {
               MVector<Shape*> v(10);
               Circle* cp = new circle();
               v[0] = cp;
               v[1] = new Triangle;
               Square s;
               v[2] = &s;
               v[2] = 0;  // ।頥 㤠 s

               //  ⠢訥 㪠⥫
               // ⮬᪨ 㤠  室
             }

  ⢥, ⠪ 襭  ⮫쪮  ⥩஢, 
    ᮤঠ  ꥪ⮢,    Map ($$8.8),
  ਬ,   .  ਢ ⮩ ਠ 
   MVector,  ᮤন 訡, ᪮     㪠⥫,
   ᥭ  ⥩, 㤥 㤠 ⮦  ࠧ.
      ஥  㭨⮦ ⠪ ⥩஢,  ᫥
   㤠 ᮤঠ   ꥪ, 쭮 ண
  . ஢   ⥩஢ ᫥ 
  ,  ࠩ , ᨫ쭮 ࠭ (⢨⥫쭮, 
  㤥 ⢥  㤠 ⥩   ?):

            template<class T> MVector {
               // ...
            private:
               MVector(const MVector&); //।頥 ஢
               MVector& operator=(const MVector&); //  ᠬ
               // ...
            };

   ᫥,  ⠪ ⥩  ।  뫪
   㪠⥫ (᫨, ,  ᫥ ),  ⮣  ࠢ
    㤭 㣮 த.
       뢠  㬥 ᫮ 㪠⥫,  묨
   ᫥ 짮⥫. ⢨⥫쭮,   ᫥
   100 ꥪ⠬ ࢮ ஢, ,  ᢮ ।, ࠢ
  1000 ꥪ⮢ 㫥 ஢, 祬 ।⢥ ࠡ 
  1100 ꥪ⠬. ⢥, ਢ  ⮬ ࠧ ਥ,
    㣨 ਥ, ᯮ㥬  ࠢ , ᢮
   ⠭⨧樨  㭨ᠫ樨   ਬ  ஢
   ஢.   ᢥ 
  ࠢ   ࠪ᪨ ࠧ ᫠ ꥪ⮢,
  ᪠ 100 000,   ࠢ塞 ᫠, ᪠ 100.
       ⠪ ࠧ ।  ⥩, ⮡
  ணࠬ, ᮧ騩 ꥪ ⨯ ⥩,  
  ⥣ ࠢ   ᪮쪨 ,  ।
  ⥩ ⮫쪮  ⨯? ᫨  ,  㤥  ࠢ?
   ன  ⢥ ⥫, ᪮ 設⢮ 㭪権
   ⥬      । .
  ⢮  ᪮쪨 ࠧ ⨯   ⥩୮
     짮⥫ 㦭 ᫮.  ⥪ 
      ⥩஢ (Vector  MVector),   , 
  ।⠢  ਠ  ⨯, ਬ:

             template<class T> PVector {
                T** p;
                int sz;
                int managed;
             public:
                PVector(int s, int managed = 0 );
                ~PVector();
                // ...
             };

             template<class T> PVector<T>::PVector(int s, int m)
             {
               // ஢ઠ s
               p = new T*[sz=s];
               if (managed = m)
                  for (int i = 0; i<s; i++) p[i] = 0;
             }

             template<class T> PVector<T>::~PVector()
             {
               if (managed) {
                  for (int i = 0; i<s; i++) delete p[i];
               }
               delete p;
             }

     ਬ஬ ,   । ⥪  祭
  ࠢ ,  ࠢ騩   $$13.9.  
  ࠢ饬    뫮  ,  ᯮ
  । ꥪ ⮣ ,  㬠  ⮬,  㤥
  㤠 㯭 १  ꥪ.  ᤥ ᠬ ꥪ ࠢ饣
  .  ⠪ 室 ॡ, ⮡  ࠢ塞 ꥪ 뫮 
    ᫠ ᯮ짮.  ⥫ ꥪ, 
     ⪮ ॡ:

             template<class T>
             class Handle {
                T* rep;
                int* pcount;
             public:
                T* operator->() { return rep; }

                Handle(const T* pp)
                  : rep(pp), pcount(new int) { (*pcount) = 0; }
                Handle(const Handle& r)
                  : rep(r.rep), pcount(r.count) { (*pcount)++; }

                void bind(const Handle& r)
                {
                  if (rep == r.rep) return;
                  if (--(*pcount) == 0) { delete rep; delete pcount; }
                  rep = r.rep;
                  pcount = r.pcount;
                  (*pcount)++;
                }

                Handle& operator=(const Handle& r)
                {
                  bind(r);
                  return *this;
                }

                ~Handle()
                {
                  if (--(*pcount) == 0) { delete rep; delete pcount; }
                }
              };

  13.10.3 㭪樨 ࠧ饭  ᢮

    ਢ ਬ  ᬠਢ   .
  , 筠 㭪 饣 祭  । ᢮
   뢠  㤨  䥪⨢, 祬 㭪 ࠧ饭
  ᯥ樠쭮 祭. ஦ 砥 ⠪ 㭪権 
   ਢ ਬ  ࠧ饭  "᪮筮"  
   ⮩ 㭪樥 ᢮.  ⥪   
  ᮤঠ⥫ 㭪樨 ࠧ饭,  뢠,    
  㤠 㤢 ᪮ 믮 ணࠬ.  ०, 祬 
     ⨬஢ ணࠬ,    䨫஢騪,
  ⮡   室, 易  뤥 .
      ࠧ $$5.5.6  $$6.7 뫮     ।
  㭪権 X::operator new()  X::operator delete()  ᯮ짮
  㭪 ࠧ饭  ꥪ⮢  X.   ।
  㤭.   ᮢ X  Y 㭪樨 ࠧ饭  
  ⮫쪮 室묨,  ⥫쭮   ⠪ 㭪.
  묨 ᫮, ⥫쭮   ⥪ ⠪ , 
  ।⠢ 㭪樨 ࠧ饭  ᢮, ਣ  ࠧ饭
  ꥪ⮢  . ᫨ ⠪  ,  㭪樨 ࠧ饭
   ᢮       ਢ離  
   㭪権 ࠧ饭  ᢮:

             class X {
                static Pool my_pool;
                // ...
             public:
                // ...
               void* operator new(size_t) { return my_pool.alloc(); }
               void operator delete(void* p) { my_pool.free(p); }
             };

             Pool X::my_pool(sizeof(X));

     Pool  ।   ࠧ.
   ਢ ਬ ꥪ my_pool ⢮  
  ࠧ஬ sizeof(X).
    ⠢ ᠭ  X  ᯮ Pool  ⮬ ⨬樨
  ᪮ ணࠬ  ⭮ ।⠢.  ,
   ࠧ 뤥塞      "஥",
  ⮬ 騩 ࠧ ࠬ 㭪樨 X::operator new() 
  ᯮ. ᯮ ਠ 㭪樨 X::operator delete()
   ࠬ. ᫨  Y  ந  X, 
  sizeof(Y)>sizeof(X),    Y   ᢮ 㭪樨
  ࠧ饭  ᢮. ᫥ 㭪権  X ਢ
   .  ,  ⠪ 㭪樨  Y 祭 .
      Pool ।⠢ 易 ᯨ᮪ ⮢ ॡ㥬
  ࠧ.  뤥    䨪஢ ࠧ
      訢   . 
  㯯 訬 , ⮡ ஢ ᫮ 饭
     㭪樨 ࠧ饭 饣 祭.    
   㤥 㭨⮦ ᠬ ꥪ PooL,    頥
  㭪樨 ࠧ饭 饣 祭.
      ਢ ᠭ  Pool:

           class Pool {

              struct Link { Link* next; }

              const unsigned esize;
              Link* head;

              Pool(Pool&);            //   ஢
              void operator= (Pool&); //   ஢
              void grow();
            public:
              Pool(unsigned n);
              ~Pool();

              void* alloc();
              void free(void* b);
            };

            inline void* Pool::alloc()
            {
              if (head==0) grow();
              Link* p = head;
              head = p->next;
              return p;
            }

            inline void Pool::free(void* b)
            {
              Link* p = (Link*) b;
              p->next = head;
              head = p;
            }

  ਢ ᠭ 筮    䠩 Pool.h.
  騥 ।  室    ணࠬ 
    ਬ. ꥪ Pool  樠஢
  ஬:

            Pool::Pool(unsigned sz)
              : esize(sz)
            {
              head = 0;
            }

  㭪 Pool::grow() 㤥 뢠    ᯨ᮪ ⮢
  ᢮  head, ࠧ    . ।
  ⠫ 㭪権-童 ⠢  ⢥ ࠦ 5  6 
  $$13.11.

            void Pool::grow()
            {
              const int overhead = 12;
              const int chunk_size = 8*1024-overhead;
              const int nelem = (chunk_size-esize)/esize;

              char* start = new char[chunk_size];
              char* last = &start[(nelem-1)*esize];

              for (char* p = start; p<last; p+=esize)
                  ((Link*)p)->next = ((Link*)p)+1;
              ((Link*)last)->next = 0;
              head = (Link*)start;
            }

  13.11 ࠦ

  1. (*3)  । 㭪権-童  Type_info.
  2. (*3) । ⠪  ꥪ Type_info, ⮡ 㭪
     Type_info::get_info() ⠫ 譥,  ९  ⮬ ⮣
     㭪樨-童 Type_info.
  3. (*2.5) ᪮쪮 來  ᬮ  ਬ  Dialog_box,
      ᯮ ம। ( ⠪ ७ 몠)? ᪮쪮
     來  㤠  , ᯮ ७ 몠?
  4. (*4) ᫥  ப ࠭ ⥪.
        , ࠧ  : 
     ⨯, ࠪ ⨯, 㧫 , ࠢ騥  
     䥩 . ᯮ  ࠪ 㧫 
       㧫 ?   ।  室饥
     ࠧ ᮢ  ⥪? ᯮ  
     䥩?   ।⢠  ᪮ ଠ樨  ⨯
     (᫨  )?  ⥣ ࠢ ?
  5. (*3) । 蠡 ਠ  Pool  $$13.10.3. 
     ࠧ 뤥塞   㤥 ࠬ஬ 蠡
     ⨯,   .
  6. (*2.5) ᮢ襭 蠡 ⨯ Pool  ।饣 ࠦ
     ⠪, ⮡   ࠧ頫  ६ ࠡ .
     㫨  祬 㤥 ஡ ७ᨬ, ᫨ ᯮ짮
     Pool  ⨯ ⮢ char,    ࠭.
  7. (*3) ᫨   ++ אַ  ন ᪨
       ⨯,   ᢮ ᭮ ⥪. 
      ⠬ 堭 ᪨ ᮢ  ⨯? ᫨  ⠪,
      樨  $$13.5  ன  ⨬ 堭.
  8. (*2.5) । ⠪ ப ,  ஬  
     ᪮ ஫,  ன ந   ப
     ,  ⮫쪮 ஢ ᪨ ஫  頥
      ࢮ.     ⠪ 襭  ࠢ
      襭, ஬  롮 ᪨ ஫,
     ࠢ  室, ᯮ騬 ਠ,  뫮 ।
      $$12.2.7.1. ᪮쪮  ᮢ  室?
  9. (*4) ।  Storable  ࠪ   
     㠫묨 㭪ﬨ writeout()  readin().  
     ⨬,    㦭 ᭮ ࠭⢠ 筮
     ப ᨬ.    Storable ॠ
      ꥪ⠬  ᪮. ஢   ꥪ ᪮쪨
     ᮢ  ᢮ ᬮ७.
  10.(*4) ।   Persistent  ﬨ save()
      nosave(),  㤥 ஢,   ᮧ ꥪ
      । .    樨  ।?
     ஢  Persistent  ᪮쪨   ᢮ 롮.
        Persistent 㧫 ᮬ,  
     ࠪ ⨯? 㬥 ⢥.
  11.(*3) ⠢ ⮫쪮 ᠭ  stack,  ॠ
     ⥪   権 create() (ᮧ ⥪), delete()
     (㭨⮦ ⥪), push() (  ⥪)  pop() ( 
     ⥪). ᯮ ⮫쪮 ᪨ 童.  ਢ離 
     祭 ⥪ ।  id. ࠭, 
     짮⥫ ᬮ ஢ ꥪ stack::id,   ᬮ
     ࠡ    ᯮᮡ. ࠢ  । ⥪
      ᮬ stack  $$8.2.
  12.(*3) ⠢ ᠭ  stack,   ࠪ
     ⨯ ($$13.3). ।  ࠧ ॠ樨  䥩,
      stack.   ணࠬ, ࠡ 
     ⨬ ᠬ. ࠢ  襭  ᠬ, ।騬
     ⥪,  ।饣 ࠦ   $$8.2.
  13.(*3) ⠢ ⠪ ᠭ  stack,  ண 
        ॠ. ᪠: "  
      ,    ᢥ".
  14.(*3.5) ।  Oper, ᮤঠ騩 䨪 (ண
     室饣 ⨯)   ( 㪠⥫  㭪).
     ।  cat_object, ᮤঠ騩 ᯨ᮪ ꥪ⮢ Oper 
     ꥪ ⨯ void*.    cat_object 樨:
     add_oper(),   ꥪ  ᯨ; remove_oper(id),
      㤠  ᯨ᪠ ꥪ Oper c 䨪஬ id;
     operator() (id,arg),  뢠 㭪  ꥪ Oper c
     䨪஬ id.     cat_object
     ⥪ ꥪ⮢ Oper.   ணࠬ, ࠡ
      ⨬ ᠬ.
  15.(*3) । 蠡 ⨯ Object, 㦠騩  ᮬ
      cat_object.   Object ॠ ⥪  ꥪ⮢
      String.   ணࠬ, ᯮ 
     蠡 ⨯.
  16.(*3) । ਠ  Object   Class,  ஬
     ꥪ   䨪஬  騩 ᯨ᮪ 権.
       ணࠬ, ᯮ  蠡 ⨯.
  17.(*3) । 蠡 ⨯ Stack,   ࠤ樮
       䥩  ⥪, ॠ㥬 ꥪ⮬ 蠡
     ⨯ Object. ࠢ  । ⥪  ᠬ, 騬
     ⥪,  । ࠦ.   ணࠬ,
     ᯮ  蠡 ⨯.

