
                                ++

         "筥  ⮣,  ୥
           , 몮".
          ("஫  VI", ⢨ II)

       ⮩  ᮤন ⪨  ᭮ 楯権  権
  몠 ++.  㦨   ⢠  몮. ஡ ᠭ
  ⥩ 몠  ⮤ ணࠬ஢     ᫥
  .    ᭮  ࠪ樨  
  ꥪ⭮-ਥ஢ ணࠬ஢,    ᭮
   楤୮ ணࠬ஢.


                                1.1 

       ணࠬ஢ ++ 뢠  ,  㤥: 

      -  몠 ;

      - ন ࠪ ;

      - ন ꥪ⭮-ਥ஢ ணࠬ஢.

       ⮩     ࠧ  ஡ ᠭ
  権 몠.

      $$1.2 ᮤন ଠ쭮 ᠭ ࠧ稩 "楤୮",
  "쭮"  "ꥪ⭮-ਥ஢" ணࠬ஢.  ਢ
  樨 몠,  ⢥    ᫥ ⨫
  ணࠬ஢. ⢥  ⨫ ணࠬ஢ 㦤 
  ࠧ "楤୮ ணࠬ஢  "쭮 ணࠬ஢".
   ++ - "訩 ਠ ".   ন ⠪ ⨫
  ணࠬ஢, 祬 ᠬ , 祬     -
  魮  䥪⨢  ࠢ  .     ६  C
   ⢮ ++. ࠪ   ꥪ⭮-ਥ஢
  ணࠬ஢ ᬠਢ  "প ࠪ樨 " 
  "প ꥪ⭮- ਥ஢ ணࠬ஢". ࢠ 
    ।  ⨯  ࠡ  ,   - 
     ⨯.

      $$1.3 ᮤন ᠭ ᭮ 権  楤୮ 
  쭮 ணࠬ஢.  ⭮, । 㭪樨, 㪠⥫,
  横, -뢮  ⨥ ணࠬ  ᮢ㯭 ࠧ쭮
  ࠭᫨㥬 㫥. ஡   ᠭ   2, 3  4.

      $$1.4 ᮤন ᠭ ।, ।祭  䥪⨢
  ॠ樨 ࠪ樨 .  ⭮, । , ⥩訩
  堭 ஫ 㯠,   , ॣ㧪
  権, ८ࠧ 짮⥫᪨ ⨯, ࠡ⪠ ᮡ 権
   蠡 ⨯. ஡   ᠭ   5, 7, 8  9.

      $$1.5 ᮤন ᠭ । প ꥪ⭮-ਥ஢
  ணࠬ஢.  ⭮, । ந  
  㠫 㭪樨, 㦤   ॠ樨.   
  ஡    6.

      $$1.6 ᮤন ᠭ । ࠭祭  
  ᮢ襭⢮  몮 ணࠬ஢ 饣 祭 ,
  ⠪  ++  ⭮.  ࠭祭 易  䥪⨢, 
  ⨢騬   ॡﬨ ࠧ ⥩ ਫ,
  ஡ 祭  室 ࠭樨  믮 ணࠬ 
   ⥬.

      ᫨ - ࠧ    , ⥫쭮
  ᮢ㥬  ᮮ⢥騥 ,  ⥬,  
  ஡ ᠭ ᭮ 権 몠,   ⮩ .
   㦭  ⮣, ⮡  뫮 ⠢ 饥 ।⠢ 
  몥.   筮 ᢥ, ⮡  
  ணࠬ஢.


                       1.2  ࠤ ணࠬ஢

      ꥪ⭮-ਥ஢ ணࠬ஢ -  ⮤
  ணࠬ஢, ᯮᮡ ᠭ "" ணࠬ  ⢠ .
  ᫨  ନ  - ,    ࠧ㬥: ⠪
   ணࠬ஢,  ।⠢ 訥  
  ꥪ⭮-ਥ஢ ⨫ ணࠬ஢.

       ᫥ 㪠   ࠧ. ,  
  ন  ⨫ ணࠬ஢, ᫨    ⠪
  ,   ணࠬ஢  ⮬ ⨫ 㤮
  (筮 ,   䥪⨢).   ন
   ⨫ ணࠬ஢, ᫨ ॡ 訥 ᨫ  
  ⢮, ⮡  ணࠬ  ⮬ ⨫.    砥,
    頥  ணࠬ  ⮬ ⨫. ⢨⥫쭮, 
    ணࠬ  ࠭  ꥪ⭮-ਥ஢
  ணࠬ  ,   㤥 ⮩ ⮩ ᨫ, ᪮  모 
  ন 㪠 ⨫ ணࠬ஢.

      প 몮 । ࠤ (⨫) ணࠬ஢ 
     몮 , ⠭  .  
       ⮭, ⮩ ଥ,  ⪫ 
  ࠤ   ⠤ ࠭樨  믮 ணࠬ.
   祢 ਬ -  ஫ ⨯.  ஬ ⮣, 몮
  প ࠤ   ஢મ  筮 
  ᪨ ஫. প  ।⠢   ᠬ
  몠, ਬ, ⠭묨 ⥪  । ணࠬ஢.

       ᪠,     㣮 ⮫쪮 ⮬,   
   ,   㣮 .  뢠  ࠧ
  .     ,  ﬨ  , 
  , ᪮쪮 騥    ন ࠭ ⨫
  ணࠬ஢  । 㣠 . ⮬ 
  㫨஢ ᫥騥 ॡ  :

      [1]  樨 몠  ⢥  ⭮ ।
   .

      [2]  襭 ।    
  ᯮ짮 ⠭ 権, ⮡  室 
   ⮩ 楫  .

      [3]   쭮 ᫮ 祢 権 ᯥ樠쭮
  祭.

      [4]   ᪠ ⠪ ॠ, ⮡ 
  ᯮ饩  ணࠬ   ⥫ 室.

      [5] 짮⥫ 筮  ⮫쪮  ⢮ 権,
  ஥ ।⢥ ᯮ   ணࠬ.

      ࢮ ॡ     ᪮ . 
  ᫥ ࠦ ਭ樯 쭮.  ᫥  
  㫨஢ ⠪: ", 祣   ,  ᬮ   ।".

       ⮬ ࠭祭, 㪠   ࠢ,  ++
  ஥஢  প ࠪ樨   ꥪ⭮-ਥ஢
  ணࠬ஢    ࠤ樮 ⨫ . 祬,  
  ,   ॡ -  ⨫ ணࠬ஢  
  짮⥫.

       ३   ⨫ ணࠬ஢  ᬮਬ
   ᭮ 樨 몠,  ন騥.   ᮡࠥ
    ᠭ  権.


                     1.2.1  楤୮ ணࠬ஢

      ࢮ砫쭮 (, ,  ᯮ㥬) ࠤ
  ணࠬ஢ 뫮:

      ।,  楤  㦭; ᯮ 訥  
   ⬮!

      ७   ࠡ    ⬠,
  ந饣 㦭 ᫥.  প ⮩ ࠤ 모
  ।⠢﫨 堭 । ࠬ஢  祭 १⮢
  㭪権. , ࠦ ⠪ 室,  㦤ﬨ 
  ᯮᮡ । ࠬ஢,  ⮬,  ࠧ ࠬ ࠧ ⨯,
   ࠧ  㭪権 (楤, ணࠬ, ப, ...) 
  ..  楤 몮  ࠭,  60, 68, ᪠ 
   த  ࠢ.

       ਬ஬ 襣 ⨫  ⠪   㦨
  㭪 祭 ⭮ .   ࠬ  뤠
  १,  砥    ⥬᪨ 権:

      double sqrt ( double arg )
      {
      // ணࠬ  ᫥ ⭮ 
      }

      voide some_function ()
      {
        double root = sqrt ( 2 );
        // ..
      }

         // 稭 ਩,  த
    ப.

       ⠪ ࣠樨 ணࠬ 㭪樨  । 冷 
  堮 ࠧ ⬮.


                      1.2.2  쭮 ணࠬ஢

       ६   ஥஢ ணࠬ 業 ᬥ⨫ 
  ࣠樨 楤  ࣠  .  ᥣ 祣
   맢  ⮬ ࠧ஢ ணࠬ. 㫥 筮 뢠
  ᮢ㯭 易 楤   , 묨  ࠢ.
  ࠤ ணࠬ஢ ਮ५ :

      ।,  㫨 㦭;  ணࠬ ⠪, ⮡ 
  뫨    

       ࠤ ⭠ ⠪  "ਭ樯 ᮪ ". ᫨ 
  몥   㯯஢ 易 楤   묨,
     ন  ⨫ ணࠬ஢.  ⮤
  ᠭ "" 楤 ਬ  ⤥ 楤 .
   ਬ  - । ⥪.  室  ⠪
  :

      [1] ।⠢ 짮⥫ 䥩  ⥪ (ਬ, 㭪樨
  push ()  pop ()).

      [2] ࠭஢,  ।⠢ ⥪ (ਬ,   ᨢ
  ⮢) 㤥 㯭  १ 䥩 짮⥫.

      [3] ᯥ稢 樠 ⥪ ।   ᯮ짮.

       㫠-2 אַ ন  ࠤ, ⮣   ⮫쪮
  ᪠ ⠪ ⨫.  ।⠢    譨 䥩
  , ॠ饣 ⥪:


      // ᠭ 䥩   ,
      // ॠ饣 ⥪ ᨬ:

       void push ( char );
       char pop ();
       const int stack_size = 100;

      ⨬,  ᠭ 䥩 室  䠩 stack.h, ⮣
  ॠ ⥪  । ᫥騬 ࠧ:

        #include "stack.h"            // ᯮ㥬 䥩 ⥪

        static char v [ stack_size ]; // ``static'' 砥 
                                      //   䠩/㫥
        static char * p = v;           // ⥪ 砫 

        void push ( char c )
        {
        //஢  ९    ⥪
        }

        char pop ()
        {
        //஢,    ⥪,    
        }

       ,  ॠ ⥪  , ਬ, ᫨
  ᯮ짮  ࠭ 易 ᯨ᮪. 짮⥫   砥 
   ।⢥ 㯠  ॠ樨: v  p - ᪨
  ६, .. ६   ⮬ 㫥 (䠩),  ஬ 
  ᠭ. ᯮ짮 ⥪  ⠪:

        #include "stack.h"       // ᯮ㥬 䥩 ⥪

        void some_function ()
        {
          push ( 'c' );
          char c = pop ();
          if ( c != 'c' )  error ( "" );
        }

      ᪮   ⢥ ,   뢠,
  ⨥ 뢠  ਢ쭮    뢠
  ଠ樨, ..  ६, ⠭, 㭪権  ⨯,  ⮦
    묨  㫥.  ++   ।砫 ᯥ樠쭮
   প 쭮 ணࠬ஢,  ন 楯
  쭮 ($$5.4.3  $$5.4.4).   ⮣ ++, ⢥,  㦥
  த஢  쭮,    , ..
  ।⠢   ⤥쭮  ࠭樨.


                          1.2.3  ࠪ 

      쭮 ணࠬ஢ । 㯯஢   
  ⨯   , ࠢ饣 ⨬ ⨯. ᫨ ॡ ⥪
   ࠧ ,  । ࠢ騩    ⠪
  䥩ᮬ:


           class stack_id { /* ... */ };        // stack_id ⮫쪮 ⨯
                                                //  ଠ樨  ⥪
                                                //   ᮤন

           stack_id create_stack ( int size );  // ᮧ ⥪  
                                                //  䨪

          void push ( stack_id, char );
          char pop ( stack_id );

          destroy_stack ( stack_id );           // 㭨⮦ ⥪

      筮 ⠪ 襭  , 祬 堮, ᢮⢥
  ࠤ樮, ஢ 襭,  㥬 ⠪ ᯮᮡ
  ⨯ ᮢ襭 祢 ⫨  "", ஥. 
  ࠢ騩 ⨯   । ᢮ ᮡ⢥ 
  ᮧ "६" ⮣ ⨯.   㭨ᠫ ࠢ
  ᢠ 䨪஢,  ꥪ ⠪ ⨯. 
  "६" ⠪ ⨯   ,  뫨  
  ࠭  㣨 ⥬ ணࠬ,   "६" 
  稭  ࠢ ⥩   । ࠬ஢.

      , ॠ㥬 ࠢ騬  㫥,    ᯥ⠬
  ⢥ ⫨砥  ஥ ⨯.  ⨯   ⮩
  প  ஭ ࠭ (ࠧ  ஫), 
  ᯥ稢  ஥ ⨯.  ஡   ⮬,  ணࠬ
  㫨  ନ  (- ᫮) ਯ஢ ꥪ⮢,
     ନ ᠬ ꥪ⮢ ( stack_id  㦨 ਬ஬ ⠪
  ਯ).  砥,  ࠭  ᬮ ⫮ ,
  祢 訡, த ,  饭  ਢ  㭪樨:

          void f ()
          {
            stack_id s1;
            stack_id s2;

            s1 = create_stack ( 200 );
            // 訡: 뫨 ᮧ s2

            push ( s1,'a' );
            char c1 = pop ( s1 );  

            destroy_stack ( s2 ); // ⭠ 訡

            // 訡: 뫨 㭨⮦ s1

            s1 = s2;  //  ᢠ   
                      // ᢠ 㪠⥫,
                      //   s2 ᯮ ᫥ 㭨⮦
          }

      묨 ᫮, 楯 쭮, ন ࠤ
  뢠 ,  頥 ⠪ ⨫ ணࠬ஢,   
  ᯮᮡ .

       몠 , Clu, ++     㤭 ८
   ⮬,  짮⥫ ࠧ蠥 । ᢮ ⨯, 
  ࠪ  몥 ࠪ᪨ ⠪ ,  ஥.   ⨯ 筮
  뢠 ࠪ묨 ⨯ ,  , ,  뢠
   짮⥫᪨.  ண । ࠪ ⨯
   뫮   ⥬᪮ ।. ᫨  㤠  ,
  ,   뢠  ணࠬ஢ ⨯, 뫮  
  ।⠢ ⢨⥫쭮 ࠪ 魮⥩.  । "
  ࠪ" ⨯,   $$4.6. ࠤ  ணࠬ஢ 
  ࠧ ⥯ ⠪:

      ।,  ⨯  㦭; ।⠢   権
    ⨯.

      ᫨  室  ࠧ ꥪ  ⨯,  ⨫
  ணࠬ஢,  ண ᢮  뢠 , 
  ᫥ ஬ ᯥ稢   楯樨 쭮, 
  ⥭ ⮩ ࠤ.

      䬥᪨ ⨯,  ⨯ 樮   ᥫ,
   ⨯묨 ਬࠬ 짮⥫᪨ ⨯:

         class complex 
         {
             double re, im;
         public:
             complex(double r, double i) { re=r; im=i; }
             complex(double r)  // ८ࠧ float->complex
                 { re=r; im=0; }
             friend complex operator+(complex, complex);
             friend complex operator-(complex, complex); // ⠭
             friend complex operator-(complex)           // 㭠 
             friend complex operator*(complex, complex);
             friend complex operator/(complex, complex);
             // ...
         };

      ᠭ  (.. ।塞 짮⥫ ⨯) complex 
  ।⠢ ᭮ ᫠   権  묨 ᫠.
  ।⠢   (private): re  im 㯭 ⮫쪮 
  㭪権, 㪠  ᠭ  complex.  㭪樨  
  । ⠪:

          complex operator + ( complex a1, complex a2 )
          {
            return complex ( a1.re + a2.re, a1.im + a2.im );
          }

       ᯮ짮 ᫥騬 ࠧ:

           void f ()
           {
             complex a = 2.3;
             complex b = 1 / a;
             complex c = a + b * complex ( 1, 2.3 );
              // ...
             c = - ( a / b ) + 2;
           }

      設⢮ 㫥 (   )  । 
  짮⥫᪨ ⨯.


                      1.2.4  । ࠪ樨 
 
      ࠪ ⨯  ।   " 騪". ᫥
  ᢮ ।        ணࠬ. 
    ᯮᮡ   楫,   ।.  ⮬
  ᫥   襭. , ਬ, 㦭 । 
  ᪮ ⥬ ⨯ shape (䨣).   ⠥,   ⥬ 
   ⠪ 䨣: 㦭 (circle), 㣮쭨 (triangle)  
  (square).  㦥  । 窨  梥:

          class point { /* ... */ };
          class color { /* ... */ };

       shape  । ᫥騬 ࠧ:

          enum kind { circle, triangle, square };

          class shape 
          {
             point center;
             color col;
             kind k;
             // ।⠢ 䨣
          public:
             point where () { return center; }
             void move ( point to )  { center = to; draw (); }
             void draw ();
             void rotate ( int );
             //   樨
          };

      " ⨯" k 室  ⮣, ⮡ ⠪ 樨,  draw () 
  rotate (),  ।,   䨣ன    ( 몠
  த ᪠  ᯮ짮  ⮣   ਠ⠬,  ன
  k  -ਬ⮬). 㭪 draw ()  । ⠪:

           void shape :: draw ()
           {

             switch ( k )  
             {
             case circle:
                 // ᮢ 㦭
                 break;
             case triangle:
                 // ᮢ 㣮쭨
                 break;
             case square:
                 // ᮢ 
                 break;
             }
           }

        㭪,  謠.   㦭    䨣,
   ⮫쪮 . ⮬   묨 ࠬ,  ⮫쪮
   ⥬   䨣.  ,  ᫥ । 
  䨣 㦭 ஢ , ,    樨 .
  ⮬, ᫨  㯥 室 ⥪  樨 , 
   䨣  ⥬  .    䨣
  ਢ    ⥪⮬  ⢥ 樨 .
  ॡ 筮 ᮪ 䨪, ⮡ ࠢ  ⮩
  祩,   ࠢ   訡  㦥 ⫠ 
  ணࠬ, ࠡ  묨 䨣ࠬ.  롮
  ।⠢  ⭮ 䨣 ᨫ쭮 㦠, ᫨ ॡ, ⮡
    ।⠢ 㪫뢠  㦥  ଠ, ᯥ஢
  騬 । 䨣 (.. । ⨯ shape).


              1.2.5  ꥪ⭮-ਥ஢ ணࠬ஢

      ஡ ⮨  ⮬,    ࠧ砥 騥 ᢮⢠ 䨣
  (ਬ, 䨣  梥,   ᮢ  ..)  ᢮⢠
  ⭮ 䨣 (ਬ, 㦭 -  ⠪ 䨣,  
  ࠤ,  ࠦ   㭪樨, 饩 㣨  ..). 
  ꥪ⭮-ਥ஢ ணࠬ஢  ⮬,   
  ࠦ  ࠧ  ᯮ . ,   樨 
  ࠦ  ᯮ짮  ࠧ稩, ন
  ꥪ⭮-ਥ஢ ணࠬ஢.  㣨 모 
  ন .   ᭮ ஫ ࠥ 堭 ᫥,
  ⢮  몠 㫠. 砫 । , 騩 騥
  ᢮⢠  䨣:

      class shape 
      { 
        point center; 
        color col; 
        // ...  
        public: 
        point where () { return center; } 
        void move ( point to ) { center = to; draw(); } 
        virtual void draw (); 
        virtual void rotate ( int ); 
        // ...  
      };

       㭪樨,    ।  䥩, 
  ॠ  (.. ⥫  ୮ )  ⮫쪮 
   䨣, ⬥祭 㦥 ᫮ virtual (㠫). 
  㫥  ++ 㠫쭮 㭪樨 砥: "㭪  
  ।   , ந  ".  ⮬ ⠪
  ।    騥 㭪樨, ࠡ騥  䨣ࠬ:

            void rotate_all ( shape v [], int size, int angle )
            //    ᨢ "v" ࠧ "size"
            //  㣮 ࠢ "angle"
            {
              int i = 0;
              while ( i<size ) 
              {
                v [ i ] . rotate ( angle );
                i = i + 1;
              }
            }

       । ⭮ 䨣 ᫥ 㪠, ० ᥣ, 
   -  䨣    ᮡ ᢮⢠ (  㠫
  㭪樨):

            class circle : public shape 
            {
                int radius;
            public:
                void draw () { /* ... */ };
                void rotate ( int ) {}  // ,   㭪
            };

       몥 ++  circle 뢠 ந  ⭮襭  
  shape,   shape 뢠    circle.  
  㣠 ନ, ᯮ  ""  "㯥ફ" 
  ᮢ circle  shape ᮮ⢥⢥.   ࠤ ணࠬ஢
  㫨 ⠪:

      ।,    室; ।⠢  
  権   ; 魮 ᮢ ࠧ   
  ᫥.

      ᫨ 魮  ᠬ ,  筮 ࠪ樨
  . ᪮쪮 ਬ ꥪ⭮-ਥ஢ ணࠬ஢ 
    ਫ । ⥯ 魮  ࠧ묨
  ⨯,   ᯮ짮 ᫥  㠫 㭪樨.
    , ⠪, ਬ,  ࠪ⨢ 䨪, 
  ப   ꥪ⭮-ਥ஢ ணࠬ஢.  㣨
  ,   ᯮ ࠤ樮 䬥᪨ ⨯ 
  ᫥  , 㤭  ਬ   ࠧ ⨫
  ணࠬ஢, 祬 ࠪ .  ।⢠, ন騥
  ꥪ⭮-ਥ஢ ணࠬ஢, 祢, .

      宦 魮 । ⤥ ⨯ ⥬ ।⠢ ᮡ
  ਢ . ⥯ ⠪ 魮   ᯮᮡ
  ஥஢ ⥬.   ஥஢  魮
  ᮢ   ﭭ 楫.  ⨣  ᯮᮡ:
   ஥஢ ᯥ樠 ᮢ, ᯮ㥬  "௨" 
  ஥ 㣨,  ᪮ 宦 ᮢ  뤥  饩
      .

       ⪠ ᭨,  ⠪ ꥪ⭮-ਥ஢
  ணࠬ஢,  ᯮ  権 몮
  ணࠬ஢,    ࠡ [2]  [6], ਢ 
  ᯨ᪥    11.

      ⠪,  㪠,   প  ᯥ稢 
  ணࠬ஢  楤୮ ணࠬ஢,  뢠
  , ࠪ樨   ꥪ⭮-ਥ஢ ணࠬ஢.
   ᪮쪮 ஡ 襬 ।⢠ 몠,    ᠬ
  ⢥,  騥  䥪⨢ ॠ ࠪ
    ꥪ⭮-ਥ஢ ணࠬ஢.


                             1.3  "襭 "

      쭠 প 楤୮ ணࠬ஢ 砥 㭪樨,
  䬥᪨ 樨, 롨騥   横.  ⮣ 
   ।⠢ 樨 - 뢮.   몮 ।⢠ ++
  㭠᫥   ( 㪠⥫),  樨 -뢮
  ।⠢ ⥪.  筠 楯 쭮
  ॠ   堭 ࠧ쭮 ࠭樨.


                    1.3.1  ணࠬ  ⠭ 뢮

       쪠 ணࠬ  ++ 룫廊 ⠪:

      main () { }

       ⮩ ணࠬ । 㭪, 뢠 main,  
   ࠬ஢  祣  .  ᪮ {  } ᯮ 
  ++  㯯஢ ஢.   砥   砫 
   ⥫ (⮣) 㭪樨 main.   ணࠬ  ++  
  ᢮ 㭪 main(),  ணࠬ 稭  믮 ⮩ 㭪樨.

      筮 ணࠬ 뤠 - १.  ணࠬ, 
  뤠 ਢ⢨ Hello, World! (ᥬ ਢ!):

           #include <iostream.h>

           int main ()
           {
              cout << "Hello, World!\n";
           }

      ப #include <iostream.h> ᮮ頥 ࠭,    
  ணࠬ ᠭ, 室  ࠡ ⠭ ⮪ -
  뢮,  室  iostream.h.   ᠭ ࠦ

      cout << "Hello, World!\n"

         ᫠.  << ("뤠") 뢠 ᢮ ன
  ࠬ   ࠬ.   砥 ப "Hello, World!\n"
  뢠  ⠭ 室 ⮪ cout. ப - 
  ᫥⥫쭮 ᨬ, 祭   窨.  ᨬ:
  ⭮ ஡  \  ।⢥ ᫥騩   - 
   ᯥ樠 ᨬ.   砥 \n  ᨬ 
  ப ( ॢ ப), ⮬  뤠 ᫥ ᨬ Hello,
  world!

       祭, 頥 㭪樥 main(), ᫨ ⮫쪮  ,
  ⠥ 頥 ⥬ 祭 ணࠬ. ᫨ 祣 
  頥, ⥬  - "୮" 祭.

      ।⢠ /뢮 ⮪ ⥪ ஡ 뢠 
   10.


                 1.3.2  ६  䬥᪨ 樨

          ࠦ 易  ⨯.  ⨯ ।
  樨,   믮  . ਬ,  ᠭ

      int inch;

      ,  inch  ⨯ int, .. inch  楫
  ६.

      ᠭ -  ,     ணࠬ.  ᠭ
  㪠뢠 ⨯ . ,  ᢮ ।, ।  ࠢ쭮
  ᯮ짮   ࠦ.

      ᭮ ⨯,  ਡ  "⭮ ॠ쭮" 設,
  ⠪:

                char
                short
                int
                long

       ।⠢ 楫 ᫠.  騥 ⨯:

                float
                double
                long double

      ।⠢ ᫠  饩 窮. ६ ⨯ char 
  ࠧ, 㦭  ࠭  ᨬ   設 (筮 
   ). ६ int  ࠧ, 室  楫 䬥⨪
    設 (筮   ᫮).

      騥 䬥᪨ 樨  ᯮ짮  
  ⠭ ᫥ ⨯:

              +    (, 㭠  )
              -    (, 㭠  )
              *    (㬭)
              /    ()
              %    (⮪  )

        ୮  権 ⭮襭:

              ==   (ࠢ)
              !=   ( ࠢ)
              <    ( 祬)
              <=   (  ࠢ)
              >=   (  ࠢ)

       権 ᢠ  䬥᪨ 権  ++ 믮
   ᫥ ८ࠧ ᭮ ⨯, ⮡   뫮
  ࠭祭 ᯮ짮   ⠭:

              double d;
              int i;
              short s;
              // ...
              d = d + i;
              i = s * i;

       = 砥 筮 ᢠ.


                         1.3.3  ⥫  ᨢ

      ᨢ   ⠪:

      char v [ 10 ]; // ᨢ  10 ᨬ

      ᠭ 㪠⥫  ⠪ :

      char * p; // 㪠⥫  ᨬ

       [] 砥 "ᨢ ",  ᨬ * 砥 "㪠⥫ ".
  祭  ࠭    ᨢ ࠢ , ⮬ v
   10 ⮢: v [ 0 ] ... v [ 9 ]. ६ ⨯ 㪠⥫ 
  ᮤঠ  ꥪ ᮮ⢥饣 ⨯:

      p = & v [ 3 ]; // p 㪠뢠  4-  ᨢ v

      ୠ  & 砥 ⨥ .


                      1.3.4  ᫮   横

       ++  ࠤ樮  롨 ஢  横. 
  ਢ ਬ ஢ if, switch  while.

       ᫥饬 ਬ  ८ࠧ   ᠭ⨬ 
  ⭮. ।,   室 ⮪ 祭  ᠭ⨬
  蠥 ᨬ i,  祭   - ᨬ c:

            #include <iostream.h>

            int main ()
            {
                const float fac = 2.54;
                float x, in, cm;
                char ch = 0;

                cout << "enter length: ";

                cin >> x;   //  ᫠  饩 窮
                cin >> ch   //  饣 ᨬ

                if ( ch == 'i' ) 
                {      // 
                    in = x;
                    cm = x * fac;
                }
                else if ( ch == 'c' ) 
                { // ᠭ⨬
                    in = x / fac;
                    cm = x;
                }
                else
                    in = cm = 0;

                cout << in << " in = " << cm << " cm\n";
            }

       >> (" ") ᯮ   ; cin
   ⠭ 室 ⮪.  ࠭, ᯮ ࠢ
   樨 >>, ।,  祭 ;  뢠 
   ࠭.

       switch (४⥫) ࠢ 祭  ஬
  ⠭.  ஢  ।饬 ਬ   ⠪:

            switch ( ch ) 
            {
            case 'i':
                  in = x;
                  cm = x * fac;
                  break;
            case 'c':
                  in = x / fac;
                  cm = x;
                  break;
           default:
                 in = cm = 0;
                 break;
          }

       break ᯮ  室  ४⥫. 
  ⠭ ਠ⮢   ࠧ. ᫨ ࠢ 祭 
  ᮢ     , 믮   ⪮ default.
  ਠ default   ⢮.

      ਢ ,  ஢ 10 ⮢  ᨢ 
  㣮:

           int v1 [ 10 ];
           int v2 [ 10 ];
            // ...
           for ( int i=0; i<10; i++ ) v1 [ i ] = v2 [ i ];

         ࠧ ⠪: "  i ࠢ ,   i
   10, ஢ i-   㢥稢 i." ६ (++)
  ६ 楫 ⨯  ᢮  㢥祭  1.


                               1.3.5  㭪樨

      㭪 -    ணࠬ,   뢠
   㣨 ⥩ ணࠬ ⮫쪮 ࠧ, ᪮쪮 室. ਢ
  ணࠬ, 뤠 ⥯ ᫠ :

            extern float pow ( float, int ); 
                // pow () ।  㣮 

            int main ()
            {
                for ( int i=0; i<10; i++ ) cout << pow ( 2, i ) << '\n';
            }

      ࢠ ப  ᠭ 㭪樨.   pow  㭪 
  ࠬࠬ ⨯ float  int,  祭 ⨯ float. ᠭ
  㭪樨 室   맮,  । 室  㣮 .

       맮 㭪樨 ⨯  䠪᪮ ࠬ ᢥ 
  ⨯, 㪠  ᠭ 㭪樨, 筮 ⠪ ,  ᫨ 
  樠஢ ६ ᠭ ⨯.  ࠭ 
  ஢  ८ࠧ ⨯. ਬ, 맮 㭪樨 pow(12.3,"abcd")
  ࠭  訡, ᪮ "abcd"  ப,  
  ࠬ஬ ⨯ int.  맮 pow(2,i) ࠭ ८ࠧ 楫
  ⠭ (楫 2)  ᫮  饩 窮 (float),  ⮣ ॡ
  㭪. 㭪 pow   । ᫥騬 ࠧ:

        float pow ( float x, int n )
        {
            if ( n < 0 ) 
                error ( "訡:  pow ()  ⥫ ⥫");
            switch ( n ) 
            {
            case 0:  return 1;
            case 1:  return x;
            default: return x * pow ( x, n-1 );
            }
        }

      ࢠ  । 㭪樨   , ⨯ 頥
  祭 (᫨  ),  ⠪ ⨯   ଠ ࠬ஢ (᫨
   ). 祭 頥  㭪樨   
  return.

       㭪樨 筮  ࠧ ,  㭪, 믮騬
  室 樨  ꥪ⠬ ࠧ ⨯,    .  ᫨
  ⨯ ࠬ஢ ⠪ 㭪権 ࠧ,  ࠭ ᥣ 
  ࠧ,  㭪 㦭 뢠. ਬ,   
  㭪樨   ⥯:  -  楫 ᥫ,   -  ᥫ
   饩 窮:

            int pow ( int, int );
            double pow ( double, double );
            //...
            x = pow ( 2,10 );    // 맮 pow ( int, int )
            y = pow ( 2.0, 10.0 );// 맮 pow ( double, double )

       ⭮ ᯮ짮  뢠 ॣ㧪 
  㭪樨   ॣ㧪; ॣ㧪 ᬠਢ ᮡ  
  7.

      ࠬ 㭪樨  ।  " 祭",  "
  뫪". ᬮਬ । 㭪樨,  ⢫ 
  祭  楫 ६. ᫨ ᯮ ⠭ ᯮᮡ
  । ࠬ஢  祭,  ਤ । 㪠⥫:

           void swap ( int * p, int * q )
           {
             int t = * p;
             * p = * q;
             * q = t;
           }

      ୠ  * 뢠 ᢥ ( 樥
  ࠧ묥),  롨ࠥ 祭 ꥪ,   ஥
  㪠⥫. 㭪  뢠 ᫥騬 ࠧ:

           void f ( int i, int j )
           {
             swap ( & i, & j );
           }

      ᫨ ᯮ짮 । ࠬ  뫪,   
   権  㪠⥫:

           void swap (int & r1, int & r2 )
           {
             int t = r1;
             r1 = r2;
             r2 = t;
           }

           void g ( int i, int j )
           {
               swap ( i, j );
           }

        ⨯ T  T& 砥 "뫪  T". 뫪 㦨
  ᨭ ⮩ ६, ன  樠஢. ⬥⨬, 
  ॣ㧪 ᪠ ⢮  㭪権 swap   ணࠬ.


                                1.3.6  㫨

      ணࠬ ++  ᥣ ⮨  ᪮쪨 ࠧ쭮
  ࠭᫨㥬 "㫥".  "" 筮 뢠 室
  䠩,   - 楩 ࠭樨.  ⮨  ᫥⥫쭮
  ᠭ ⨯, 㭪権, ६  ⠭. ᠭ extern 
    室 䠩 뫠  㭪  ꥪ, । 
  㣮 室 䠩. ਬ:

             extern "C" double sqrt ( double );
             extern ostream cout;

       ࠭ ᯮᮡ ᯥ ᮣᮢ ᠭ
  譨   室 䠩 -  ⠪ ᠭ  ᯥ樠
  䠩, 뢠 묨.  䠩    
  室 䠩,   ॡ ᠭ 譨. ਬ, ᠭ
  㭪樨 sqrt ࠭  筮 䠩 ⠭ ⥬᪨
  㭪権   math.h, ⮬, ᫨ 㦭   ७ 
  4,  :

              #include <math.h>
              //...
              x = sqrt ( 4 );

      ᪮ ⠭  䠩    
  室 䠩,    ᠭ, 㡫஢    맢
  訡. , ⥫ 㭪樨   ⠪ 䠩, ᫨ ⮫쪮 
  㭪-⠭,  樠 㪠 ⮫쪮  ⠭ ($$4.3).
    ⠪ 砥,  䠩 筮 㦨 ࠭饬 
  ⨯,  ।⠢ 䥩  ࠧ쭮 ࠭᫨㥬묨 ﬨ
  ணࠬ.

        祭 祭  㣫 ᪮  䠩 ( 襬
  ਬ - <math.h>) 뫠  䠩, 室騩  ⠭⭮ ⠫
  砥 䠩.   - ⠫ /usr/include/CC. , 室騥
   㣨 ⠫,  ᢮ ⥢묨 , 묨 
  窨. ⮬  ᫥ :

            #include "math1.h"
            #include "/usr/bs/math2.h"

       䠩 math1.h  ⥪饣 ⠫ 짮⥫  䠩
  math2.h  ⠫ /usr/bs.

      ਢ 让 祭 ਬ,  ஬ ப । 
   䠩,  ⠥  㣮.  䠩 header.h । 㦭
  ⨯:

            // header.h

            extern char * prog_name;
            extern void f ();

       main.c  ᭮ ணࠬ:

            // main.c

            #include "header.h"
            char * prog_name = "ਬ⨢,  祭 ਬ";
            int main ()
            {
              f ();
            }

       ப ⠥ 㭪樥  䠩 f.c:

            // f.c

            #include <stream.h>
            #include "header.h"
            void f ()
            {
              cout << prog_name << '\n';
            }

       ᪥ ࠭ ++  ।  室
  䠩-ࠬ஢  ࠧ ॠ  ᯮ짮 ࠧ
  ७   ணࠬ  ++.  設  ࠭  
  ணࠬ 룫廊 ⠪:

            $ CC main.c f.c -o silly
            $ silly

              ਬ⨢,  祭 ਬ

            $

      ஬ ࠧ쭮 ࠭樨 楯 쭮  ++ ন
   ($$5.4).


                      1.4  প ࠪ樨 

      প ணࠬ஢  ࠪ樥   ᭮ ᢮ 
   ।  権 (㭪樨  樨)  ⨯. 
  饭  ꥪ⠬ ⮣ ⨯ ࠭稢 ﬨ  
  . ,  ⠪ , ணࠬ ᪮ 㦨,
    㤮⢠ ।  ᯮ짮  ⨯ 㦭 
   ७ 몠. 訬 ਬ஬ ⠪ ७ 
  ॣ㧪 権.


                       1.4.1  樠  㤠

       ।⠢ ⨯ , 室  짮⥫ ।⢠
   樠樨 ६ ⮣ ⨯. ⥩襥 襭 - 
  ᯮ짮 ६ 뢠  㭪   樠樨.
  ਬ:

              class vector 
              {
              // ...
              public:
                 void init ( init size );  // 맮 init () । 
                                           // ᯮ짮 ꥪ vector
                 // ...
              };

              void f ()
              {
                vector v;
                //  v  ᯮ짮
                v.init ( 10 );
                // ⥯ 
              }

        ᨢ  ॢ⮥ 訡 襭. 㤥 , ᫨
  ᮧ⥫ ⨯ ।  樠樨 ६ 
  ᯥ樠 㭪. ᫨ ⠪ 㭪 ,   ᨬ 樨
  ࠧ饭  樠樨 ६ ᮢ   ( 
  뢠 ⠫樥   ஥). 㭪 樠樨
  뢠 ஬.  뤥 ।   㭪権
    ⥬,   ⠪  ,   ᠬ . ᫨ ꥪ
  ண ⨯  ਢ쭮,  㦭   ⥫쭠
    㤠  ᫥ ᫥ ᯮ짮. 㭪 㤠
   ++ 뢠 ஬.      ,   
  ,  ।  ⮨ ᨬ ~ ( ++  ᨬ ᯮ 
  樨 ).  ਢ ਬ:

               class vector 
               {
                  int  sz;            // ᫮ ⮢
                  int * v;             // 㪠⥫  楫
               public:
                  vector ( int );                // 
                  ~vector ();                  // 
                  int& operator [] ( int index ); //  樨
               };

        vector  ᯮ짮  ஫  訡
   뤥 :

               vector::vector ( int s )
               {
                 if ( s <= 0 ) 
                    error ( "⨬ ࠧ " );
                 sz = s;
                 v = new int [ s ];  // ࠧ ᨢ  s 楫
               }

        vector ᢮ ᯮ짮 :

               vector::~vector ()
               {
                 delete [] v;      // ᢮ ᨢ,  
                                  // ஥ 㪠⥫ v
               }

       ॠ樨 ++  ॡ ᢮ 뤥   new
  , ᫨     뫠   㪠⥫ (묨 ᫮,
   ॡ ⮬᪠ "ᡮઠ ").   ⮣  
  ⥫⢠ 짮⥫ ।   ᮡ⢥ 㭪樨
  ࠢ .  ⨯ ᯮᮡ ਬ ஢ 
  ஢,     易  ࠢ 
  ਬ  㭪権 (., ਬ, $$9.4).


                     1.4.2  ᢠ  樠

        ⨯  ࠢ  ᢮  ஥ 
  㭨⮦ 易   ꥪ⮢,   ⨯,   ⮣
  .  室 ࠢ ᥬ ﬨ ஢.  ୥
    vector:

            void f ()
            {
              vector v1 ( 100 );
              vector v2 = v1;   // ஥   v2,
                                // 樠㥬 v1
              v1 = v2;          // v2 ᢠ v1
               // ...
            }

         ।  権
  樠樨 v2  ᢠ v1. ਬ,  ᠭ:

            class vector 
            {
                int * v;
                int sz;
            public:
                // ...
                void operator = ( const vector & );  // ᢠ
                vector ( const vector & );          // 樠
            };

      㪠뢠,  ᢠ  樠 ꥪ⮢ ⨯ vector
   믮   । 짮⥫ 権.
  ᢠ  । ⠪:

            void vector::operator = ( const vector & a )
             // ஫ ࠧ  ஢ ⮢
            {
              if ( sz != a.sz ) 
                error ( "⨬ ࠧ   =" );
              for ( int i = 0; i < sz; i++ ) v [ i ] = a.v [ i ];
            }

      ᪮   ᯮ  ᢠ "஥ 祭"
  ,  樠樨   㣮 㭪樥,
  ਬ, ⠪:

            vector::vector ( const vector & a )
            // 樠  祭 㣮 
            {
              sz = a.sz;                        // ࠧ  
              v = new int [ sz ];               // 뤥   ᨢ
              for ( int i = 0; i < sz; i++ )    //஢ ⮢
                  v [ i ] = a.v [ i ];
            }

       몥 ++   T(const T&) 뢠 ஬
  ஢  ⨯ T.  樠 ꥪ⮢ ⨯ T  믮 
   祭 ண 㣮 ꥪ ⨯ T.   
  樠樨   T(const T&) ᯮ  ।
  ࠬ஢  祭  祭 頥 㭪樥 祭.


                             1.4.3   ⨯

      祬 ணࠬ   । ⠪ ⨯,  
  楫 ᥫ?  ࠢ,  㦥   ⮢, ⨯ 
  ⥭ ᮧ⥫  Vector. ⥫쭮,  㬥 ।
  ⨯  ⠪, ⮡ ⨯ ⮢  ⮬ । ⢮ 
  ࠬ, 騩 "ॠ" ⨯ ⮢:

            template < class T > class Vector 
            { //  ⮢ ⨯ T
                T * v;
                int sz;
            public:
                Vector ( int s )
                {
                    if ( s <= 0 ) 
                        error ( "⨬  Vector ࠧ" );
                    v = new T [ sz = s ];  
                        // 뤥   ᨢ s ⨯ T
                }
                T & operator [] ( int i );
                int size () { return sz; }
                // ...
            };

       । 蠡 ⨯.   ᯮᮡ 祭 ᥬ⢠
  室 ᮢ.  襬 ਬ 蠡 ⨯ Vector 뢠,  
       ⨯  ⮢.  ᠭ
  ⫨砥  筮 ᠭ  稥 砫쭮 樨
  template<class T>,   뢠,  뢠  , 
  蠡 ⨯   ࠬ஬-⨯ (  ᯮ  ⨯
  ⮢).    ।  ᯮ짮  ࠧ ⨯:

             void f ()
             {
               Vector < int > v1 ( 100 );     //   100 楫
               Vector < complex > v2 ( 200 ); //   200
                                              //  ᥫ
               v2 [ i ] = complex ( v1 [ x ], v1 [ y ] );
               // ...
             }

      ,  ॠ 蠡 ⨯,  뢠
  ࠬ᪨ ⨯  ᪨ ꥪ⠬.   室 
  ﬨ, 騬  몠 Clu  .  ᯮ짮 蠡 ⨯
     ᮡ - ⥫ 室 ६  ࠢ
   ᯮ짮 ,  ஬  ⨯ 㪠 ।⢥.


                      1.4.4  ࠡ⪠ ᮡ 権

         ணࠬ,  ᮡ  ⨢ ᯮ짮
  ⥪  室 ⠭⭮ ࠡ⪨ 訡 (, 
   ப ᫥, "ᮡ 権"). 모 , -68  Clu
  ন ⠭ ᯮᮡ ࠡ⪨ ᮡ 権.

       ୥   vector.  㦭 ,  樨
  樨 । 祭 , 室饥  ࠭ ᨢ?
  ⥫  vector  ,   뢠 짮⥫  ⠪
  砥,  짮⥫   㦨  訡 (᫨  ,
    訡    ).  室 ⠪: ᮧ⥫ 
  㦨 訡 室  ࠭ ᨢ,  ⮫쪮 ᮮ頥  
  ⭮ 짮⥫.  짮⥫ ᠬ ਭ 室 .
  ਬ:

           class vector {
             // । ⨯  ᮡ 権
           class range { };
             // ...
           };

       맮 㭪樨 訡  㭪樨 vector::operator[]() 
  ३    ணࠬ,  ன ࠡ뢠 ᮡ 樨.
   뢠 " ᮡ " ("throw the exception"):

          int & vector::operator [] ( int i )
          {
            if ( i < 0 || sz <= i ) throw range ();
            return v [ i ];
          }

       १  ⥪ 㤥 롨 ଠ, 頥 㤠 
  맮 㭪権,   ,   㤥 㦥 ࠡ稪 ᮡ
  樨  ⨯ range    (vector::range);   㤥
  믮.

      ࠡ稪 ᮡ 権  । ⮫쪮  ᯥ樠쭮
  :

            void f ( int i )
            {
                try 
                {      
                //  ⮬  ࠡ뢠 ᮡ 樨
                //   ।  ࠡ稪
                vector v ( i );
                // ...
                v [ i + 1 ] = 7;  // ਢ  ᮡ 樨 range
                // ...
                g ();         //  ਢ  ᮡ 樨 range
                              //   
                }
                catch ( vector::range ) 
                {
                    error ( "f (): vector range error" );
                    return;
                }
            }

      ᯮ짮 ᮡ 権  ࠡ 訡 
  㯮冷祭  ⭮. 㦤  ஡ ⫮   9.


                         1.4.5  ८ࠧ ⨯

      ।塞 짮⥫ ८ࠧ ⨯, ਬ, ⠪, 
  ८ࠧ ᫠  饩 窮  ᭮, ஥ 室
    complex(double),  祭 묨  ++.
  ணࠬ    ८ࠧ ,    
  ࠭,  믮    ⮬ 砥,   室
   :

            complex a = complex ( 1 );
            complex b = 1;      // : 1 -> complex ( 1 )
            a = b + complex ( 2 );
            a = b + 2;          // : 2 -> complex ( 2) 

      ८ࠧ ⨯ 㦭  ++ ⮬,  䬥᪨ 樨
   ᬥ蠭묨 ⨯  ମ  몮, ᯮ㥬  ᫮
  . ஬ ⮣,   짮⥫᪨ ⨯, ᯮ㥬
   "᫥" (ਬ, , ப, 設 ) ᪠
  ⢥ ८ࠧ  㣨 ⨯ (  㣨 ⨯).

      ८ࠧ ⨯ ᯮᮡ  ⢥  ணࠬ:

        complex a = 2;
        complex b = a + 2;  //  砥: operator + ( a, complex ( 2  ))
        b = 2 + a;          //  砥: operator + ( complex ( 2 ), a )

          믮 樨 "+" 㦭 ⮫쪮  㭪,
    ࠬ ࠧ ࠪ ⥬ ⨯ 몠.  ⮣,
   complex 뢠 ⠪,   ⢥  ९⢥
  饭  ᫠  室 -   楫 ᥫ.


                       1.4.6  ⢥ ॠ樨

      ᭮ ।⢠, ন騥 ꥪ⭮-ਥ஢
  ணࠬ஢,  : ந   㠫 㭪樨,-
   ᯮ짮   প ࠪ樨 , ᫨ 
  ᪮쪮 ॠ権  ⨯. ୥  ਬ  ⥪:

                template < class T >
                class stack 
                {
                    public:
                    virtual void push ( T ) = 0; //  㠫쭠 㭪
                    virtual T pop () = 0;      //  㠫쭠 㭪
                };

      祭 =0 뢠,   㠫쭮 㭪樨  ॡ
   ।,   stack  ࠪ, ..  
  ᯮ짮 ⮫쪮   . ⮬ ⥪  ᯮ짮,
    ᮧ:

              class cat { /* ... */ };
              stack < cat > s;    // 訡: ⥪ - ࠪ 

              void some_function ( stack <cat> & s, cat kitty ) // ଠ쭮
              {
                s.push ( kitty );
                cat c2 = s.pop ();
                // ...
              }

      ᪮ 䥩 ⥪ 祣  ᮮ頥   ।⠢, 
  짮⥫ ⥪   ⠫  ॠ樨.

       । ᪮쪮 ࠧ ॠ権 ⥪. ਬ, ⥪
    ᨢ:

             template < class T >
             class astack : public stack < T > 
             {
             // ⨭ ।⠢ ꥪ ⨯ ⥪
             //   砥 -  ᨢ
             // ...
             public:
               astack ( int size );
               ~astack ();

               void push ( T );
               T pop ();
             };

       ॠ ⥪  易 ᯨ᮪:

                template < class T >
                class lstack : public stack < T > 
                {
                // ...
                };

        ᮧ  ᯮ짮 ⥪:

             void g ()
             {
               lstack < cat > s1 ( 100 );
               astack < cat > s2 ( 100 );

               cat Ginger;
               cat Snowball;

               some_function ( s1, Ginger );
               some_function ( s2, Snowball );
             }

       ⮬,  ।⠢ ⥪ ࠧ ,  ᯮ ⮫쪮
  ,   ᮧ (.. 㭪 g()),  짮⥫ ⥪ (.. 
  㭪樨 some_function())  ࠦ  ⠫  ॠ樨.
  ⮩     ,   樨  ⥪
    㠫묨 㭪ﬨ.


          1.5 প ꥪ⭮-ਥ஢ ணࠬ஢

      প ꥪ⭮-ਥ஢ ணࠬ஢ ᯥ稢
     堭 ᫥,  ⠪ 堭 맮
  㭪権-童  ᨬ  ⨭ ⨯ ꥪ (  ⮬, 
   砨,   ⨯ ⥭  ⠤ ࠭樨). ᮡ
   ஫ ࠥ 堭 맮 㭪権-童.    
  ।⢠, ন騥 ࠪ  (   ਫ ࠭). 
     ࠪ樨      ⮤, 
   ⢥  ᨢ ࠡ  ⨯,    몠,
  ন饣 ꥪ⭮-ਥ஢ ணࠬ஢. ᯥ 
  ⮤   ᯮᮡ ஥ ⨯,  ⮣, ᪮쪮 
  ,   䥪⨢. ⮤ ꥪ⭮-ਥ஢
  ணࠬ஢  ।  騥  
  짮⥫᪨ ⨯  ࠢ  ⥬,  , ᫨
  ᯮ짮 ⮫쪮 ࠪ .


                           1.5.1  堭 맮

      ᭮ ।⢮ প ꥪ⭮-ਥ஢ ணࠬ஢
  -  堭 맮 㭪樨-童   ꥪ,  ⨭
  ⨯   ⠤ ࠭樨 ⥭. , ਬ,  㪠⥫
  p.  ந室 맮 p->rotate(45)?  ᪮ ++  
  ᪮ ஫ ⨯, 饥 맮 ࠦ   ⮫쪮
   ᫮,  㭪 rotate() 㦥 뫠 ᠭ. ,  祭
  p->rotate()  ,  p  㪠⥫  ꥪ ண
  ,  rotate   童 ⮣ .    类
  ᪮ ஫ ⨯ ஢ઠ ४⭮ 맮 㦭  ⮣,
  ⮡ 㡥 (᪮쪮    ⠤ ࠭樨),  ⨯ 
  ணࠬ ᯮ ⨢稢 ࠧ.  ᠬ ࠭,
   ணࠬ ᢮    訡.

      ⠪, ࠭   ⭮ ᠭ , 筮
  ⥬,  ਢ  $$1.2.5:

           class shape 
           {
           // ...
           public:
              // ...
              virtual void rotate ( int );
              // ...
           };

       㪠⥫ p   ᠭ, ਬ, ⠪:

      T * p;

       T -  shape  ந   .  ࠭
  ,   ꥪ,   ஥ 㪠⥫ p, ⢨⥫쭮
   㭪 rotate(),  㭪  ࠬ ⨯ int. ,
  p->rotate(45) ४⭮ ࠦ.

      ᪮ shape::rotate() 뫠 ᠭ  㠫쭠 㭪, 㦭
  ᯮ짮 堭 맮 㠫쭮 㭪樨. ⮡ 㧭, 
    㭪権 rotate ᫥ 맢, 㦭  맮  
  ꥪ  㦥 ଠ,  뫠 饭 㤠  
  ᮧ.  ⮫쪮 ⠭,  㭪  맢, ⨬
  circle::rotate, ந室  맮  㦥 㯮訬 ஫ ⨯.
  筮  ⢥ 㦥 ଠ樨 ᯮ ⠡ ᮢ
  㭪権,  ࠭ ८ࠧ  rotate   ⮩ ⠡. 
  ⮬ ⮩ ⠡ ꥪ ⨯ shape  ।⠢ ⠪:


          center
                               vtbl:
          color                    &X::draw
                                   &Y::rotate
           ...
                                       ...

      㭪樨  ⠡ 㠫 㭪権 vtbl  ࠢ쭮
  ࠡ  ꥪ⮬    ,   뢠饩 㭪樨
    ⠡ vtbl,  ᯮ    ꥪ,
  祭 ... .   X  Y 祭  ᮢ,  
  室 뢠 㭪樨.  ꥪ circle   X  Y  circle.
  맮 㠫쭮 㭪樨     ⮫  䥪⨢, 
  맮 筮 㭪樨.


                            1.5.2  ஢ઠ ⨯

      室 ஫ ⨯  饭  㠫 㭪
    । ࠭祭  ࠧࠡ稪 ⥪.
  ਬ,   ।⠢ 짮⥫  "⥪ 祣-㣮".
  ।⢥  ++  ᤥ . , ᯮ 蠡 ⨯ 
  ᫥,  ਡ  ⮩ 䥪⨢  
  ஥஢  ᯮ짮 ⥪,  ᢮⢥ 몠 
  ᪨ ஫ ⨯.  ⠪ 몠 ⭮, ਬ, 
  Smalltalk,  ஬   "⥪ 祣-㣮".  ᬮਬ
  । ⥪   蠡 ⨯:

              template < class T > class stack 
              {
                 T * p;
                 int sz;
              public:
                 stack ( int );
                 ~stack ();

                 void push ( T );
                 T & pop ();
              };

       ᫠ ᪮ ஫ ⨯,  ᯮ짮 ⠪ ⥪
   ࠭ 㪠⥫  ꥪ ⨯ plane (ᠬ):

          stack < plane * > cs ( 200 );

          void f ()
          {
             cs.push ( new Saab900 );   // 訡  ࠭樨 :
                                        // ॡ plane*,  । car*
             cs.push ( new Saab37B );
                                        // ४᭮: Saab 37B -  ᠬ
                                        //  ᠬ, .. ⨯ plane
             cs.pop () -> takeoff ();
             cs.pop () -> takeoff ();
           }

      ᫨ ᪮ ஫ ⨯ , ਢ  訡
  㦨 ⮫쪮  믮 ணࠬ:

           // ਬ  ᪮ ஫ ⨯
           //  ᪮;   ++
           Stack s; // ⥪  ࠭ 㪠⥫  ꥪ
                    // ந쭮 ⨯
            void f ()
            {
               s.push ( new Saab900 );
               s.push ( new Saab37B );
               s.pop () -> takeoff ();  // ४᭮: Saab 37B - ᠬ
               cs.pop () -> takeoff ();  // ᪠ 訡:
                                     // 設   
            }

       ᯮᮡ ।, ⨬    ꥪ⮬, 筮
  ॡ  ⥫ 室, 祬  堭 맮
  㠫 㭪権  ++.

      뢠  ᪨ ஫ ⨯  맮 㠫 㭪権,
   室   ⨫ ணࠬ஢, 祬  ⮫쪮 
  ᪨ ஫ ⨯.   ++  ண ।
  䥩  ⢠ ꥪ⮢ ⮣   ந , ⮣
    Smalltalk   ⮫쪮 쭮 室 ᫮ 権,
   짮⥫ ࠢ ਬ    樨. 묨
  ᫮,   ++ ᮤন 筮 ᠭ 権,  짮⥫
  ࠭,  ⮫쪮  樨 ࠭  ⨬묨.


                      1.5.3  ⢥ ᫥

      ᫨  A   ᮬ  B,  B ᫥ ਡ
  A.  .. B ᮤন A   -.  ⮬ ⮣ ⠭ 祢,
   ,   B  ᫥    ᮢ A1 
  A2.  뢠 ⢥ ᫥.

      ਢ  ⨯ ਬ ⢥ ᫥.  
     displayed  task.  ।⠢ ,
  ଠ    뤠  ࠭   ண
  ,  ன - , 믮塞  ࠢ ண
  ᯥ. ணࠬ  ᮧ ᮡ⢥ , ਬ,
  ⠪:

         class my_displayed_task: public displayed, public task 
         {
            // ⥪ 짮⥫
         };

         class my_task: public task {  
            //    ࠦ
            //  ࠭, ..  ᮤন  displayed
            // ⥪ 짮⥫
         };

         class my_displayed: public displayed 
         { 
            //    
            // ..  ᮤন  task
            // ⥪ 짮⥫
         };

      ᫨ ᫥  ⮫쪮  ,  짮⥫ 㯭
  ⮫쪮    ਢ ᮢ.  १  砥
  㡫஢ ⥩ ணࠬ,   , ,  ࠢ,
  ந室  ,  㣮. ਢ ਬ 室  ++  直
  ⥫ 室 ६    ࠢ  ணࠬ, 
   ᫥    .  ᪨ ஫ ⨯ 
  ⮣ ⮦  ࠤ.

       筮   ⠤ ࠭樨:

           class task 
           {
           public:
             void trace ();
             // ...
           };

           class displayed 
           {
           public:
             void trace ();
             // ...
           };

           class my_displayed_task:public displayed, public task 
           {
             //  ⮬  trace ()  ।
           };

           void g ( my_displayed_task * p )
           {
             p -> trace ();  // 訡: 筮
           }

       ⮬ ਬ  ⫨ ++  ꥪ⭮-ਥ஢ ⮢
  몠 ,    ⢥ ᫥.   
  筮 ࠧ蠥 ⠪:  ⠥ ⢥ 冷
  ᠭ,   묨 ꥪ    ⥬   
  ࠧ  ,  ᯮ ஢ ᯮᮡ, 
  ᮢ ꥪ⮢   ᮢ ⠥   ᫮
  ᯮᮡ  ந ᮢ.  ++ 筮,  ࠢ,
  ࠧ蠥    㭪樨:

        class my_displayed_task:public displayed, public task 
        {
            // ...
        public:
            void trace ()
            {
              // ⥪ 짮⥫
              displayed::trace ();  // 맮 trace ()  displayed
              task::trace ();       // 맮 trace ()  task
            }
            // ...
       };

      void g ( my_displayed_task * p )
      {
         p -> trace ();  // ⥯ ଠ쭮
      }


                             1.5.4  

       童  ( 㭪樨-童  童, ।⠢饬
  ) ॡ   "ᠭ樮஢ 㯠".  ࠧ㬭
  ࠭ ⢮ 㭪権,  ⠪ 童 㤥 㯥? 祢
  ⢥  몮, ন ꥪ⭮-ਥ஢
  ணࠬ஢, ⠪:    樨,  । 
  ⮣ ꥪ, 묨 ᫮,  㭪樨-童. ਬ:

          class window 
          {
          // ...
          protected:
             Rectangle inside;
             // ...
          };

          class dumb_terminal : public window 
          {
             // ...
          public:
             void prompt ();
             // ...
          };

          window 童 inside ⨯ Rectangle 뢠
   饭 (protected),  㭪樨-童 ந ᮢ,
  ਬ, dumb_terminal::prompt(),      ᭨, 
      ࠡ.   㣨 㭪権 童
  window::inside 㯥.

       ⠪ 室 ⠥ ᮪ ⥯ 饭
  (⢨⥫쭮,    "砩" । ந ) 
  , 室  ணࠬ,  ᮧ   ᯮ
    (⢨⥫쭮, " ᥡ" ᥣ   ந 
  ।ᬮ   饭 童).

      祢 ᫥⢨  ⮣:  ⠢  
  ⥫ ᯨ᮪  㭪権,  㤥 㯥 饭 童,
  ᪮ ᥣ    , ।   㭪-童 
   ந .  ⮤ ࠪ樨  ⠪ 室 
  뢠  ਥ. ᫨  ਥ  ⮤ ࠪ樨
  ,  祢   襭 -  ॡ 㪠뢠 
  ᠭ  ᯨ᮪  㭪権,  㦥   童.   ++
   ⮩ 楫 ᯮ ᠭ  (private) 童. 
  ᯮ짮   ਢ ᠭ ᮢ complex  shape.

       樨, .. 祭 童   ,
  १ ⠥  ⮬ ࠧ஢ ணࠬ  㢥稢騬 ࠧᮬ
  ⥩ ਫ.  $$6.6  ஡ 㦤  몠
   樨.


                          1.6  । ᮢ襭⢠

       ++ ஥஢  "訩 ", ন騩 ࠪ
    ꥪ⭮-ਥ஢ ணࠬ஢.  ⮬  
   ਣ  設⢠ ᭮  ⥬ ணࠬ஢.

      ᭮ 㤭  몠,  ᮧ    ⮤
  뢠 , ࠪ樨   ꥪ⭮-ਥ஢
  ணࠬ஢,  ⮬,   ⮣, ⮡  몮 饣
  祭,  :

      -   ࠤ樮 設;

      - ⢮  ࠤ樮묨 樮묨 ⥬  몠;

      - ᮯ୨  ࠤ樮묨 몠 ணࠬ஢  䥪⨢
  믮 ணࠬ;

      -  ਣ   ᭮  ਫ.

       ,      䥪⨢ ᫮
  権 (䬥⨪  饩 窮  ᮡ  室,
   짮⥫ । ࠭)  ।⢠ ⠪ 㯠  ,
      ⮬ 몥 ࠩ ன. ஬ ⮣, 
  㬥  맮 㭪権  筮 ਢ筮 , ਭ⮩ 
  饭  ࠤ樮 樮 ⥬. ,  
    몠, ন饣 ꥪ⭮-ਥ஢
  ணࠬ஢, 뢠 㭪樨, ᠭ  㣨 몠,  
  㣨 몮 뢠 㭪  ⮬ 몥, ন饬
  ꥪ⭮-ਥ஢ ணࠬ஢.

      ,  뢠  ப ᯮ짮 ᪮ 몠
  ணࠬ஢  몠 饣 祭, ᫨ ॠ  楫
    ,    設  ࠤ樮
  ⥪ன.

      ᫨       ஢,  ਤ 
  ᭮  設⢠ ⥩ ਫ ᯮ짮 
  모  ஢, ਬ   ᥬ.  ++ ஥஢ 
  ⮬,     ᤥ ,  ⨬  , 祬 
  㢥祭 ६ 믮.  , ++ ஥஢, 室 
  ਭ樯,      ⥫  ६ 
  , ᫨ ⮫쪮 ⮣    ᠬ ணࠬ.

       ஥஢    ᮢ६ ⮤ ࠭樨,
   ᯥ稢 ஢ ᮣᮢ ணࠬ,  䥪⨢
   ⭮ ।⠢. ᭮ ।⢮   ᫮
  ணࠬ , ० ᥣ, ண ஫ ⨯  .
  ᮡ  ᠥ  ணࠬ, ᮧ  쬨.
  짮⥫      ᮧ⥫ ⠪ ணࠬ,  
     ணࠬ⮬.  ᪮   ணࠬ
     প ⥪, ᮧ 㣨
  ணࠬ⠬, ᫥ 砭  ⭥ ࠪ᪨  ᥬ
  ணࠬ.

      ++ ஥஢  প ⮣ ਭ樯,  猪 ணࠬ
       ॠ쭮 ⨩,   
   ।⠢ , ⮣   ਫ ($$12.2).
  ⮬  ஭뢠  ணࠬ  ++,   ⪨
  ॡ    , ⭮ ꥪ⮢  
  䥪⨢  ᯮ짮. ᫨ ࠡ  ᠬ 㤥 㤮
   ᫨誮 ,      ᯮ짮,  ணࠬ
  த  ணࠬ  "襬 ".  짮⥫  㬥
  ᫠ ⥬ ﬨ, ࠤ , ᮡ⢥,  ᮧ
  .
