
        ++

          ६  , ᨬ쭮 ,   ᢥ ⮣.
           - . ⥩
     饭 裡  ஥஢  몮
  ணࠬ஢ ++.   ᫥ ਬ ᮢ 
  ஥஢  㪠뢠 ।  ᨬ⥩, 
  ᫥ 뤥   , ⠪   ᠬ. 砥
  ஫ ᪮ ஫ ⨯. ᫥ ਬ ᫥
    ᫥  ਭ. 㦤 ⨥ 
     ࠧ  䥩ᮢ.

  12.1 ஥஢   ணࠬ஢.

  ᫨    뫮 ந ,   쥧 㬠 , 
   ਠ  ந,  ஥  ᨫ쭮 ᥫ  
  ࠭ ਠ, , ᫥⥫쭮, ࠧ㬭 ஥ 
   ⫨  ࠧ㬭 ஥⮢ ⠫᪮  
   ࠧ㬭 ஥⮢ ॢﭭ   ..  ⮨
  뢠  롮 室饣   ਠ  ।
    ਠ   ᯮ짮. 筮,    
  ᯥ樠⮬ ⭨  ஥஢ ॢﭭ ,  
    ᭮ ஢  ॢ, ⮡ । 
  ⠫  ⢥ ਠ  .  ⮣,  
  ஥஢ ॢﭭ       ᯥ樠⮬
  ⭨,  室 筮 ⠫쭮  ᢮⢠
  ॢ      ⭨.
      筮,  롮 몠 ணࠬ஢ 
  । ணࠬ ᯥ祭   ᪮쪮 몮,
    ᯥ譮 ஥஢ ணࠬ  筮 ⠫쭮
   ࠭  ॠ樨,  ᫨  筮  ।⮨
     窨 ணࠬ. 訩 ஥஢騪 
  業 ᢮⢠ ᯮ㥬  ਠ  ਬ   襭
  ஥. 筮, 訩 ࠧࠡ稪 ணࠬ ᯮ ᨫ
  ஭ 몠 ॠ樨 , ᪮쪮 , ६  ⠪
   ᯮ짮, ஥ 맮 㤭  ⠤ ॠ樨.
       㬠,  ⠪ 砥 ⢥ ࠧ, ᫨
   ஥஢  ⮫쪮  ࠧࠡ稪  ணࠬ, 
    ⮬ 砥 ணࠬ  ᨫ ⪠   -
  ࠢ ਢথ  ⨫ ணࠬ஢, ⠭ 
  ᮢ襭 㣨 모,  ᡨ  ୮ ᯮ짮 몠.
  ᫨ ࠧࠡ稪 ⢥ ⫨砥  ணࠬ,  ᮡ
  ᫨   ࠧ ணࠬ᪠ ,  
   ⥫쭮 ᨨ ⥬ 訡, 䥪⨢   襭
   猪 ॢ  .
      ⠪, 祬   ࠧࠡ稪  ணࠬ஢? 
   ।⠢ ⠪ 몮 ।⢠,  
  ࠧ אַ  몥 ணࠬ஢ ᭮  ஥.
   砥 ॠ,  ন  ᮮ⢥⢨
  ஥,  ࣠ 饭 
  ࠧࠡ稪  ணࠬ⠬,    ᮧ
   ᮢ襭 ।⢠   ࠧࠡ稪, ⠪  
  ணࠬ⮢.
      ਬ,  ⮤ ஥஢ 㤥 ⥫쭮 
  ᨬ  ࠧ묨 ﬨ ணࠬ (筮  楫
   㬥襭  ࠭⨨ ⮣,       
  ।). , ᪠騩   䥩ᮢ 
  ﬨ ணࠬ,    ⮬ 
  ࠧࠡ稪.   ࠭஢,  ⢨⥫쭮 
  ⢮ ⮫쪮 । ᨬ. ᪮
  設⢮ ᨬ⥩  ࠦ  ணࠬ  ⠪ 몥,
   ࠧࠡ ।⢠, 騥 ணࠬ  뤠騥 
  ᨬ⥩.  ⮬ 砥 ࠧࠡ稪  㣨 ᯮ⥫ 
  ᭨  ணࠬ.  모 ணࠬ஢  ++
   ᮪ ࠧ  ஥⮬  ணࠬ,  
  㬥  ⠭  .
        ⨥ ++ -  .   ।
  ⨯. ஬ ⮣,   ࢨ ।⢮ 뢠
  ଠ樨.  뢠 ணࠬ  ନ 짮⥫᪨
  ⨯  娩  ⨯.  ஥, ⠪  짮⥫᪨
  ⨯ 稭 ࠢ ᪮ ஫ ⨯. 㠫
  㭪樨 ।⠢,   ࠢ ᪨ ⨯,
  堭 뢠  ⠯ 믮.  ⨯ 
  ᮧ ࠬਧ ⨯. ᮡ 樨  ᤥ
  ॣ୮ ॠ  訡.   ।⢠ ++ 
  ᯮ짮  ⥫ 
  室  ࠢ  ணࠬ  .  訥
  ।⢠ ++,   ।⠢  뢠 ࠧࠡ稪.
  ஬ ⮣, ⢥   ਭ⨥ 襭  ⠤
  ஥஢  稥  㯭  ⥪
  ᫥饣 祭:  ࠡ  栬,  裡 
   ,  প ࠫ쭮
  ணࠬ஢, ᪨ ⥪  ..
         । , ਣ   ࠡ  㣨
  몠,  㣨 ⥬   ਫ,  ।⢠
  ஥஢ -   ਢ  ⨬쭮 ᯮ짮 ++.
   ⬥  ,  ࠧࠡ稪  㤠
   룮  ⥩ ++   ࠭祭 몠:
  [1] ஢ ᮢ  ⠢ ஥ ⠪ ࠧ, 
      ணࠬ⠬ 室 ࠭稢 ⮫쪮 .
  [2] ஢ ந ᮢ  㠫 㭪権,
      ᯮ짮 ⮫쪮 ⢠ ࠪ .
  [3] ஢ ᪮ ஫ ⨯  ⠢ ஥
      ⠪ ࠧ,  ணࠬ 㦤 ਬ ᪨
      ஢ન ⨯.
  筮 㪠    ࠧࠡ稪, 易 :
  [1] C,  ࠤ樮 ⥬ CASE  ⮤ ୮
      ஥஢;
  [2]   ⮤ ஥஢   ࠪ樨 ;
  [3] 몠,  Smalltalk  Lisp.
    砥 ᫥ : ࠢ쭮 ࠭ 
  ॠ樨 (,  ⮤ ஥஢ ࠭ ୮), 
  ࠧࠡ稪  㤠 ᯮᮡ  業  (, 
   ॠ樨 ࠭ ୮).
        ᪠,   祣 筮  ୮ 
  ⠪ 宦.   宦, ஥ ਢ 
  ⨬쭮 ஥,  ⥫ ࠡ 
  ணࠬ⮢,   砥,   ⨩ ஥
  ⥫쭮   몠 ++,    ᠬ ࠧࠡ稪.
       ⬥⨬,  易⥫쭮  ணࠬ 
  ஢    ᮢ  () 娩 ᮢ,
   易⥫쭮 猪 ணࠬ  ᯮ짮  ।⢠,
  ।⠢塞 ++.  ࠧ ,  ᯥ ஥ 室,
  ⮡   뢠 ᯮ짮 몮 ।,  묨
   ⮫쪮 .  ᫥饣    ⮬,
  ⮡ 易 筮 ᯮ짮 ᮢ, 娩 
  ண ⨯஢ 䥩ᮢ,   ⮬, ⮡ 
    ᯮ짮 ,   
  ਫ, ࠭祭 ++   ᯮ⥫.  $$12.1.4 
  ᬮ७ 室  ࠧ筮 ᯮ짮 ++  ஥
    "஥-ਤ".

  12.1.1 ஢ ᮢ

  ᬮਬ   㪠 ⮢ - ஢ ᮢ.
   ⠪ 砥 稢 ணࠬ  ++ 㤥 ਡ⥫쭮
  ⭠ -ணࠬ, ࠧࠡ⠭  ⮬  ஥, ,
   ᪠,    ਡ⥫쭮  ணࠬ
     , ࠧࠡ⠭   .
    ஥ ⠢  騩  몠 ॠ樨, 
  ਭ㦤 ணࠬ ࠭稢 騬 ⢮ 몮
  ,   .   ᢮ २⢠. ਬ, 稢襥
   १ ண ࠧ   ணࠬ  
   ᯮ짮 ࠤ樮  ,  ࠧࠡ⠭
   ⠪ ணࠬ. ᪮ ᯮ ࠭祭 
  ணࠬ஢,  ணࠬ⮢ ॡ  ⭮
  (,  ࠩ  㣮  ஢).   ਫ,
  ਬ,  ࠤ樮  , ࠡ 
  䠩 ᫥⥫쭮, ⠪ 室  ࠧ㬥,  ࠤ樮
  ਥ, ࠡ⠭  ⨫,   .
        ⠬,   ਫ ⢥ ⫨砥 
  ࠤ樮 ᫥⥫쭮 ࠡ⪨ ᥩ ( ᨬ),
   ᫮  , , ਬ,   ⥬
  CASE, ⮪ 몮 প ࠪ 
  - ⪠  ᮢ (᫨   뢠) ।
  ஥.    㬥, , ᪮ ⥬
  ॠ   몥,   ணࠬ  㤥
  ⢥ ஥.   ᫨誮 让 ꥬ,  墠⠥ ஢ન ⨯,
  , ,   ᯮᮡ  ᯮ짮 ࠧ
  ᯮ⥫ ।.  , ਢ騩  謠ࠬ  
  ᮯ஢.
       筮  ८ 㪠 㤭⥩ ᮧ ᯥ樠
  ।⢠, ন騥 , ᯮ㥬  ஥. 
   ᮧ 樨  ᮪
  ஢  ࣠ ஢ન  楫 ஢ 䥪
  ( ᮧ⥫쭮 ) 몠 ॠ樨.  ⮤
  ஥஢ ⠭ ᠬ楫,    ᮧ ᯥ樠
   ணࠬ஢.  모 ணࠬ஢  設⢥
  砥  宩  ப ࠭ 몮
  ணࠬ஢ 饣 祭,  ᮯ஢
  室騬 ।⢠ ஥஢. ᯮ짮 ++  ⠪
  ࠭祭, ஥  ஢  ஥஢
  ᯥ樠묨 ।⢠, ᫥.  ᮮ⢥⢨ 
  몮 ணࠬ஢  ।⢠ ஥஢   
  ⠤  室,   ६ .
        ⨯筮 稭 ஢ ᮢ  ஥஢
    . ࠤ樮 모 ணࠬ஢ 
  ।⠢  ,   ࠤ樮 ⮤ ஥஢
  ࠦ  ⮪. 筮   ஥஢
  襥  㤥 ࠧ   楤,
  ந騥 ॡ㥬 ⢨.   1  ⨥ 뢠
  楤 ணࠬ஢,    ஥஢ 
    㭪樮쭠 .  ⨯
   "  ᯮ짮 ++ ᮢ⭮  ⮤ ஥஢,
  騬  㭪樮쭮 樨?" , , ,
  ⭥ ᥣ,  १  ਤ  ᯮ짮 ++ 
   襭   ᥬ 㪠묨  ஡. 
    ਥ  ਮ 室   ,  
  㦥 襭 ஥஢,   ,  
  ᯮ짮 ᮢ   ⢥ 룮 (᫨ 뢠
   ணࠬ஢  ++   ),   饬
  砥  讬 १ ६ ⪠  ᢮
  ᯮ짮 ᮢ, 易  ⮤ 㭪樮쭮
  樨,   ᮢ⨬  䥪⨢ ᯮ짮 ++.
        楤୮-ਥ஢  ꥪ⭮-ਥ஢
  室  ணࠬ஢ ࠧ  ᢮   筮
    ᮢ襭 ࠧ 襭  .  뢮
  ७   ⠤ ॠ樨, ⠪   ⠤ ஥஢:
   業    ।ਭ ⢨,  
  ।⠢塞 魮,    ⮬  㣮 ६.
         祬 ⮤ ꥪ⭮-ਥ஢ ஥஢
  ।⥫쭥 ⮤ 㭪樮쭮 樨?
   稭  ⮬,  㭪樮쭠   
  筮 ࠪ樨 .   㦥 ᫥,  ஥
  㤥
      -  ⫨  ,
      -  ᯮᮡ  ᯮ짮 ࠧ ᯮ⥫
        ।,
      -  ਣ  ࠫ쭮 ࠧ 
      -  ਣ  ࠫ쭮 믮.
    ⮬,  㭪樮쭠  㦤 
  ""  묨, ᪮, ᫨ ⥬ ஢
   ॢ 㭪権, 类 , 㯭  㭪, 
     ⭮襭  .  ਢ  ⮬, 
  ""  "ᯫ뢠"  設 ॢ, 
   ⮣   襥 ᫮ 㭪権 ॡ 㯠  .

    筮 ⠪  ந室  砥 娨 ᮢ  
  ୥,  ""  ᯫ뢠  ࠢ  
  .

    業㥬   ᠭ ᮢ, 
  ।   ,  ᨬ  ࠧ묨
  ﬨ ணࠬ ࠦ     ᫥.  
   ,   ⠪ 室 㬥蠥 ᫮ ᨬ⥩
   ⥬   襩 ⠭ 뫮  .
      ,       
  楤.  "ꥪ⭮-ਥ஢" ஥஢  
  ⮬, ⮡ 㤠   楤  ணࠬ 
     ⥬ 楤୮-ਥ஢ ⥩. ᭮
   ᪮॥  ⮬,  ,    楤 ⠭
   ꥪ⮬   ⠤ ஥஢. ᯮ짮
  楤୮ ⨫   ᮧ 襭,   襭,
  ਭ  㬮砭.  , ⠪  楤 ᫥
  ਬ ᮮࠧ  ਫ,    
   ⮤ ஥஢.

  12.1.2 ஢ ᫥

  ᬮਬ ਠ 2 - ஥,   ᫥.  ⮬
  砥  ⥫쭮 ணࠬ   ᯮ 
  ᭮ ।⢠ ++,    । 룮 
  ᯮ짮 ++  ࠢ  ᯮ짮 몮 , ᪠,
  ࠭,   ..     ⮣,  樨,
  ⢥ত,  "᫥ -  ⠫ ॠ樨",  "᫥
  ९ 뢠 ଠ樨",  "᫥ 㤭
  ⢨  㣨 ⥬ ணࠬ஢".
        ᫥ ᥣ  ⠫ ॠ樨 - 
  ஢  ᮢ,   ।⢥
  ஢ ⭮襭  ﬨ   ਫ. 
  ⭮襭    ࠦ  ஥, ⮡ 
   ࠧࠡ稪 த㬠 .
           ਢ   ᪫祭 ᫥
    ⥩ ணࠬ  ++,  ।⢥ 
   ணࠬ, ᠭ묨  㣨 몠.    
  筮 稭, ⮡ ⪠  ᫥  ⥬
   楫,      ⮣, ⮡ ⭮ ।
   㫨஢ ணࠬ 䥩  "譨 ஬".
  筮, ⮡   ᯮ⢠, 맢 ⠭楩 
  뢠 ଠ樨  稨 ᫥,  ஦
  ᯮ짮 㠫 㭪樨   童,  
  ⪠뢠  ᫥.
          筮  権,  ᯮ짮
  ᫥    룮,  ⨪
  " ᫥" ਢ   ⭮   
  ⥬,  ன ᫥ "뢠"  
   ࠤ樮 権 몠  ஥஢.
    ஥⮢  ⢥.  ⮣,
   ,  ᬮ  ⠪ ⨪, ᫥
   ࠢ 㤥 ᯮ짮, ᪮ ணࠬ, ࠡ騥
   ++,  㡥⥫    ஥஢  ⮬
  ᫥  ࠧ  ⥬.  ࠧ, ⨪
  " ᫥" ਢ   ⮬,   ⥬ 㤥
  ⢮ 楫⭠  ,  ᯮ짮 娨
  ᮢ 㤥 ࠭祭 ।묨 ⥬.
          묨 ᫮,  ।㡥묨.  ᮢ
    易⥫쭮  类 襩 ணࠬ,  
   権,        
  ਫ, ⠪   㫨஢ 襭. ⢥ত, 
  ᫥  ࠢ쭮  १୮ ᯮ짮,
  㦨 ⮫쪮    ஦,     
  ⪠  .

  12.1.3 ஢ ᪮ ஫ ⨯

  ᬮਬ ਠ 3, ⭮騩  ஥,  ஬ 
  ᪨ ஫ ⨯. ࠭    ⪠
   ⠤ ஥஢  ᪮ ஫ ⨯ ᢮
   ⮬,  "⨯ -  த 몮 ணࠬ஢",  
  " ⢥ 㦤  ꥪ,    ⨯",
   "᪨ ஫ ⨯ 㦤  㬠  ॠ樨
   ᫨誮 ࠭ ⠯".  室  ⨬   ,
    ࠡ⠥   ਭ ।.  ࠧ㬭  ⠤
  ஥஢    ⠫ ஢ન ⨯,  
   ⨬  ⠤   砫 ⠤ ஥஢
     , 易  ⨯.    ६,
    娨 ᮢ 祭   ⠤ ஥஢,
   ⭮,     । ⨩, 
  筮  ⭮襭  ﬨ   㦤
   .   ࠧ ஥  ।  筮
  ८ࠧ     ⢥ত    
  䥩.
       ,  筮 ।  ண ⨯஢
  䥩  㭤⠫ ।⢮ ஥஢. 
  ++  ᮧ  ࠧ  ⮬ ⮣. ண ⨯஢
  䥩 ࠭,  ⮫쪮 ᮢ⨬ 
  ணࠬ   ᪮஢  ᪮ ,  ⥬
  ᠬ   ⭮⥫쭮 ண 饭   .
   饭 ᯥ稢 ⥬ ⨯ 몠.
   १ ᢮   ஢ન  ⠯
  믮,  蠥 䥪⨢  ਢ  ⥫쭮
  ᮪饭 䠧 ⥣樨 ⥩ ஥, ॠ ࠧ묨
  ணࠬ⠬.  ⥫ 
  ⥣樨 ⥬  ண ⨯஢묨 䥩ᠬ ਢ
   ⮬,   ⥣樨   䨣 । ᭮
  ⥬ ⮩ .
       ᬮਬ ᫥ :  䨧᪮   ﭭ
  ᮥ塞 ࠧ ன⢠,   饥 ᪮
  ᫮ ⠭⮢  ᮥ.  ᮡ  ᮥ:
   ᯥ樠쭮 ஥஢ ⠪ ࠧ, ⮡ ᤥ 
  ᮥ  ன, ⠭  ,
    ᮥ   ᤥ ⢥
  ࠢ ᯮᮡ.    ᮥ ஡ 
  ஧⪥  ᮪ 殮. ᫨   ᬮ ᤥ , 
  ᮦ    ᣮ५ ᠬ.  ⥫쭮 뫠
  , ⮡   ᮥ 
  ᮢ⨬ ன. ୠ⨢ ६ ᯮ짮
  ᪮쪨 ᮢ⨬ ன  㦨 ⠪ ன⢮,
  ஥ ᠬ ᥡ 頥  ᮢ⨬   ன,
     室. 訬 ਬ஬  㦨 ⠡
  殮. ᪮  ᮢ⨬ ன 
  ࠭஢ ⮫쪮  "஢ ᮥ",  ॡ 
  ண   ᪮ 楯,    
  ᯮᮡ  ()   ᪠窮 殮.
         ࠪ᪨ ﬠ : ᪨ ஫
  ⨯ ⥭ ᮢ⨬  ஢ ᮥ,  ᪨
  ஢ન ᮮ⢥   樨  楯. ⮬
  㤠筮 ஫   䨧᪮, ⠪   ணࠬ  㤥
  쥧 .   ⥬ ᯮ   ஫.
   ࠭ ⠯ ஥஢  筮 ⮣ ⢥ত:
  "  ன⢠ 室 ᮥ";  ᪮ ⠭
  ⢥,   ᫥  ᮥ: " ࠭⨨
   ᮥ ⭮⥫쭮  ன?", 
  "  訡 権 ?", 
  " ਡ⥫쭠 業 ⠪ ᮥ?"
          ਬ "᪮ ⨯樨"  ࠭稢 ணࠬ
  ஬.  䨧   㪠 ᥬ⭮ ࠭
   ७ (, ࠬ, ᥪ㭤), ⮡ 
  ᬥ訢 ᮢ⨬ 魮⥩.
           襬 ᠭ 蠣 ஥஢  $$11.3.3 ⨯
    業 㦥  蠣 2 (祢, ᫥ ᪮쪮
  ⢥  ᬮ७  蠣 1)  ⠭ 
  ⥬ 蠣 4.
          ᪨ ஫㥬 䥩 - 
  ᭮ ।⢮ ⢨ ணࠬ ⥩ ⥬
   ++, ᮧ ࠧ묨 㯯,  ᠭ 䥩ᮢ 
  ⥩ ( ⮬  । ⨯) ⠭ ᭮
  ᯮᮡ 㤭⢠  ⤥묨 㯯 ணࠬ⮢.
   䥩  ᭮ १⮬  ஥஢
   㦠  ।⢮ 饭  ࠧࠡ稪 
  ணࠬ⠬.
          ⪠  ⮣ ਢ  ஥⠬,   ᭠
   ணࠬ, ஫ 訡 ⫮  ⠤
  믮,   㤭  ॠ  ++.
          ᬮਬ 䥩, ᠭ   "ꥪ⮢",
  । ᥡ ᠬ⥫쭮. , ਬ, ⠪ ᠭ:
  "㭪 f()  㬥,    ᠬ⮬"
  ( ஢ ᠬ 㭪樥  ६  믮),  ⫨稥
   ᠭ "㭪 f()  㬥, ⨯ ண  ᠬ"
  ( ஢ ࠭஬). ࢮ ᠭ  ⢥
   ᠭ 䥩, .. ਢ  ᪮ ஢થ
   ᪮ ஫.  뢮  ਬ 
  ᠬ⮬ ᤥ  $$1.5.2.  ᯮ짮  
  ᯥ䨪樨,  ᯮ짮 蠡 ⨯  㠫 㭪樨 
  ࠭祭 ᪨ ஢ப  ⮣, ⮡ ७
   訡  ⠯ 믮  ⠯ ࠭樨.  稥
  ६ ࠡ ணࠬ  ᪨  ᪨ ஫
    쬠 ⥫, 筮  室  
   3  10 ࠧ.
         ᫥    ࠩ.  㦨
   訡   ᪮ ஫. ਬ, 
  ணࠬ  ᠬ  ᪨ ஫ 梨  ᡮ
  .   ,   㦭  讥 ࠧࠧ
  䥩ᮢ  ᪮ ⨯樥   ⨯  
  ਫ, . $$12.4.
       ,  ஥, ᮢ襭
  ࠧ㬭  ࠪ⭮ ஢,  ⮫  쥧묨
  ஡, ᫨  뢠 ࠭祭  ।, 
   砥 ++. ਬ, ᯮ짮 ,   ⨯ 
  ஢ ⥬ ਢ  㦭 ஡ 
  ⥬ ⨯ ++ , ⥬ ᠬ,   稭 訡 
   室  믮. ᬮਬ  :

          class X { // pseudo code, not C++
            f()
            g()
          }

          class Y {
            g()
            h()
          }

          class Z {
            h()
            f()
          }

  ᯮ㥬 묨 㭪ﬨ ⨯ ஥:

          k(a, b, c)  // pseudo code, not C++
          {
            a.f()
            b.g()
            c.h()
          }

   饭

          X x
          Y y
          Z z

          k(x,y,z)  // ok
          k(z,x,y)  // ok

   ᯥ묨, ᪮ k()  ॡ, ⮡  
  ࠬ   f(), ன ࠬ -  g(), 
  ⨩ ࠬ -  h().   㣮 ஭ 饭

       k(y,x,z);  // fail
       k(x,z,y);  // fail

   㤠筮.  ਬ ᪠ ᮢ襭 ࠧ㬭
  ॠ樨  몠   ᪨ ஫ (ਬ,
  Smalltalk  CLOS),   ++    אַ
  ।⠢, ᪮  ॡ, ⮡ 魮 ⨯ 뫠
  ॠ  ⭮襭   . 筮 ਬ,
   ⮬,  ।⠢  ++, ᫨ 뢠 ⢥ত
   魮    । ᮢ,   ॡ
  讣 㬨  ᯮ⥫ ।.  ᤥ,
  ਬ, ⠪:

         class F {
           virtual void f();
         };

         class G {
           virtual void g();
         };

         class H {
           virtual void h();
         };

         class X : public virtual F, public virtual G {
           void f();
           void g();
         };

         class Y : public virtual G, public virtual H {
           void g();
           void h();
         };

         class Z : public virtual H, public virtual F {
           void h();
           void f();
         };

         k(const F& a, const G& b, const H& c)
         {
           a.f();
           b.g();
           c.h();
          }

          main()
          {
            X x;
            Y y;
            Z z;

            k(x,y,z);  // ok
            k(z,x,y);  // ok

            k(y,x,z);  // error F required for first argument
            k(x,z,y);  // error G required for second argument
           }

   ,  ᤥ । k()  ᢮ 㬥
  묨,  ६⨫ ஫ 訡  ⠯ 믮  ⠯
  ࠭樨.  ਬ,  ਢ, ,
    ॠ  ++ ஥, ᤥ  ᭮
   ࠡ  㣨 ⥬ ⨯. 筮  ,
    १ 砥 ⢥  䥪⨢ ணࠬ.
   ᮢ  ਥ ஥஢  몮
  ணࠬ஢  ࠢ  ᮢ  ᫮
  ॢ   ⢥ 몠  㣮.  ᪨
   檮 ࠬ⨪ 룫廊 ⮫  㪫,   檨
   ᪮ ࠬ⨪,   몠   㯭
   ⮣,       .
       ਬ ⢥ত  뢮,    ணࠬ 
   饭 ⨩, ᯮ㥬  ஥஢,
  ⮬ ⪨ ⭮襭  ᠬ ਢ  ⪮
  ᭮ ⨩ ஥஢.

  12.1.4 ਤ ஥

  室   ⮤ ࠡ   ⥫  
  ࣠樨. ᪮    宦  㤭 
   ⥫묨.  १ ⥫ 室, ᯮᮡ  
  ॢ 䥪⨢  ஢ ஭ "ன 誮"
   䥪⨢ 窮 " 誮" 筮 ਥ.   
  ६,      , 
  ⥫  筮 易  ᪮.
         ++ ᮧ  楫 ᮪ ⠪   
  ⥯   ⮤.  祢,  訥
  २⢠  ᯮ짮 ++ ⨣   ࠪ樨
  , ꥪ⭮-ਥ஢ ணࠬ஢ 
  ꥪ⭮-ਥ஢ ஥஢, ᮢ襭 祢,
   ॥ ᥣ  ⮣  ⥫
  ࠧ뢮  .   ⠪  ࠧ 㤥 ,
  筮 ६  ᮢ襭⢮ ᤥন  
  ᤥন, ⮡ 室    ࠢ塞.  㦭 뢠
  ᫥饥:
    - ࠡ稪  ணࠬ⠬ ॡ ६  
      묨 ⮤.
    -  ணࠬ  ⢮  묨 ணࠬ.
    -  ணࠬ 㦭 ᮯ஢ ( ᪮筮).
    -   ⥪騬 ஥⠬  ணࠬ  
      믮  ப.
    - ।⢠, ⠭   ⮤, 㦭 ஢ 
      쭮 㦥.
   ᬠਢ  ࠧ 樨, 易  ᫥묨
  ॡﬨ.  業   ॡ.
       ᪮  ++  ᪮쪮 奬 ணࠬ஢,
   ᪠ ⥯ 室  , ᯮ
  ᫥騥 २⢠ ⠪ 室:
    -  ++, ணࠬ  த ࠡ.
    -  㦥,   ணࠬ ।⢠, ᯮ짮 ++
       ਭ ⥫ 룮.
    - ணࠬ, ᠭ  ++,   ⢮
       ணࠬ, ᠭ묨    㣨 ࠤ樮 몠.
    -   讥 ⢮, ᮢ⨬  .
       砥  ⥯ 室 ணࠬ 
  ࠤ樮 몠  ++: 砫  ணࠬ  ++
   ࠤ樮 楤୮ ⨫, ⥬   ⮤ ࠪ樨
  ,  ,   몮  易묨   ।⢠,
   室  ꥪ⭮-ਥ஢ ணࠬ஢.
  ⨬,   ஥஢ ⥪ ᯮ짮 
  , 祬 ஥஢  ॠ뢠, ⮬    ᢮
  蠣 箪   २⢠, ᯮ 
  ࠧ ।⢠ ++.
       ⥯, 蠣  ++,  ⠪ 
  ᬥ訢 ணࠬ  ++  ணࠬ, ᠭ묨  몠,
    । ࠪ樨   ꥪ⭮-ਥ஢
  ணࠬ஢, ⢥ ਢ  ஥, 饬
  ਤ ⨫. 設⢮ 䥩ᮢ   ⠢
   楤୮ ஢, ᪮ -  ᫮ 
  ਭ  먣. ਬ, 饭  ⠭⭮
  ⥪ math   ।  ++ ⠪:

       extern "C" {
          #include <math.h>
       }

   ⠭ ⥬᪨ 㭪樨  ⥪  ᯮ짮
  ⠪ ,    .   ᭮ ⥪ ⠪ 祭
    ᤥ ⥬,  ⠢ ⥪, ⠪ 
  ணࠬ  ++   㤥 ,   몥 ॠ
  筠 㭪. ᯮ짮 ⥪, ᠭ  ⠪
  몠  ,    砫 ᠬ  ᯮᮡ
  ୮ ᯮ짮  ++.
        ᫥饬 蠣,  ⠭ 室  ᫮
  ਥ, ।⢠, ॠ  ⠪ 몠    ࠭,
  ।⠢   ᮢ   樨  
   㭪権  䥩 ᮢ ++.  ਬ஬
    ᮪ ᥬ᪮ ஢   室
   ஢ 楤     ஢ ࠪ樨 
   㦨  ப  $$7.6.    樨
  ᨬ ப  ⠭ ப 㭪権 
  砥  ப ⨯,  ࠧ  ᯮ짮.
         ࠧ     ᮢ 
  ஥  ⤥쭮 । ⨯. ਬ, ⨯ int
      ᮢ ⠪:

           class Int : public My_object {
             int i;
           public:
             // definition of operations
             // see exercises [8]-[11] in section 7.14 for ideas
             // । 権   ࠦ [8]-[11]
             //  ﬨ   ࠧ 7.14
           };

   ᫥ , ᫨ ⢨⥫쭮  ॡ
   ⠪ ⨯  .
      ⭮,  ++  ।⠢  ணࠬ   
  ࠭  㭪樨   . ਬ:

            class myclass {
               // representation
            public:
              void f();
              T1 g(T2);
              // ...
            };

            extern "C" {  // map myclass into C callable functions:

              void myclass_f(myclass* p) { p->f(); }
              T1 myclass_g(myclass* p, T2 a) { return p->g(a); }
              // ...
            };

   -ணࠬ ᫥ ।  㭪樨  筮 䠩
  ᫥騬 ࠧ:

    // in C header file

    extern void myclass_f(struct myclass*);
    extern T1 myclass_g(struct myclass*, T2);

   室  ࠧࠡ稪  ++, ᫨   㦥 
   ணࠬ, ᠭ  몠,    
  ࠪ樨   娨 ᮢ, ⥯ ਮ  ⨬
  ,   ⮬ ॡ,  ⥫ ᨨ ணࠬ
   㤥 뢠  ࠤ樮 楤 몮.

  12.2 

  ᭮  ꥪ⭮-ਥ஢ ஥஢ 
  ணࠬ஢ 砥  ⮬,  ணࠬ 㦨 
   ⨩ ॠ쭮.   ணࠬ ।⠢
  ᭮   ਫ ,  ⭮, ᭮
   ᠬ  ஢ ॠ쭮. ꥪ ᮢ
  ।⠢ । ॠ쭮   த 
  ॠ樨.
        ᬮਬ  ணࠬ  窨 ७ ᫥
  ⭮襭  ᠬ:
     - ⭮襭 ᫥,
     - ⭮襭 ਭ,
     - ⭮襭 ᯮ짮 
     - ணࠬ஢ ⭮襭.
   ᬮ७  ⭮襭  ।,   
   㧫 ⮬  ஥ ⥬.  $$12.4 ᫥
  ᢮⢠,      䥩 묨 
  ।⠢ ⨩.  ,  , ᨬ 
   ⠫쭮    쭠  ⪮ ।, 
  ᠬ   १ 䥩 뢠   ꥬ
  ଠ樨  ⠫쭮 .
      ભ,    ++  ⨯, ⮬ ᠬ 
   ⭮襭   ᯥ祭 ⥫쭮 প
   ஭ ࠭   饬 砥  ᪮ .

  12.2.1  ।⠢ ?

     ⥬ 뢠   :
  [1] ,  אַ ࠦ   ਫ,
      .. ,  ᯮ  짮⥫ 
      ᠭ ᢮    襭;
      
  [2] ,   த⮬ ᠬ ॠ樨, ..
      ࠦ , ᯮ㥬 ࠧࠡ稪  ணࠬ⠬
       ᠭ ᯮᮡ ॠ樨.
    ᮢ,  த⠬ ॠ樨, 
  ।⠢   ॠ쭮 . ਬ, ணࠬ 
    ⥬  訬 ⠬
   ஫ ᮢ, ।⠢  ਫ.  ࠦ
   䠪,  ⥬  ᬠਢ  ᪮쪨 祪
  ७,  ,     ⠫ ॠ樨, 
  㣮   ⨥  ਫ. 
  ஥஢ ⥬  ᮤঠ , 
    ᬠਢ ⥬  ᪨
  ࠧ 祪 ७. ਢ ਬ:
    [1] , ।⠢騥 짮⥫᪨  (ਬ,
         設  㧮),
    [2] , ।⠢騥 饭 짮⥫᪨ ⨩
        (騥 ।⢠),
    [3] , ।⠢騥   (ਬ, 
        ࠢ ),
    [4] , ।⠢騥 ⥬  (ਬ,
        室 ⮪),
    [5] , ᯮ㥬  ॠ樨 㣨 ᮢ (ਬ,
        ᯨ᪨, ।, ஢騪) 
    [6] ஥ ⨯    ࠢ.
    ⥬ 祭 㤭 ࠭ ᪮ ࠧ
  ⨯ ࠧ ᮢ  ন ⠪ ࠧ 
  ࠧ묨 ஢ﬨ ࠪ樨.  ਢ  ᫥
  ।⠢  ஢ ࠪ樨:
    [1+2] ।⠢ 짮⥫᪮ ࠦ ⥬,
    [3+4] ।⠢ 設,  ன 㤥 ࠡ ⥬,
    [5+6] ।⠢ ஢ ( ஭ 몠 ணࠬ஢)
          ࠦ ॠ樨.
    ⥬, ⥬ 襥 ᫮ ஢ ࠪ樨 室
    ᠭ,  ⥬ 㤭 ।  ন  ஢
  ࠪ樨. ⬥⨬,  ⠪ ஢ ࠪ樨  אַ
  ᮮ⢥⢨  த   ࠧ ஥ 祫᪮
  ⥫. ਬ,  ᬠਢ   ꥪ,
  騩 
    [1] ⮬,
    [2] ,
    [3] ᮪  ௨祩,
    [4] , ⮫  ⥭;
    [5] .
   㤠 ࠭ ࠧ쭮 ।⠢  ஢ ࠪ樨,
   ন 楫⭮ ।⠢  . , ᫨
  ᬥ ,  ᫨. ਬ, ।
  "  ⮨  ᪮쪨  ⮢ 㣫த, 
  ᫮ ஢,  5000 ௨祩,     13
  ⮫" -  भ. - ࠪ⭮ த
  ணࠬ  ⢥ত  - ᫮ ணࠬ
  ⥬   ᥣ ਭ  ᫨.
       ஥஢ 뤥 ⨩   ਫ
       ⮩ 堭᪮ 樥. 筮
    ॡ 让 ஭⥫쭮. ⨬,  ᠬ
    ਫ  ࠪﬨ. ਬ, 
  த   "⥫騪", ""  "㤭".
      ,  ⪨, 묨  
  筮, ⮡ ஢   ⭮襭  ன
  ⥬.  ॠ  ࠦ  (ਬ, ,
  ᮡ 䠭⨪) 㦠 筨 ⨩,  न쭮
  ८ࠧ  ॢ   . , ࠭  
  () ᮢᥬ  室  孮  ⮫, 
   ᮧ  楫 ॠ ⨥ "⮫" ,
      ᯫ  ᠬ ⤠ ⭮襭 
  ᯮᮡ  १樨 ⥦   .
      뭥 ⠪ ᯮ浪  ᥡ  ࠭.

   ஢ ॠ쭮   ୮ ᫥ ⮬,
    ,   ᯮ짮 ॠ쭮  砫  ஥஢,
  筨 孮   类,  㤥ন, 
   ணࠬ஢ ஧   ᯮᮡ
   ᢮ ᮡ⢥ ணࠬ.
       ।: 窠 筮 㤭 "室"
  ,  ᪮  ८  -
  ⭮⥩.  筮 室 ⠯,    ⭮襭
  ᫥   ᪮஫쭮 .  㦥
   ஡, 易  ᫮, 䥪⨢ 
  ᭮ 祭 ணࠬ.    ⤥ ⠫
  ᫥ ।⠢ ⤥ ᮬ,    
  ⭮襭  ᠬ ᫥ ।⠢  ⭮襭
  ᫥. ࠩ  뢠,  楫 ஥ - ᬮ஢
  ⥬  室騬 ஢ ⠫樨  室騬 ஢
  ࠪ樨.   ⥬  ஬  ⮩ 
  魮    .


   12.2.2 娨 ᮢ

  ᬮਬ ஢ ࠭ᯮ⭮ ⮪  த, 楫 ண
  筮 筮 । ६, ॡ饥, ⮡ ਩ 騥
  ।⢠ ⨣ 㭪 祭. 祢,   
  ।⠢   㧮 設, 設 ᪮ன ,
  ᥢ   楩᪨ 設, ⮡ᮢ  ..
  ᪮ 类 ⨥ ॠ쭮    ஢,
   ᮥ  ᫥묨 ﬨ  㣨 ﬨ,
   ⠪ ⭮襭  ᫥.  ࠧࠢ  
     ,     ﭨ   ⤥쭮
  ⨥.   , ᫨  ࠦ ⭮襭 
  ﬨ,   ⭮ ।⠢ ᠬ . ⠪, 
  襩 ணࠬ 㦭   ।⠢ ⨩,  ⮣
  筮.  㦭 ᯮᮡ ।⠢ ⭮襭  ᠬ.
  ᫥   ᯮᮡ אַ ।⠢
  ᪨ ⭮襭.  襬 ਬ, ,  ᥩ ,
  竨  ਩ ।⢠ ᯥ樠묨 騬 ।⢠
  ,  ⮣, 뤥  ।⢠, ।⠢ 묨 
  㧮묨 設.   ᮢ ਮ५  ⠪ :
       饥 ।⢮
    設  ਩ ।⢮ 㧮 設
  楩᪠ 設 設 ᪮ன  ୠ 設
  設  뤢 ⭨楩
    Emergency ।⠢  ଠ, 室 
  ஢ ਩  ।, ਬ: ਩
  設    ࠢ ,  
  ਮ  ४⪠, 室  ஫ ᯥ
   ..
   ++    ⠪:

      class Vehicle { /*...*/ };
      class Emergency { /*   */ };
      class Car : public Vehicle { /*...*/ };
      class Truck : public Vehicle { /*...*/ };
      class Police_car : public Car , public Emergency {
          //...
      };
      class Ambulance : public Car , public Emergency {
          //...
      };
      class Fire_engine : public Truck , Emergency {
          //...
      };
      class Hook_and_ladder : public Fire_engine {
          //...
      };

  ᫥ -  ⭮襭 ᠬ ᮪ 浪, ஥ אַ
  ।⠢  ++  ᯮ २⢥  ࠭
  ⠯ ஥஢.   ஡ 롮: ᯮ짮
  ᫥  ।⠢ ⭮襭  । 
  ਭ. ᬮਬ 㣮 ।  ਩
  ।⢠: 饥 ।⢮ ⠥ ਩, ᫨ 
   ᮮ⢥騩 ᢥ⮢ ᨣ.   
   ᮢ,   Emergency  童 
  Vehicle:
        饥 ।⢮ (Vehicle {eptr})
    設 (Car) 㧮 設 (Truck)
  楩᪠ 設 (Police_car) 設 ᪮ன  (Ambulance)
    ୠ 設 (Fire_engine)
    設  뤢 ⭨楩 (Hook_and_ladder)
    Emergency ᯮ   童   ,
   ।⠢ ਩ 騥 ।⢠:

       class Emergency { /*...*/ };
       class Vehicle { public: Emergency* eptr;  /*...*/ };
       class Car : public Vehicle { /*...*/ };
       class Truck : public Vehicle { /*...*/ };
       class Police_car : public Car { /*...*/ };
       class Ambulance : public Car { /*...*/ };
       class Fire_engine : public Truck { /*...*/ };
       class Hook_and_ladder : public Fire_engine { /*...*/ };

   饥 ।⢮ ⠥ ਩, ᫨ Vehicle::eptr
   ࠢ . ""   㧮 設 樠
  Vehicle::eptr ࠢ ,   㣨 Vehicle::eptr  
  ⠭  㫥 祭, ਬ:

       Car::Car()     //  Car
       {
          eptr = 0;
       }
       Police_car::Police_car()   //  Police_car
       {
          eptr = new Emergency;
       }

   ।  ८ࠧ ਩ ।⢠ 
  筮  :

       void f(Vehicle* p)
       {
          delete p->eptr;
          p->eptr = 0;   //   ਩ 饣 ।⢠

          //...

          p->eptr = new Emergency;   //   ᭮
       }

     ਠ 娨 ᮢ ?  饬 砥 ⢥ ⠪:
  "襩  ணࠬ,   ।⢥ ࠦ
  ॠ ". 묨 ᫮,  롮    ६
   襩 "ॠ쭮",   ⮬  ࠭祭,
  뢠 ॡﬨ   䥪⨢. ⮬,
  ᬮ   ८ࠧ 筮 饣 ।⢠ 
  ਩, ஥ 襭 ।⠢ ࠪ.
   設  設 ᪮ன  - 
  騥 ।⢠ ᯥ樠쭮 祭  ᯥ樠쭮
  ⮢ ᮭ,    ࠢ 
  ᯥ, ॡ ᯥ樠쭮 㤮  裡. 
   砥,  ਭ  ਩ 騬 ।⢠ -
    ⨥, ஥  襭 ஫ ⨯ 
  ਬ ࠧ ணࠬ ।   אַ
  ।⠢  ணࠬ. ᫨   ஢ ,  ன
  祭  ।  ⮫ ।,
  ᪠, ,  ன  ࠭ᯮ ਮ᪨ ᯮ
   ⠢ ᯥ樠쭮 ᮭ   ந⢨,  
  ᯥ稢   ⨢ ਥ, ⮣  
   室騬  㣮 ᯮᮡ ஢ ⥬.
       ,  ⠥ ਬ ஢  ࠭ᯮ
  ,   ᪠,    ஥஢
   ﭭ   롮  ᫥
   ਭ.  ਬ   $$12.2.5, 
  뢠 ᢨ⮪ (scrollbar) - ப稢 ଠ樨  .

  12.2.3 ᨬ  ࠬ 娨 ᮢ.

  ⢥, ந    ᢮  ᮢ.
  ࠧ ० 뢠,  ⭮ ⠪  
  ࠢ.

      ࠧ ⠪ ᯮᮡ: "㬠⢨ ᫥,
       ᢮ ⥩."

  ᫨  ᮤন 㠫 㭪, ந  
   ᢮ ᬮ७ , ॠ뢠   権 ⮩
  㭪樨  ࠧ,   ८।  ந
  . ᫨ 童   ᠬ 뢠   㠫
  㭪権 ந , ⮣ ॠ  
    ॠ権  ந ᮢ. 筮 ⠪ , ᫨
   ᯮ 饭 童,  ॠ 㤥  
  ந ᮢ. ᬮਬ ।:

       class B {
           //...
       protected:
           int a;
       public:
           virtual int f();
           int g() { int x = f(); return x-a; }
       };

   १ ࠡ g()? ⢥ ⢥   ।
  f()  ஬ ந .  ਢ ਠ, 
  ஬ g() 㤥  1:

        class D1 : public B {
            int f() { return a+1; }
        };

    ᫥饬 । g() ⠥ "Hello, World"  ୥ 0:

        class D1 : public {
            int f() { cout<<"Hello, World\n"; return a; }
        };

       ਬ     ⮢, 易
   㠫묨 㭪ﬨ.    ᪠,  
  㯮,  ணࠬ    祣 .
     ⮬,  㠫쭠 㭪  
  䥩   ᮬ,     㤥,  ᥩ
  , ᯮ짮  ଠ樨   ந .
  ⥫쭮,  ⠪   ꥪ  ,
  ⮡  쭥襬  ணࠬ, 祣     ந
  .
  直 ,  ८। ந 㭪, 
  ॠ ਠ ⮩ 㭪樨. ਬ, 㠫쭠 㭪
  rotate()   Shape 頥  䨣,  㭪樨
  rotate()  ந ᮢ, ⠪,  Circle  Triangle,
    ꥪ ᮮ⢥ ⨯,  㤥 襭
  ᭮    Shape.     B  
  ந ᮢ D1  D2  㫨஢  ,
  ⮬ ਢ ਬ   ࠧ㬭.  ஥
     ᫥ 㤥 ᠭ 
  ⢨ 㠫 㭪権.
           ଠ쭮 ᨬ  
  (  ।) ந ᮢ? ⢥, ⢥,
    楫 ணࠬ. ᫨ 楫 ⮨  ⮬, ⮡
  ஢   直 譨 ﭨ , ⥬ ᠬ, ,
     ᥡ । ࠧ,   
  㠫 㭪権  饭 童. ᫨ 楫 ⮨  ⮬,
  ⮡ ࠧࠡ ,   ᫥騥 ணࠬ
  (  ᠬ १ ) ᬮ ࠨ ᢮ ணࠬ,  
  㠫 㭪樨  ।  ᯮᮡ 襭,
   饭 童      ॠ樨.
         ⢥ ਬ ᬮਬ ⮩ 蠡 ⨯, ।騩
  :

        template<class T> class buffer {
           // ...
           void put(T);
           T get();
        };

  ᫨ ॠ  ९  饭  ⮬ , "ﭠ"
   ᠬ ,  ਬ 㤥 ࠭祭.  ᫨ 㭪樨 put()
   get()   㠫 㭪 overflow()  underflow()
  ᮮ⢥⢥,  짮⥫ , 㤮⢮ ᢮
  㦤, ᮧ  ࠧ ⨯:

       template<class T> class buffer {
          //...
          virtual int overflow(T);
          virtual int underflow();
          void put(T);   // 맢 overflow(T),   
          T get();   // 맢 underflow(T),   
       };

       template<class T> class circular_buffer : public buffer<T> {
           //...
           int overflow(T);  // ३  砫 , ᫨  
           int underflow();
       };

       template<class T> class expanding_buffer : public buffer<T> {
           //...
           int overflow(T);   // 㢥 ࠧ , ᫨  
           int underflow();
       };

     ⮤ ᯮ짮  ⥪ ⮪ -뢮
    ($$10.5.3).

  12.2.4 ⭮襭 ਭ

  ᫨ ᯮ ⭮襭 ਭ,    ᭮
  ᯮᮡ ।⠢ ꥪ  X:
  [1]  童 ⨯ X.
  [2]  童 ⨯ X*  X&.
  ᫨ 祭 㪠⥫  㤥   
  䥪⨢  ,  ᯮᮡ :

       class X {
           //...
       public:
           X(int);
           //...
       };

       class C {
            X a;
            X* p;
       public:
            C(int i, int j) : a(i), p(new X(j)) { }
            ~C()  { delete p; }
       };

   ⠪  ।⥫쭥 ।⢥ 童⢮ ꥪ,
   X::a  ਬ , ⮬    
  ६,   ⢠  ᨬ.  ⠪
   $$12.4  $$13.9.
       ᮡ, ᯮ騩 㪠⥫, ᫥ ਬ  
  ,  室 ࠨ 㪠⥫ 
  "ꥪ-"  祭  "ꥪ-". ਬ:

       class C2 {
           X* p;
       public:
           C(int i) : p(new X(i))  { }
           ~C() { delete p; }

           X* change(X* q)
           {
              X* t = p;
              p = q;
              return t;
           }
       };

   ⨯ 㪠⥫  ⠪ ᯮ짮, ⮡  
  । "ꥪ-"  ⢥ ࠬ:

       class C3 {
         X* p;
       public:
          C(X* q) : p(q) {  }
          // ...
       }

   ꥪ⠬ ᮤঠ 㪠⥫  㣨 ꥪ,  ᮧ
  ,  筮 뢠 " ꥪ⮢".  ୠ⨢
   ᯮ⥫ ᯮᮡ ஢  ⭮襭  娨
  ᮢ.  뫮   ਬ ਩ 饣
  ।⢠  $$12.2.2,   쭮 ⮭  ஥஢:
  ।⠢  ᢮⢮      
    童 . ॡ  ८। ᫥ 
  㪠,   ਠ .  ᫨  
   ।⠢ ஥ ᢮⢮   ࠧ
  ⨯,   ⠭  ஬ ਠ. ਬ:

       class XX : public X { /*...*/ };

       class XXX : public X { /*...*/ };

       void f()
       {
          C3* p1 = new C3(new X);     // C3 "ᮤন"  X
          C3* p2 = new C3(new XX);    // C3 "ᮤন"  XX
          C3* p3 = new C3(new XXX);   // C3 "ᮤন"  XXX
          //...
       }

  ਢ ।  ᬮ஢    ந
   C3  X,    C3, 饣 童 ⨯ X, ᪮
  室 㪠뢠  ⨯ 童.    ᮢ 
  㠫묨 㭪ﬨ, ⠪, ਬ,  Shape ($$1.1.2.5), 
    ࠪ⭮ ⢠ ($$13.3).
      ⨬,  뫪  ਬ  饭 ᮢ,
  ᯮ 童-㪠⥫, ᫨  祭  ꥪ-
  뫪 ஥ ⮫쪮   ꥪ, ਬ:

        class C4 {
            X&  r;
        public:
            C(X& q) : r(q) { }
            // ...
         };

  12.2.5 ਭ  ᫥

  뢠 ᫮  ⭮襭 ᫥,  祣
  㤨⥫쭮  ⮬,    ࠢ쭮   ᯮ
  ᢥ . ᫨  D ᠭ  騩 ந 
   B,   ,  D  B:

       class B { /* ... */ ;
       class D : public B  /* ... */ }; // D  B

     㫨஢ ⠪: ᫥ - 
  ⭮襭 "", ,  筮  ᮢ D  B, ᫥
  -  ⭮襭 D  B.  ⫨稥  ⮣, ᫨  D
  ᮤন  ⢥ 童 㣮  B,  , 
  D "" B:

       class D {  // D  B
         // ...
       public:
          B b;
         // ...
       };

  묨 ᫮, ਭ -  ⭮襭 "" 
   ᮢ D  B : D ᮤন B.
         B  D,  롨  ᫥ 
  ਭ? ᬮਬ  ᠬ  .窨 筮
  訢: 㤥  訬 襭 ᤥ  ᠬ
  ந   .  宥 襭, ᪮
  ᠬ  "" , ᠬ "" .  
   ⮬ , ᬮॢ,   ᠬ ""  
   ஢. ᪮  ।⠢  
  ( ᫨     ணࠬ,  ன  ᠬ
     ஬), ᫥ ᯮ짮 ਭ, 
   ᫥.  "    ..?" 뢠
  㤨⥫쭮    ᮬ⥫ .  ᥣ,
    ࠣ 㫮 魮 ணࠬ஢.
  ᫨    뫮 ⠪   ।⠢,  ᠬ 
  ,  뫮     ਢ 訡 ⨯ ⮩,
   ᠬ ।  ந   . ,
  ⠪ 訡 筮 , ᮡ  , 
  ⠥ ᫥   堭  ⠭
  権 몠 ணࠬ஢. ᬮ  㤮⢮ 
  筮 ,  ।⠢ ᫥, 
   ᯮ짮 ⮫쪮  ࠦ  ⭮襭,
   ⪮ ।  ஥. ᬮਬ ।:

       class B {
       public:
           virtual void f();
           void g();
       };

       class D1 {      // D1 ᮤন B
       public:
           B b;
           void f();   //  ८। b.f()
       };

       void h1(D1* pd)
       {
          B* pb = pd;  // 訡:  ८ࠧ D1*  B*
          pb = &pd->b;
          pb->q();     // 맮 B::q
          pd->q();     // 訡: D1   童 q()
          pd->b.q();
          pb->f();     // 맮 B::f ( D1::f  ८।)
          pd->f();     // 맮 D1::f
       }

   ,   ⮬ ਬ   ८ࠧ
       ⮢,   , ᮤঠ騩 
  ⢥ 童 㣮 ,  ८। 㠫
  㭪樨 ⮣ 童.   ⫨稥  ਬ, ਢ
  :

       class D2 : public B {    // D2  B
       public:
           void f();            // ८। B::f()
       };

       void h2(D2* pd)
       {
          B* pb = pd;  // ଠ쭮: D2*  ८ࠧ  B*
          pb->q();     // 맮 B::q
          pd->q();     // 맮 B::q
          pb->f();     // 맮 㠫쭮 㭪樨: 饭  D2::f
          pd->f();     // 맮 D2::f
        }

  ⢮ , த஢  ਬ  ᮬ D2, 
  ࠢ    ਬ  ᮬ D1,  稭, 
  ன ⠪ ᫥ 㯮ॡ.  ᫥ ,
    ।   㤮⢮   
  襩 ᨬ  B  D2 (. $$12.2.3).  ⭮,
      ८ࠧ D2  B. ᫨ ⮫쪮 ⠪
  ८ࠧ  ⭮  ᥬ⨪  ᮢ, ᫥
   ᠭ ந   饩 . ᫨ 
  ।⠢ । ⨥,  ᫥ ᯮ
   ⭮襭 "",  ⠪ ८ࠧ 筮  ࠧ ,
   㦭.
        , 뢠 ⠪ 樨,  ⥫쭮
   ᫥,   ᪠ ८ࠧ. ᬮਬ
    cfield (controled field - ࠢ塞 ), ,
   ᥣ 祣,   ஫஢  ⠤
  믮   㣮  field.    
  ᮢ襭 ࠢ ।  cfield  ந 
   field:

         class cfield : public field {
            // ...
         };

   ࠦ  䠪,  cfield, ⢨⥫쭮,   field,
  頥  㭪樨,  ᯮ 童  field 
  cfield, ,  ᠬ ,    cfield
  ८। 㠫 㭪樨  field.    ⮬,
   ८ࠧ cfield*  field*, 饥  ।
   cfield,    ஫ 㯠  field:

       void q(cfield* p)
       {
           *p = "asdf";   // 饭  field ஫
                          // 㭪樥 ᢠ cfield:
                          // p->cfield::operator=("asdf")

           field* q = p;  //  ८ࠧ cfield*  field*
           *q = "asdf";   // ਥ堫! ஫ 
       }

   뫮  ।  cfield ⠪, ⮡ field   童,
   ⮣ cfield   ८। 㠫 㭪樨 field.
  訬 襭  㤥 ᯮ짮 ᫥  ᯥ䨪樥
  private (⭮ ᫥):

       class cfield : private field { /* ... */ }

   樨 ஥஢, ᫨  뢠 ( ) 
  ८।, ⭮ ᫥ ⭮ ਭ.
   ⮬ 砥 ਬ ⮤,  ஬  ।
   饩   ந  ࠪ⭮   
   䥩,  ⠪ ।   ⭮ ᫥ 
  ⭮ , 饣 ॠ ($$13.3). ᪮
  ᫥, ᯮ㥬  ⭮, 
  ᯥ䨪 ॠ樨,    ࠦ  ⨯ ந ,
     뢠 "᫥  ॠ樨",  
   ⮬  ᫥  饩 ,  ᫥
  䥩    ⨬  ८ࠧ 
   ⨯. ᫥ ᫥  뢠 ।
  ⨯  "䥩 ᫥".
        쭥襣 㦤  롮 ᫥
   ਭ ᬮਬ,  ।⠢  
  ᪮ ⥬ ᢨ⮪ (  ப稢  
  ଠ樨),   ਢ易 ᢨ⮪    ࠭. ॡ
  ᢨ⪨  : ਧ⠫  ⨪.  
  ।⠢    ⨯ horizontal_scrollbar 
  vertical_scrollbar     ⨯ scrollbar, 
   㬥, ।騩,  ᯮ ⨪
   ਧ⠫. ࢮ 襭 ।,   
  ⨩ ⨯, 騩  ᢨ⮪ - scrollbar,   ⨯
    ᮬ   । ᢨ⪮. ஥
  襭 । ⥫ 㬥  ⨯ scrollbar 
  稥 祭,   ᢨ⪠. ਬ, ⠪:

        enum orientation { horizontal, vertical };

      ⮫쪮  ⠭    襭, ।
  ꥬ ,  ਤ   ⥬. ⨬, 
  ⮬ ਬ  ॡ  ᢨ⪨ 쥣 . 砫
  ।,    ᢨ⪨ ⮫쪮   (
  类   ⮫쪮  ७),   ⮬ ਬ,
      㣨,  ७,  
    ९஥஢. ਬ,  
   ᯮ짮 "ࠢ " (⨯ )  ᢨ⪮
   .     ப  ࠧ
  ࠢ  ᨬ  ⮣,     
   짮⥫. ⨥  । 孥 窨 
  뢠 "ப稢 ", ⨥  ।  ⮫ -
  "ப稢 ", ⨥   孥 㣫 -
  "ப稢   ".    
  祬- ,    ᬠਢ  筥 
  ᢨ⪠, ஥ ᮡ 室   ⥩ ਫ,
   易   묨 ⥪⠬,    ᫮
  ଠ樥.
         ࠢ饩   ணࠬ, ᯮ饩
     ᢨ⪮, ॡ    , 
   㦭  ணࠬ, ࠡ  묨 ᢨ⪠:
   ᢨ⮪
  ਧ⠫_ᢨ⮪ ⨪_ᢨ⮪ ࠢ_
   ⥫쭠 ஭ "᪮ 襭".
       ਥ樨 ᢨ⪠  ⢥ ࠬ ਢ 
    ⨯  ꥪ ᢨ⪠  ᯮ짮 ४⥫
   ⥫ 㭪権-童 ᢨ⪠. 묨 ᫮, ।  筠
  : ࠧ  ᯥ  ⥬  
  ।  ॠ   ୮  ணࠬ.
  ࢮ 襭 㢥稢 ꥬ ᪨ ஢ப  ꥬ
  ଠ樨,  ன  ࠡ ࠧ ᯮ⥫
  ।⢠. ஥ 襭 ⪫뢠 ஢ન  ⠤ 믮
   ࠧ蠥  ⥫ ⤥ 㭪権,   
   ⥬,   ।⠢  窨 ७
  ᪮ ஫  ᯮ⥫ ।.  設⢥
  砥, ।⥫쭥 ࢮ 襭.
       ⥫쭮 ஭ 襭   ⨯ ᢨ⪠  ,
    । ଠ   㦭  ᢨ⪠ 㣮
  㭪樨:

       void helper(orientation oo)
       {
          //...
          p = new scrollbar(oo);
          //...
       }

       void me()
       {
           helper(horizontal);
       }

   室   ⠤ 믮  ७ந ᢨ⮪
    ਥ.    祭   ਬ  ᢨ⪠,
      ⢥  宦 ਬ.   ⮬,
   ᥣ   । 롮,    .
        ᬮਬ  ਢ易 ᢨ⮪  . ᫨ 
  window_with_scrollbar (__ᢨ⪮)  ,  
  window  scrollbar,  稬 :

       class window_with_scrollbar
       : public window, public scrollbar {
           // ...
       };

     ꥪ ⨯ window_with_scrollbar 㯠
    window,   scrollbar,    ॡ 襭
  ᯮ짮 ⮫쪮 ⢥ ⨯ scrollbar.
      ᫨,  㣮 ஭,  window_with_scrollbar ꥪ⮬
  ⨯ window,   scrollbar,  稬 ⠪ ।:

      class window_with_scrollbar : public window {
        // ...
        scrollbar* sb;
      public:
          window_with_scrollbar(scrollbar* p, /* ... */)
          : window(/* ... */), sb(p)
          {
             // ...
          }
        // ...
       };

     ᯮ짮 襭  ᢨ⪠  ⨯. ।
  ᠬ ᢨ⪠  ⢥ ࠬ   (window) 
   ⨯  ᢨ⪠. ᫨ ॡ, ⮡ ꥪ ⨯
  window_with_scrollbar ⢮  scrollbar,  
   ८ࠧ:

      window_with_scrollbar :: operator scrollbar&()
      {
         return *sb;
      }


  12.2.6 ⭮襭 ᯮ짮

   ⠢   ஥  室 ,
      ᯮᮡ ᯮ  .
   ⭮襭 ᮢ
   ++ ࠦ .   ᯮ짮 ⮫쪮 
  ,  - ।,   ⠪   ணࠬ
   ++,  ᮤঠ  ᯨ᮪  ᯮ㥬 .
   祭 ⠪ ᯨ᪠ 室
  ᯮ⥫ ।⢠ (,   ⢨, ⥫쭮
  ⥭).  ᫥騬 ࠧ ஢  ᯮᮡ,
      X  ᯮ짮  Y:
    - X ᯮ  Y
    - X ᯮ Y
        - X 뢠 㭪-童 Y
        - X ⠥ 童 Y
        - X   童 Y
    - X ᮧ Y
        - X ࠧ頥 auto  static ६  Y
        - X ᮧ Y   new
        - X ᯮ ࠧ Y
   ⭥᫨ ᯮ짮 ࠧ ꥪ   ᮧ, ᪮
   ⮣ ॡ   । .  㣮
  ஭,  뤥  ⤥쭮 ⭮襭 ᯮ짮  Y,
  ᪮, 㪠뢠   ᠭ Y*   ᠭ
  譥 㭪樨,    㦤  㯥  । Y:

        class Y;  // Y -  
        Y* p;
        extern Y f(const Y&);

   ⤥ ᮧ Y   new   ᠭ
  ६, ᪮  ⠪ ॠ ++,  ன
   ᮧ Y   new 易⥫쭮 
  ࠧ Y.    ⢥  ࠭祭  ᨬ⥩
   ஥  ᢥ   ࠭樨 ᫥ ᥭ .
        ++  ॡ, ⮡ ᮧ⥫ ᮢ 筮 ।,
       㤥 ᯮ짮.   稭 ⮣
  祭  ⮬,  ᠬ     ⮫ 讣
  ⢠ 㣨 ᮢ,   ਤ 襣  ணࠬ
  㦭 ᮪饭 ଠ  ᯨ᪠ ᯮ㥬 ᮢ, ਬ,
     #include. 㣠 稭  ⮬,  䨪
   ᨬ⥩ ,  ⭮,   ᨬ⥩
    易 몠 ணࠬ஢. , 楫
  ࠧࠡ稪, ணࠬ  ᯮ⥫쭮 ।⢠ । ,
    ᫥ ᬠਢ ⭮襭 ᯮ짮. , ,
   ᨬ ।⠢ 訩 ,   
  ᯥ䨪 ॠ樨 몠.

  12.2.7 ⭮襭  

      㦤 ⮫쪮 ,   樨 㯮,
  ᫨   㦤 蠣  ࠧ ணࠬ
  ᯥ祭 ($$11.3.3.2),   뫨  ஬ , ꥪ 
  ࠪ᪨   㯮.   :  ++
  ,   㭪  ꥪ,  ᭮ ⨥
  ࣠樨 ⥬.
        뢠  ᥡ  ᯥ䨪 ॠ樨,
  ࠢ  "吝묨" ਥ ணࠬ஢,   
  㦤  .    ६ ꥪ 設⢠ ᮢ
  ᠬ ࠧ ॣ   ᯮ ⠪ ᯮᮡ,
    筮  .  ꥪ    
  ᮢ㯭 㣨  ꥪ⮢ (  뢠 童),
    ,  ᢮ ।,  㪠⥫ﬨ  뫪
   㣨 ꥪ. ⮬ ⤥ ꥪ  ᬠਢ 
  ७ ॢ ꥪ⮢,   室騥   ꥪ  "
  ꥪ⮢",    ᮢ, ᬮ७  $$12.2.4.
  ᬮਬ  ⢥ ਬ  ப  $$7.6:

       class String {
           int sz;
           char* p;
       public:
           String(const char* q);
           ~String();
           //...
       };

  ꥪ ⨯ String  ࠧ ⠪:

  12.2.7.1 ਠ

  祭 童  ꥪ⮢, 㯭   童 ,
  뢠 ﭨ ꥪ (  祭 ꥪ).
    ஥  - : ਢ ꥪ  
  । ﭨ (樠), ࠭  ।
  ﭨ    믮   ࠧ 権,
     ࠡ 㭨⮦ ꥪ  直 ᫥⢨. ⢮,
  ஥  ﭨ ꥪ  ।, 뢠
  ਠ⮬.
       ⮬ 祭 樠樨 -   祭,
    믮 ਠ ꥪ.   樨 
  ।,  ਠ    । 믮
  樨   ࠭ ᫥ 樨.   ࠡ
   蠥 ਠ, 㭨⮦ ꥪ. ਬ,
   String::String(const char*) ࠭,
   p 㪠뢠  ᨢ ,  ࠩ , sz ⮢, 祬
  sz  ᫥ 祭  v[sz-1]==0.  ப 
      ⢥ত.
       ஥஢  ॡ 讥 ⢮, ⮡
  ᤥ ॠ  筮 ⮩  ᪠饩
  稥  ਠ⮢,  ᫮ . 
  ॡ, ⮡   ਠ, 㤭 । 
  ਠ,  ⥭   뢠 ⪨ ࠭祭
   ⢨ ࠧࠡ稪    䥪⨢ ॠ樨.
   "ਠ"   ணࠬ ࠣ,
  믮 ,  ஢ ﭨ ꥪ.  
    ண   ⥬᪮ । ਠ,  
        室騬.  
   ਠ⮬  ࠪ᪠,  , 筮 ,
    ஢ઠ ﭨ ꥪ.
      ⨥ ਠ   ࠡ ,   ,
  饭 ।-  -᫮,  砥   
    ࠪ ⨯   䨪樨 ணࠬ 
  ᫥ 20 .    ᭮ ।⮬ ⫠  C++.
      筮,  祭 ࠡ 㭪樨-童 ਠ  ࠭.
  ⮬ 㭪樨,   뢠   , 
  ਠ  ,   室  騩 䥩 .
   㭪樨   묨  饭묨.
       ࠧ ਠ  ணࠬ  ++? ⮥ 襭 -
  । 㭪, ஢ ਠ,  ⠢ 맮 ⮩
  㭪樨  騥 樨. ਬ:

       class String {
           int sz;
           int* p;
       public:
           class Range {};
           class Invariant {};

           void check();

           String(const char* q);
           ~String();
           char& operator[](int i);
           int size() { return sz; }
           //...
       };

       void String::check()
       {
           if (p==0 || sz<0 || TOO_LARGE<=sz || p[sz-1])
              throw Invariant;
       }

       char& String::operator[](int i)
       {
           check();                        // ஢ઠ  室
           if (i<0 || i<sz) throw Range;   // 
           check();                        // ஢ઠ  室
           return v[i];
       }

   ਠ ४᭮ ࠡ⠥   ᫮  ணࠬ.
    ⠪ ⮣   String ஢ઠ ਠ 㤥
     ६ . ⮬ ணࠬ 筮
  믮 ஢ ਠ ⮫쪮  ⫠:

       inline void String::check()
       {
           if (!NDEBUG)
               if (p==0 || sz<0 || TOO_LARGE<=sz || p[sz])
                   throw Invariant;
       }

   ࠫ  NDEBUG, ᪮  ம।, ஥
  ᯮ   楫  ⠭⭮ ம।
   assert(). ࠤ樮 NDEBUG ⠭  楫 㪠,
   ⫠ . ,  check()  ⠭, 
  ࠭஢,   ணࠬ  㤥 ᮧ,  ⠭
  NDEBUG  㤥 ⠭  祭, 饥 ⫠.
    蠡 ⨯ Assert()    ॣ
  ⢥ত, ਬ:

       template<class T, class X> inline void Assert(T expr,X x)
       {
           if (!NDEBUG)
               if (!expr) throw x;
       }

  맮 ᮡ  x, ᫨ expr ,    ⪫稫
  ஢   NDEBUG. ᯮ짮 Assert()  ⠪:

       class Bad_f_arg { };

       void f(String& s, int i)
       {
           Assert(0<=i && i<s.size(),Bad_f_arg());
           //...
       }

   ⨯ Assert() ࠦ ப assert() 몠 .
  ᫨ i  室  ॡ㥬 ,  ᮡ
   Bad_f_arg.
        ⤥쭮 ⠭  ⠭   ஢
   ⢥ত  ਠ - 类 . ᫨ 
  室 ஢ ਠ   ꥪ,  ।
  ந ,  ஬ ஢ ﬨ  ,  
  ஢ન, . .8  $$13.11.
      ᮢ   ᫮묨 ﬨ 室  ஢ન 
   ⥫, ⮬ ஢ન  ⠢ ⮫쪮  ""
  㤭 㦨 訡. 筮  ⠢  ࠩ
   ᪮쪮 ஢ப   祭  ⫠ ணࠬ.
    ᫮ ᠬ 䠪 । ਠ⮢  ᯮ짮
    ⫠  業   祭 ࠢ쭮
  ணࠬ ,   ,  , ।⠢
  ᠬ,  ॣ묨  ண ।묨.   ⮬, 
    ᮧ ਠ,  ᬠਢ   㣮
  窨 ७   । 筮  ணࠬ.
    㣮 㢥稢 ⭮ 㦥 訡, ⨢稩
   ᬮ஢.
   㪠  $$11.3.3.5,   ᠬ 騥  ८ࠧ
  娨 ᮢ   ࠧ      뤥
  饩   ᮢ   .    
  த㬠 ਠ  ᪠  ⠪
  ८ࠧ. ᫨, ࠢ ਠ  ணࠬ 権,
   㦨,  設⢮ ஢ப ਠ 譨,
     ᮧ५  ࠧ.  ⮬ 砥 ⢮ 権
    ⮫쪮   ﭨ ꥪ. ⭮,
   ᮧ५  ᫨ﭨ, ᫨   室 ਠ, 
   ஬ ࠧ稨   ॠ樨.

  12.2.7.2 

  ⬥⨬,   ++ ,   ⤥ ꥪ,  ⮩
  楩,    㫨஢ (祭  ).
  ਬ:

       class list {
           list* next;
       public:
           int on(list*);
       };

       int list::on(list* p)
       {
           list* q = this;
           for(;;) {
               if (p == q) return 1;
               if (q == 0) return 0;
               q = q->next;
           }
       }

   饭  ⭮ 㪠⥫ list::next ⨬, ᪮
  list::on()    类 ꥪ  list,  
     뫪. ᫨  㤮,   ,
  ⪠   㯠 १ 㭪-童 
  ।⠢ 㣨 ꥪ⮢, ਬ:

       int list::on(list* p)
       {
           if (p == this) return  1;
           if (p == 0) return 0;
           return next->on(p);
       }

   ⥯  ॢ頥  ४,   ᨫ쭮
   믮 ணࠬ, ᫨ ⮫쪮 ࠭
   㬥 ⭮ ८ࠧ ४  .

  12.2.8 ணࠬ㥬 ⭮襭

    ணࠬ஢   אַ ন
   ⨥  ⮤ ஥஢. ᫨  ணࠬ஢
   ᯮᮡ אַ ।⠢ ⨥ ஥஢, ᫥
  ⠭ 㤮 ⮡ࠦ 権, ᯮ㥬  ஥,
   몮 樨. ਬ, ⮤ ஥஢ 
  ᯮ짮 ⨥ ஢, 饥,  猪
  ,   ।   A,  믮
      㪠⥫ p  ᮮ⢥騩 童  B,
   ஬  ।.  ++  ࠧ  אַ. ,
  ॠ ⮣  ⮫쪮   ++,   ।⠢
  ணࠬ ॠ樨:

       class A {
           B* p;
           //...
           void f();
           void ff();
       };

       class B {
           //...
           void f();
           void g();
           void h();
        };

   䠪,    A   㪠⥫ A::p,
  ࠦ  ᫥饩 :

       class A {
           B* p;      // ஢   p
           //...
           void f();
           void ff();
           void g() { p->g(); }  // ஢ q()
           void h() { p->h(); }  // ஢ h()
        };

   ணࠬ ᮢ襭 祢,   ந室,  
   蠥 ਭ樯 筮 ᮮ⢥⢨. 
  "ணࠬ㥬" ⭮襭 㤭 ࠧ  몠 ணࠬ஢,
   ⮬   㤭 ਬ ࠧ ᯮ⥫ ।⢠.
  ਬ, ⠪ ।⢮   ⫨ "஢"  B
   A   A::p   㣮 ᯮ짮 B*.
      -⠪ ᫥ ,   , 
  筮 ᮮ⢥⢨  ﬨ ஥  ﬨ
  몠 ணࠬ஢.   ।   ࠭,
   ஥ ⭮ ⮡ࠦ  ணࠬ,  頥
  ࠡ ணࠬ  ᯮ⥫ ।.
  樨 ८ࠧ ⨯  堭,   ண
   ।⠢  몥  ணࠬ㥬 ⭮襭,  :
   ८ࠧ X::operator Y() ࠭,  ,
   ⨬ ᯮ짮 Y,  ਬ  X.  
  ⭮襭   Y::Y(X). ⬥⨬,  
  ८ࠧ ⨯ (  ) ᪮॥ ᮧ  ꥪ,
  祬  ⨯ 饣 ꥪ.   ८ࠧ
   㭪樨 Y - 砥  ॡ  ਬ
  㭪樨, 饩 Y. ᪮  ਬ 権
  ८ࠧ ⨯  権, ।塞 ࠬ, 
  ਢ  ⭮,  ஠஢   ⤥쭮
    ஥.
     㡥,   ਬ 権 ८ࠧ ⨯
   ᮤন 横. ᫨  ,  ᫥ ,
   ன ⨯, 騥  横, ⠭ ᮢ⨬묨 
  樨. ਬ:

       class Big_int {
           //...
           friend Big_int operator+(Big_int,Big_int);
           //...
           operator Rational();
           //...
       };

       class Rational {
           //...
           friend Rational operator+(Rational,Rational);
           //...
           operator Big_int();
       };

   Rational  Big_int  ⠪  ,  
  뫮  㬠:

       void f(Rational r, Big_int i)
       {
           //...
           g(r+i);   // 訡, 筮:
                     //        operator+(r,Rational(i)) 
                     //        operator+(Big_int(r),i)
           g(r,Rational(i));  //  ࠧ襭 ।
           g(Big_int(r),i);   //  
       }

   뫮   ⠪ "" ८ࠧ, ᤥ
     묨. ਬ, ८ࠧ Big_int  ⨯
  Rational  뫮      㭪樨 make_Rational()
   樨 ८ࠧ, ⮣ ᫮  ਢ
  ਬ ࠧ蠫   g(BIg_int(r),i). ᫨  
  "" 権 ८ࠧ ⨯,  㦭 ८
  騥 ⮫     ८ࠧ ( 뫮
  ),    । ᪮쪨 ࠧ ᨩ
  ୮ 樨 ( 襬 砥 +).

  12.3 

   몥 ++  権,   ࠧ אַ  ணࠬ
  ⨥ , .. ⢠ 易 ᮢ. ᭮
  稭 ⮣  ⮬,  ⢮ ᮢ (  ᮮ⢥騬
  묨 㭪ﬨ  ..)  ᮥ   
  ᠬ ࠧ ਧ. ⢨  ।⠢  
  몥 㤭 ஢ ࠭  ଠ樥 (),
  ᯮ㥬  ,  ଠ樥 (), ।
    짮⥫.
   ,  । ⢮ 䥩ᮢ, ᯮ㥬
    ॠ樨,  ⢮ 䥩ᮢ, ।⠢塞
  짮⥫,   祥 ⠥ "ᯥ䨪 ॠ樨" 
      ⠫ ⥩ ⥬.   
   ⢨⥫쭮 ।⠢    ࠧࠡ稪.
  ணࠬ  ᬨ  ⥬ 䠪⮬,  ++  
  饣  ࠭⢠  , ⠪  
  室 "஢"   ⨩ ᮢ  
  ࠭樨, ..  ।,    ++  ࠭祭
   ⢨  .
        ᬮਬ  ,   ᮢ⭮ ᯮ짮
  㭪 f()  ६ v.  ᥣ  f  v 
   . , 直  ணࠬ , 
  ⠪ "७" ࠭⢠   ਢ   殢
   ⭮: -  筮 ᯮ짮  f  v
    祭  筮    f  v,
  אַ ᯮ "ᯥ䨪 ॠ樨"   ⥬ ᠬ 
  䥩 .    襭:
    [1]  ""  ꥪ⠬  㭪,  
        ⠭  짮⥫.
    [2] ꥪ  㭪樨,  ।祭  짮⥫,
            䠩 ணࠬ  ᪨ (static).
    [3]  ꥪ  㭪樨,  ।祭  짮⥫,
         , । ண   짮⥫.
  ࢮ 襭 ਬ⨢  筮 㤮  ᮧ⥫
  ணࠬ,   :

       //  ᯮ ᯥ䨪 ॠ樨 compX,
       // ᫨ ⮫쪮   ࠧࠡ稪 compX:
       extern void compX_f(T2*, const char*);
       extern T3 compX_v;
       // ...

     compX_f  compX_v    ਢ  ,  
   ,  짮⥫   諥  ᯮ짮
    אַ,  ⢥,  짮⥫   砥 
   諥,   몮 堭  ।࠭
   ⭮ ,     ᫠. २⢮ ⮣
  襭  ⮬,   ਬ ᥣ   ⭮.   
  ६  ᨢ,   ᫮  ⥪.
     ஥ 襭  ,   㭨ᠫ쭮:

       // ᯥ䨪 ॠ樨 compX:
       static void compX_f(T2* a1, const char *a2) { /* ... */ }
       static T3 compX_v;
       // ...

  㤭 ࠭஢,  ଠ, ᯮ㥬   
  , 㤥 㯭 ⮫쪮    ࠭樨,
  ᪮ 樨, ࠡ騥  ⮩ ଠ樥, 
   㯭 .  襭   ⮬  ਢ 
  ஬ 栬 ࠭樨,    ⫠稪  ++
   ࣠    ᪨ 㭪権  ६.
     ६  襭    ⨬쭮  
  ⮢.
   襭  ᬠਢ  ଠ  饭
   :

        class compX_details {  // ᯥ䨪 ॠ樨 compX
        public:
           static void f(T2*, const char*);
           static T3 v;
           // ...
       };

  ᠭ compX_details 㤥 ᯮ짮 ⮫쪮 ᮧ⥫ ,
  ⠫      ᢮ ணࠬ.
        筮    ᮢ,  ।祭
   饣 짮. ᫨   ⮦ ⠭ ⮫쪮 
  쭮 ᯮ짮,   ⠪  "" 
  ᮢ, ᮤঠ ᯥ䨪 ॠ樨:

       class compX_details { // ᯥ䨪 ॠ樨 compX.
       public:
          // ...
          class widget {
             // ...
         };
         // ...
       };

  ,   ᮧ   ᯮ짮 widget
   㣨  ணࠬ. 筮 , ।⠢騥
   ,  묨 ⠬  ୮
  ᯮ짮, ,  ⠢  䥩 ,
    ⠫ ॠ樨. 㣨 ᫮,   ࠭
  饣 ஢ ࠪ樨  ꥪ, ᯮ㥬 
  ।⠢ ண ꥪ ,   묨
  ⠫ﬨ ॠ樨, , ।騥 ⠪  ꥪ,
     묨, ᫨    魮.
  ,  ᫥饬 ਬ 뢠, , 譥:

       class Car {
          class Wheel {
            // ...
          };
          Wheel flw, frw, rlw, rrw;
          // ...
       };

      ঠ ஢ ࠪ樨 
  設 (Car) ᫥ 뢠 ॠ  ( Wheel),
     ࠡ⠥  設,    ᨬ  
  ᯮ짮 .  㣮 ஭, ᠬ  Wheel 
   室騬  ப ᯮ짮, ⮬ 
  뭥  ।   Car:

        class Wheel {
          // ...
        };
        class Car {
           Wheel flw, frw, rlw, rrw;
           // ...
        };

  ᯮ짮  ? ⢥    
   楫 ஥  魮 ᯮ㥬 ⨩.  ,
  ⠪   ⢨    ⨬묨 襭ﬨ  
  ஥.  ᪮  ।࠭  ७
  饣 ࠭⢠ ,  ᢮ ࠢ  ४
  ᯮ짮 , ᫨ ⮫쪮  稭   ⮣.
       ⬥⨬,   䠩  魮 ।⢮ 
  ࠧ ।⠢  ࠧ 짮⥫,   
   㤠  ।⠢   짮⥫ 
  ,  易  ᯥ䨪 ॠ樨.
      㣨 ।⢮ ஥   ।⠢ 
  짮⥫ 㦨 .    ᯮ 
  ࠭    㭪権.  ᯮᮡ ࠭
  ஡, 易  묨 묨  㭪ﬨ, ।祭묨
   ॠ樨  ᮢ ᮢ  .
   㣮 ஭,  ⠪ 襭   ⠭
  ᫨誮 易묨   㣮,  짮⥫   ᨬ
     ᮢ  ⮢,   ⢨⥫쭮
  㦭.  ⠪  ⥭  ⮬,  童,
  ।⠢騥 "" 㭪樨   "ᯫ뢠"   
  , ⠪   ᫨誮 让 娨 ᮢ ஡ 
  묨 묨  㭪ﬨ  㦥  ࠬ ⮩ 娨.
  ⭥ ᥣ,  ந  娨   ୥,  
    ⨬   ਬ 㠫  
  ($$6.5.4).      ।⠢ ,
    .  ᥣ ᤥ 롮 ।⮨ ࠧࠡ稪.

  12.4 䥩  ॠ樨

   䥩 
     - ।⠢   ᮣᮢ ⢮ ⨩ 
       짮⥫,
     -  ᮣᮢ   ⥩ ,
     - 뢠 ᯥ䨪 ॠ樨  짮⥫,
     - ᪠ ᪮쪮 ॠ権,
     -   ⥬ ⨯,
     - ।   ⨯   ਫ,
     -   㣨 䥩ᮢ  筮   ।
       ࠧ.
  ⬥⨢ 室 ᮣᮢ   ᮢ, 
  ࠧ 䥩   ⠫ ஬,   
   䥩, ᬮॢ ⮫쪮  , ਬ:

      class X {  // ਬ 宣 । 䥩
        Y a;
        Z b;
      public:
        void f(const char* ...);
        void g(int[],int);
        void set_a(Y&);
        Y& get_a();
      };

   ⮬ 䥩 ᮤন  ⥭樠 ஡:
     - Y  Z  ᯮ ⠪,  । Y  Z  
        ६ ࠭樨.
     -  㭪樨 X::f   ந쭮 ᫮ ࠬ஢
       ⭮ ⨯ (,  - ࠧ ஫
       "ப ଠ",  ।  ⢥ ࢮ
       ࠬ).
     - 㭪 X::g  ࠬ ⨯ int[].   ଠ쭮,
        筮  ᢨ⥫  ⮬,  । ᫨誮
        ஢ ࠪ樨. ᨢ 楫   
       ।, ⠪  ⭮  ᪮쪨  
        ⮢.
     - 㭪樨 set_a()  get_a(),  ᥩ , 뢠
       ।⠢ ꥪ⮢  X, ࠧ אַ 
        X::a.
      㭪樨-童 ࠧ 䥩  ᫨誮  ஢
  ࠪ樨.  ࠢ   䥩ᮬ ⠪ ஢ ⭮
   ᯥ䨪 ॠ樨 讣 , ᫨   
   祬- ⭮.   ࠬ 㭪樨  䥩
   ᮯ஢ ⠪ ଠ樥, ன 筮
    .  㫨஢ ⠪ ࠢ:  㬥
  ।   㦨 㤠 ࢥ  㧪
  .
       ++ 뢠 ।⠢    䥩.
   ।⠢    (  private 
  protected),  易⥫쭮 㯭 ࠭, ⮡   ࠧ
  ⮬᪨ () ६, ᤥ ⠭ ⥫
  㭪樨  .. ⥫ ᫥⢨ ⮣  , 
  ᯮ짮 ⨯ ᮢ  ।⠢   ਢ 
   ⥫ ᨬ⥩. ਢ  ᯮ짮
  童 ⨯ Y  Z  ஡,   ⮣,   ⢨⥫쭮
  ⨯ Y  Z. ᫨  筮  ⨯,  complex 
  String,   ᯮ짮 㤥  ⨬  設⢥ 砥.
   ⨯   ⮩稢묨,  室 
  ।  ᮢ 㤥  ⨬ 㧪  ࠭.
  ᫨  Y  Z ᠬ  ᠬ 䥩 讣
   (ਬ, ⨯ ᪮ ⥬  ⥬ ᯥ祭
  ᪨ ⮢),   ᨬ    
  ࠧ㬭.  ⠪   ।⥫쭥 ᯮ짮 童,
  騩 㪠⥫  뫪:

        class X {
          Y* a;
          Z& b;
          // ...
        };

   ⮬ ᯮᮡ । X ⤥  । Y  Z, ..
  ⥯ । X  ⮫쪮   Y  Z.  X,
  筮, 㤥 -०   । Y  Z,  
  㦥  㤥 뢠 ⭮ ﭨ  짮⥫ X.
      ᪠   ⢥ত:  䥩,
  뢠饣 ⥫ ꥬ ଠ樨 (    
  䥩),   ⢥  ᨬ⥩, 祬
   ॠ樨,   뢠. ਬ, ।  X
   ࠭᫨஢  㯠  । Y  Z. ,
   । 㭪権-童  X,  ࠡ 
  뫪  ꥪ Y  Z,   । Y  Z 室.
    ᨬ⥩ ᫥ ᬠਢ ࠧ쭮
  ᨬ  䥩   ॠ樨.     
  ᨬ⥩  ᨬ⥩ ⥬   ࠢ
  横 䮬,  砥   ஢
  ⥬. ,  楫     ⨦ 
  ॠ権, 祬  䥩ᮢ.
      ⬥⨬,   ।  䥩:

      class X {
      private:
        // 㯭 ⮫쪮  童  㧥
      protected:
        // 㯭 ⮫쪮  童  㧥,  ⠪
        //  童  㧥 ந ᮢ
      public:
        // 饤㯭
      };

    ࠧ뢠 ᠬ ࠭祭   䥩ᮢ.
  묨 ᫮, 童   ᠭ  private, ᫨ 
  稭   ப 㯠  ; ᫨  ⠪ , 
  童   ᠭ  protected, ᫨  ⥫ 稭
     public.  設⢥ 砥    ,
  ।⠢塞 童,  public. 㭪樨  , ࠧ騥 騩
  䥩,   ஥஢ ⠪ ࠧ, ⮡ ।⠢
   ᮢ   ஫  ஥  ।⢠ ।⠢
  ⨩. ,     饣 䥩.
      ⬥⨬,  ࠪ   ᯮ짮 
  ।⠢  뢠  ᮪ ஢ ($$1.4.6,
  $$6.3, $$13.3).

  12.5  ࠢ

   ⮩   㫨  ⥬, ,  ࠢ, 
   ⥫   ४樨  ᬠਢ
  ᠬ.  ⢥砥  㡥,   "⢥ ୮
  襭". ਭ樯  ਥ ᫥ ਬ ᯮᮡ, 
  室騬  ⭮ .  ॡ ,  
  ࠧ.   ,  । ᢮ ࠢ, 
  ࠧࠡ稪  ᯮ짮  ⢥ ਥ஢,  
  ਮ 筮 , ⮡ ࠡ 訥.
   ᢮ ࠢ ਢ .
         㦨 ࠢ 窮   ࠡ⪨
  ᭮ ࠢ ஥ ⭮ ,    
  ᯮ짮 ࣠樥  ⢥ ஢筮 ᯨ᪠. ભ
   ࠧ,   ࠢ   㭨ᠫ묨   
   ᮡ ࠧ諥.
    - 楫 짮⥫  ਬ ࠪ樨  
      ꥪ⭮-ਥ஢ ணࠬ஢.
      - ⥯ 室   ⮤,  ᯥ.
      - ᯮ  ++  ⮤ ⭮-ਥ஢
        ணࠬ஢ ⮫쪮   .
      _  ᮮ⢥⢨ ⨫ ஥  ணࠬ.
    - 業   ஥஢ .
    _ ᯮ   ।⠢ ⨩.
      - ᯮ 饥 ᫥  ।⠢ ⭮襭 "".
      - ᯮ ਭ  ।⠢ ⭮襭 "".
      - ,  ⭮襭 ᯮ짮 ,  ࠧ
        横,   ᫮  쭮.
      - ⨢  魮 । ⨩  ਫ 
        ॠ樨,  騥  १  騥 
        ।⠢   .
    - । 䥩 ⠪, ⮡ 뢠 쭮 ⢮
      ॡ㥬 ଠ樨:
      - ᯮ,    ,    㭪樨-童.
      - ᯮ ᠭ public  protected, ⮡ ⫨
         ࠧࠡ稪 ந ᮢ  ᮢ 
        짮⥫.
      -    ᨬ  䥩  㣨.
      - ন ண ⨯ 䥩ᮢ.
      -  䥩  ନ ⨯   ਫ.
  ⥫ ࠢ   $$11.5.

