
              5

             

          " ⨯  ࠪ,  ⮫  ॠ,
            int  float"
                -  ன

       ⮩  뢠  ।  ⨯,
           ࠭祭  ⢮
      㭪権, ⢫ . ,   ᯮ짮
      童  ,   , 樠஢ ,
      , 㭨⮦.  ਬ ਢ   
      ࠢ ⠡楩 , ࠡ  ⥪, ⢮ 
      ॠ樨 ਬ饣 (.. ) ꥤ.
      騥    ᠭ ⥩ ++ 
      ஥  ⨯,    ᮤন  
      ਬ஢.

  5.1   ⪨ 

  ⨥ , ஬ 饭    ᫥ , 㦨
   ++  ⮣, ⮡  ணࠬ 㬥 ஥ 
  ⨯.  짮   㤮, 祬 ஥묨.
    ᯮ짮 । 짮⥫ ⨯  
  ⫨  ᯮ짮 ஥ ⨯.   ⮫쪮
   ᯮᮡ ஥.
        ⭮ ।⠢ ண .
  ਬ,  ++ ⨯ float  ﬨ +, -, *  .. 
    ࠭祭,   ।⠢ ⥬᪮
   ⢥ ᫠.  ⨯ ᮧ  ⮣, ⮡
   ᯥ樠   ।⠢ , ஥  室
  אַ  ⢥ ࠦ । ஥ ⨯. ਬ,
   ணࠬ   ⥫䮭 裡   ⨯
  trunk_module (-裡),   - ⨯ explosion (),
    ணࠬ, ࠡ뢠饩 ⥪, - ⨯ list_of_paragraphs
  (ᯨ᮪-ࠣ䮢). 筮     ணࠬ,
   ன ⨯  ।⠢ ᯮ㥬   .
  筮 ࠭ ⢮ 짮⥫᪨ ⨯  ணࠬ
   ᭮.   ࠭ 㦨 ⨬
  ᯮ짮 ꥪ⮢, ஥  ⨢ 砥 ⠭
    ⫠ ணࠬ.
       ।  ⨯ -  ⤥ ⢥
  ⠫ ॠ樨 (ਬ, ᯮ   ꥪ 
  ⨯)    ࠪ⨪,  ⢥  ࠢ쭮
   ᯮ짮 (ਬ,  ᯨ᮪ 㭪権,  
   ).  ࠧ ᯥ稢 ⥬,   ࠡ 
  ன   ७, 㦥 樨   㯭
  ⮫쪮 १ ᯥ樠 䥩 (१ " ૮").
      ⮨   ⥩:
     $$5.2   童.   ᭮ ⨥
           짮⥫᪮ ⨯, 뢠 ᮬ.   ꥪ⠬
             ࠭稢 ⢮ 㭪権, ᠭ
            室  ᠭ .  㭪樨 뢠
           㭪ﬨ-童  ﬨ.  ᮧ ꥪ⮢ 
           ᯮ ᯥ樠 㭪樨-童, 뢠
           ࠬ.   ᯥ樠 㭪-童
            㤠 ꥪ⮢    㭨⮦. 
           㭪 뢠 ஬.
     $$5.3 䥩  ॠ樨.  ਢ  ਬ
           ࠧࠡ⪨, ॠ樨  ᯮ짮 ᮢ.
     $$5.4 ⥫ ᢮⢠ ᮢ.  ਢ 
           ⥫ ஡⥩  . , 
           㭪樨,  饩 童 , ।⠢ 
             ⭮ .  㭪 뢠 㣮 .
             ᪨ 童   㪠⥫
            童 .   ,  ।
           ਬ饥 ꥤ.
     $$5.5   . ꥪ  ᮧ 
           ⮬᪨, ᪨   ꥪ  ᢮
           . ஬ ⮣, ꥪ   童 ண
           ॣ (ᨢ  㣮 ),  ⮦
            ࠧ     ᯮᮡ. ஡
            ᯮ짮 ஢  ஢,
           뢠 ਬ ।塞 짮⥫ 㭪権
           ࠧ饭  ᢮   㭪権 ᢮ .

  5.2   童

   -  짮⥫᪨ ⨯.  ࠧ   ᭮묨
  ।⢠ । , ᮧ  ꥪ⮢, ࠡ 
  ⠪ ꥪ⠬ , , 㤠  ꥪ⮢ ᫥
  ᯮ짮.

  5.2.1 㭪樨-童

  ᬮਬ,   ।⠢  몥 ⨥ , ᯮ
   ⮣ ⨯    㭪権, ࠡ  ६묨
  ⮣ ⨯:

         struct date { int month, day, year; };
         date today;
         void set_date(date*, int, int, int);
         void next_date(date*);
         void print_date(const date*);
         // ...

    裡  㭪ﬨ  ன date .  
  ⠭, ᫨  㭪樨  童 :

         struct date {
             int month, day, year;

             void set(int, int, int);
             void get(int*, int* int*);
             void next();
             void print();
         };

  ᠭ ⠪ ࠧ 㭪樨 뢠 㭪ﬨ-童.  
  뢠 ⮫쪮 १ ६ ᮮ⢥饣 ⨯, ᯮ
  ⠭  饭  童 :

           date today;
           date my_birthday;

           void f()
           {
             my_birthday.set(30,12,1950);
             today.set(18,1,1991);

             my_birthday.print();
             today.next();
            }

  ᪮ ࠧ    㭪樨-童  묨
  ,  । 㭪樨-童 㦭 㪠뢠  :

           void date::next()
           {
             if (++day > 28 ) {
                //  ᫮ ਠ
             }
           }

   ⥫ 㭪樨-童  童  ᯮ짮  㪠
   ꥪ.  ⠪ 砥  ⭮  童 ⮣ ꥪ,
   ண 뫠 맢 㭪.

  5.2.2 

   । ᪮쪮 㭪権  ࠡ  ன date,   
  ᠭ  ᫥,   ⢥ 㭪樨, 
  ।⠢   ꥪ⠬ ⨯ date.  ⠭ ⠪
  ࠭祭, ᠢ   :

             class date {
                int month, day, year;
             public:
                void set(int, int, int);
                void get(int*, int*, int*);
                void next();
                void print()
             };

  㦥 ᫮ public (騩) ࠧ ᠭ    .
  , ᠭ  ࢮ ⭮ (private)  , 
  ᯮ짮 ⮫쪮  㭪-童.  -   -
  ।⠢ ᮡ 䥩  ꥪ⠬ . ⮬  - 
  ⠪ ,  ஬  ।  童  騬.
  㭪樨-童  ।  ᯮ 筮 ⠪ , 
  뫮   ।饬 ࠧ:

             void date::print()     //     ਭ⮬   
             {
               cout << month << '/' << day << '/' << year ;
             }

    㭪権  童  童  date 㦥 ࠦ:

             void backdate()
             {
               today.day--;    // 訡
             }

    २  ⮬,      ࠭祭
   㪠 ᯨ᪮ 㭪権.  訡   (ਬ,
  December, 36, 1985)   ᥭ ⮫쪮 㭪樥-童,
  ⮬ ࢠ ⠤ ⫠ -  訡 - ந室
    ࢮ ᪠ ணࠬ.  ⮫쪮  砩 饣
  ࠢ:     ⨯ date   
  뢠 ﬨ   童. 㣮 २⢮  ⮬, 
  ⥭樠쭮 짮⥫   ࠡ   筮
   ⮫쪮 । 㭪権-童.
         ᭮뢠 ⮫쪮  ࠭祭
  ᯮ짮  童 . ⮬    
   権  ᠬ   ८ࠧ ⨯,
    㦥   襭⢮.

  5.2.3 뫪  ᥡ

   㭪樨-童  ।⢥ ᯮ짮  童
  ⮣ ꥪ,  ண  뫠 맢:

          class X {
            int m;
          public:
            int readm() { return m; }
          };

          void f(X aa, X bb)
          {
            int a = aa.readm();
            int b = bb.readm();
            // ...
          }

   ࢮ 맮 readm() m 砥 aa.m,   ஬ - bb.m.
       㭪樨-童  ⥫  ࠬ, 騩
  㪠⥫  ꥪ,  ண 뢠 㭪.  
  ᯮ짮   ࠬ   this. ⠥, 
    㭪樨-童  X 㪠⥫ this ᠭ  

          X *const this;

   樠, ⮡ 㪠뢠  ꥪ,  ண
  㭪-童 뢠.  㪠⥫  , ᪮
   ﭭ (*const).    ⮦ , .. this -
   㦥 ᫮.   ⭮ ᠭ  X:

         class X {
            int m;
         public:
            int readm() { return this->m; }
         };

   饭  童 ᯮ짮 this 譥.  ᭮ this
  ᯮ  㭪-童, ।⢥ ࠡ 
  㪠⥫ﬨ.  ਬ - 㭪,  ⠢ 
   ᯨ᮪   :

           class dlink {
              dlink* pre;  // 㪠⥫  ।騩 
              dlink* suc;  // 㪠⥫  ᫥騩 
           public:
              void append(dlink*);
              // ...
           };

           void dlink::append(dlink* p)
           {
             p->suc = suc;    // .. p->suc = this->suc
             p->pre = this;   //  ᯮ짮 "this"
             suc->pre = p;    // .. this->suc->pre = p
             suc = p;         // .. this->suc = p
           }

           dlink* list_head;

           void f(dlink* a, dlink* b)
           {
             // ...
             list_head->append(a);
             list_head->append(b);
           }

   ᪨  ⠪ 饩 ன 㦠 㭤⮬ ᯨ ᮢ,
   뢠   8. ⮡ ᮥ   ᯨ, 㦭
    ꥪ,   ஥ 㪠⥫ this, pre  suc.
      ⨯ dlink, ⮬ 㭪-童 dlink::append() 
     . 頥 楩  ++  ,   ⤥
   ꥪ .
        㭪-童 ⠪ ࠧ,  ꥪ,  ண
    뢠, 㤥 㯥  ⮫쪮  ⥭.  䠪, 
   㭪  㤥  ꥪ,  ண  뢠
   (.. this*), 砥 㦥 ᫮ const   ᯨ᪠
   ࠬ஢:

              class X {
                 int m;
              public:
                 readme() const { return m; }
                 writeme(int i) { m = i; }
              };

    㭪-童  ᯥ䨪樥 const  뢠  ﭭ
    ꥪ⮢,  㭪-童  ⠪ ᯥ䨪樨 - :

              void f(X& mutable, const X& constant)
              {
                mutable.readme();    // ଠ쭮
                mutable.writeme(7);  // ଠ쭮
                constant.readme();   // ଠ쭮
                constant.writeme(7); // 訡
              }

      ⮬ ਬ ࠧ㬭 ࠭ ᬮ  㦨, 
     㭪 X::writeme() ⠥  ﭭ ꥪ. ,
         ࠭. - ࠧ쭮
     ࠭樨   饬 砥   ࠭஢ "⢮"
     ꥪ, ᫨  ᮮ⢥饣 ᠭ  ᯥ䨪樥
     const. ਬ, । readme()  writeme()   
     㣮 䠩:

              class X {
                 int m;
              public:
                 readme() const;
                 writeme(int i);
              };

     ⠪ 砥 ᠭ readme()  ᯥ䨪樥 const ⢥.
         㪠⥫ this  ﭭ 㭪樨-童  X 
    const X *const.  ,    ਢ   this
      祭 ꥪ:

              class X {
                 int m;
              public:
                 // ...
                 void implicit_cheat() const { m++; }  // 訡
                 void explicit_cheat() const { ((X*)this)->m++; }
                      // ଠ쭮
             };

     ᯥ䨪 const  ⮬,  ⨥
    "⢠" ꥪ   祭. ࢮ, 뢠
    "䨧᪨ ⢮" ⮨  ⮬,  ꥪ ࠭
     饭   . ஥, 뢠 "᪨
    ⢮" 砥  ⮬,  ꥪ 㯠 
    ﭭ (塞)  ⭮襭  짮⥫. 
     ᪨ ﭭ ꥪ⮬    
    ꥪ, ᫨  ⮬  蠥  ⢮
     窨 ७ 짮⥫. ﬨ, 騬 ᪮
    ⢮ ꥪ,   ਧ 祭, 
    ⨪,  ६-稪  ﭭ
    㭪-童.
         ᪮ ⢠  ⨣ ਢ, 㤠騬
    ᯥ䨪 const:

             class calculator1 {
                int cache_val;
                int cache_arg;
                // ...
             public:
                int compute(int i) const;
                // ...
             };

             int calculator1::compute(int i) const
             {
               if (i == cache_arg) return cache_val;
               // 訩 ᯮᮡ
               ((calculator1*)this)->cache_arg = i;
               ((calculator1*)this)->cache_val = val;
               return val;
             }

    ⮣  १  , ᯮ 㪠⥫  
     const:

             struct cache {
                 int val;
                 int arg;
             };

             class calculator2 {
                 cache* p;
                 // ...
             public:
                 int compute(int i) const;
                 // ...
             };

             int calculator2::compute(int i) const
             {
               if (i == p->arg) return p->val;
               // 訩 ᯮᮡ
               p->arg = i;
               p->val = val;
               return val;
             }

   ⬥⨬,  const 㦭 㪠뢠   ᠭ, ⠪   ।
   ﭭ 㭪樨-童. ᪮ ⢮ ᯥ稢
   饭 ꥪ  饭   , ⮫쪮 ᫨  
     ($$7.1.6).

   5.2.4 樠

   樠 ꥪ⮢    ⠪ 㭪権  set_date()
   - ⭮  ॢ⮥ 訡 襭. ᪮   뫮
   㪠,  ꥪ ॡ 樠樨, ணࠬ   
    ᤥ,  ᤥ ,   ਢ  ⮫ 
   ᪨ ᫥⢨.   ணࠬ 
    㭪,  ।祭  樠樨 ꥪ⮢.
   ᪮ ⠪ 㭪  祭  ⨯, 
   뢠 ஬.  㭪  ᯮ -  
     ,    :

              class date {
                 // ...
                 date(int, int, int);
              };

   ᫨    ,  ꥪ ⮣  
   ந樠஢. ᫨  ॡ ࠬ, 
    㪠뢠:

              date today = date(23,6,1983);
              date xmas(25,12,0);  // ⪠ ଠ
              date my_birthday;    // ࠢ쭮, 㦥 樠

       뢠 㤮 㪠 ᪮쪮 ᯮᮡ 樠樨
   ꥪ.  ⮣ 㦭  ᪮쪮 ஢:

              class date {
                 int month, day, year;
              public:
                 // ...
                 date(int, int, int);  // , , 
                 date(int, int);       // ,   ⥪騩 
                 date(int);            //   ⥪騥   
                 date();               // ⠭⭮ 祭: ⥪ 
                 date(const char*);    //   ப ।⠢
              };

   ࠬ ஢ 稭 ⥬  ࠢ  ⨯
   ࠬ஢,    ⠫ 㭪樨 ($$4.6.6).  
   筮 ࠧ  ⨯ ᢮ ࠬ஢, ࠭
   ᯮᮡ ࠢ쭮  :

                 date today(4);
                 date july4("July 4, 1983");
                 date guy("5 Nov");
                 date now;       // 樠 ⠭ 祭

       ஢  ਬ c date ⨯筮.  ࠧࠡ⪥
    ᥣ  ᮡ    , -  
    - ਣ. ⮡ । ⢨⥫쭮 㦭
   ,  ࠧ,    १,  ࠢ,
   砥  ⭠  ⭠ ணࠬ.  ᫮
   室 㭪権    ⠭⭮ 祭 ࠬ.
    ਬ  date   ࠬ   ⠭⭮
   祭,  砥: " 祭  ⥪饩 ".

                 class date {
                   int month, day, year;
                 public:
                   // ...
                   date(int d =0, int m =0, y=0);
                   // ...
                 };

                 date::date(int d, int m, int y)
                 {
                   day = d ? d : today.day;
                   month = m ? m : today.month;
                   year = y ? y : today.year;
                   // ஢ઠ ࠢ쭮 
                   // ...
                 }

        ᯮ ⠭⭮ 祭 ࠬ,  
   ⫨   ⨬ 祭 ࠬ.  砥  
    祢,   祭  -  ⠪,  祢,
     室  祭 .  ,  ய᪮
     㫥 , .. ࠧ ᫥ 1 .  ..
   (year==-1)  1 . .. (year==1).   筮 ணࠬ
   , , ᫨誮 ⮭ .
       ꥪ     樠஢
   ᢠ  㣮 ꥪ ⮣  .  饭 
    ⮬ 砥,   ᠭ:

              date d = today;  // 樠 ᢠ

    ᠬ ,  ⠭  ஢,
   ।  ⭮ ஢ ꥪ⮢  .
   ᫨ ⠪    X  㦥,  ८।
      ஢ X::X(const X&). ஡ ਬ
    ⮬  $$7.6.

   5.2.5 

   짮⥫᪨ ⨯  , 祬  , , 
   ஢  樠.   ⨯ ॡ 
   ⭠  - , ࠭ ࠢ쭮 㤠
   ꥪ⮢ ⮣ ⨯.   X 砥 ~X ("
   ").  ⭮,   ᮢ ᯮ
   ᢮  (. $$3.2.6), 뤥塞 ஬ 
   ᢮ ஬. , ਬ, ࠤ樮 ।
   ⨯ ⥪,  ண  ⪮  襭 ࠡ⪠
   訡:

              class char_stack {
                 int size;
                 char* top;
                 char* s;
              public:
                 char_stack(int sz) { top=s=new char[size=sz]; }
                 ~char_stack()  { delete[] s; }  // 
                 void push(char c) { *top++ = c; }
                 void pop()   { return *--top; }
             };

    ꥪ ⨯ char_stack 室  ⥪饩  ,
   뢠 :

             void f()
             {
               char_stack s1(100);
               char_stack s2(200);
               s1.push('a');
               s2.push(s1.pop());
               char ch = s2.pop();
               cout << ch << '\n';
             }

    稭 믮 f(), 뢠  char_stack,
    ࠧ頥 ᨢ  100 ᨬ s1  ᨢ  200
   ᨬ s2.    f() ,  뫠  
   ᨢ, 㤥 ᢮.

   5.2.6 ⠭

   ணࠬ஢  ᠬ ।,   ணࠬ 
   ⢮ 쪨 㭪権.  , ,   ணࠬ 
   ࠤ樮 ࣠樥 﫮  筮 饭  
   , ᯮ 㭪. ,  뫮 ᮣ襭, ⠫
   ⠭⮬, ஢塞 ࠭஬.  १ ணࠬ
     ࠩ 䥪⨢.  맮 㭪樨  C++
     ⮫ ண   ࠢ  㣨
   몠, -⠪ 業   , 祬   饭  ,
   ⠢ ⥫ ਢ쭮 㭪樨.
       ८  㤭  㭪樨-⠭ (inline).
   ᫨  ᠭ  㭪-童 ।,   ⮫쪮 ᠭ,
     ⠥ ⠭.  , ਬ,  
   ࠭樨 㭪権, ᯮ char_stack  ।饣 ਬ,
    㤥 ᯮ짮  権 맮 㭪権, ஬
   ॠ樨 権 뢮! 㣨 ᫮,  ࠧࠡ⪥ ⠪
     㦭 ਭ     맮 㭪権.
   ,  ᠬ 쪮 ⢨,  ᬥ । 
   㭪   䥪⨢.  砭
   ᭨   ਢ     童
   .
       㭪-童    ᯥ䨪樥 inline   ᠭ
   :

             class char_stack {
                int size;
                char* top;
                char* s;
             public:
                char pop();
                // ...
             };

             inline char char_stack::pop()
             {
               return *--top;
             }

   ⬥⨬,  ⨬ 뢠 ࠧ । 㭪樨-童,
   饩 ⠭,  ࠧ 室 䠩 ($$R.7.1.2).
    訫  ⨥     楫쭮 ⨯.

   5.3 䥩  ॠ樨

    ।⠢ ᮡ 訩 ?  , 饥 
   । ⢮ 権. , ᬠਢ 
   " 騪", ࠢ   ⮫쪮 ।⢮ 
   権. ,  䠪᪮ ।⠢   
   ᫨ ᯮᮡ,     ⮬ ᯮᮡ ᯮ짮
   権. ,   ॡ  ᪮쪨 .
       祢 ਬ  ᮢ  ⥩ ࠧ :
   ⠡, ⢠, ᯨ᪨, , ᫮  .. 
      ᥭ  ⥩. 筮  
    ஢ન:    童 ᥭ  ⥩?
     樨 㯮冷稢  童  ᬮ 
    । 浪. ,    㤠
   童. 筮 ⥩     .

   5.3.1 ୠ⨢ ॠ樨

    ᠭ 饩    㭪権-童 ⠥ ,
   ,    짮⥫ ,   ॠ.
    ⢥ত ⮣ ᬮਬ ⠡   ணࠬ
   , ਢ   3.   ⠪:

              struct name {
                char* string;
                name* next;
                double value;
              };

     ਠ  table (⠡ ):

              // 䠩 table.h
              class table {
                 name* tbl;
              public:
                 table() { tbl = 0; }

                 name* look(char*, int = 0);
                 name* insert(char* s) { return look(s,1); }
              };

    ⠡ ⫨砥  ।   3 ⥬,  
   騩 ⨯.   ᪮쪮 ⠡,  㪠⥫
    ⠡  .. ਬ:

              #include "table.h"

              table globals;
              table keywords;
              table* locals;

              main()
              {
                locals = new table;
                // ...
              }

   ਢ ॠ 㭪樨 table::look(),  ன ᯮ
      ᯨ᪥  ⠡:

              #include <string.h>

              name* table::look(char* p, int ins)
              {
                for (name* n = tbl; n; n=n->next)
                    if (strcmp(p,n->string) == 0) return n;
                if (ins == 0) error("  ");

                name* nn = new name;
                nn->string = new char[strlen(p)+1];
                strcpy(nn->string,p);
                nn->value = 1;
                nn->next = tbl;
                tbl = nn;
                return nn;
              }

    ᮢ襭㥬  table ⠪, ⮡   襫
     (-㭪樨  ),    뫮 ᤥ  ਬ
    ஬.   㤭, ᫨ ᮡ ࠭祭,
   ॡ饥, ⮡   ணࠬ, ᯮ騥 ਢ 
    table,  뫮 :

               class table {
                  name** tbl;
                  int size;
               public:
                  table(int sz = 15);
                  ~table();

                  name* look(char*, int = 0);
                  name* insert(char* s) { return look(s,1); }
               };

              ந諨 ⮬,
     ஢ ⠡   । ࠧ.
      ⠭ 祭 ࠬ ࠭,
     ணࠬ,    ᯮ짮 ࠧ ⠡,
   ⠭ 묨. ⠭ 祭 ࠬ஢ 
    ⠪ ,  㦭  ,    ணࠬ
   짮⥫ .     ᮧ 
   㭨⮦ ஢ ⠡:

               table::table(int sz)
               {
                 if (sz < 0) error("ࠧ ⠡ ⥫");
                 tbl = new name*[size = sz];
                 for ( int i = 0; i<sz; i++) tbl[i] = 0;
               }

               table::~table()
               {
                 for (int i = 0; i<size; i++) {
                     name* nx;
                     for (name* n = tbl[i]; n; n=nx) {
                         nx = n->next;
                         delete n->string;
                         delete n;
                     }
                 }
                 delete tbl;
               }

   ᠢ    name,     
   ⮩ ਠ table::~table(). 㭪 ᪠ ࠪ᪨
   ᮢ  ਢ  ਬ  ($$3.13):

               name* table::look(const char* p, int ins)
               {
                 int ii = 0;
                 char* pp = p;
                 while (*pp) ii = ii<<1 ^ *pp++;
                 if (ii < 0) ii = -ii;
                 ii %= size;

                 for (name* n=tbl[ii]; n; n=n->next)
                     if (strcmp(p,n->string) == 0) return n;

                  name* nn = new name;
                  nn->string = new char[strlen(p)+1];
                  strcpy(nn->string,p);
                  nn->value = 1;
                  nn->next = tbl[ii];
                  tbl[ii] = nn;
                  return nn;
                }

   祢,  㭪樨-童   ࠭᫨஢ 直
   ࠧ,   ᠭ   - .  
   ⠪     ࠦ  짮⥫ .
    ᮦ, 筮 뢠  ⠪.  ࠧ饭 ६, 饩
   ⨯ , ࠭   ࠧ ꥪ . ᫨
   ࠧ ꥪ , 㦭 ࠭᫨஢ 䠩,  
   ᯮ짮 .   ⥬ ணࠬ (  
   㦥 ᠭ),  㤥 । 쭮 ⢮ 䠩,
    ࠭樨 ᫥  .  ⠪ ணࠬ
     稫 ப ࠭.
        : 祬 ++  ஥஢ ⠪ ࠧ,
    ᫥  ⭮   ॡ ࠭
   ணࠬ 짮⥫? 祬  ⭠  
     ᠭ ? 묨 ᫮, 祬 ᠭ
    童    䠩, 㯭
   짮⥫, ᫨  ࠢ 㯭    ணࠬ?
   ⢥  - 䥪⨢.   ⥬ ணࠬ஢
    ࠭樨  ᫥⥫쭮 , ந
   맮 㭪樨, 㤥 , ᫨ ࠧ ⮬᪨ (..
   ࠧ頥  ⥪) ꥪ⮢ ⥭  ⠤ ࠭樨.
         । ᥣ , ᫨ ।⠢ 
   ꥪ  㪠⥫  "騩" ꥪ.   
   , ᪮  㪠⥫    ࠧ, 
   ࠧ饭  ꥪ⮢ 㤥 ஢ ⮫쪮   䠩,
    ஬ 㯭   ᮢ. , ⠪ 襭
   ਢ  ⥫쭮 室    ꥪ 
   ⥫쭮 饭     ᯮ짮 童.
    㦥,   맮 㭪樨  ⮬᪨ ꥪ⮬
    ॡ 맮 㭪権 뤥  ᢮ .
    ⮬  ⠭  ॠ ⠭
   㭪権-童, ࠡ  묨 童 . ,
   ⠪  ᤥ  뢠 ணࠬ  ++  
   , ᪮ ࠭  㤥  㣮 ࠡ뢠 
   (struct). ⮬ ⠪ 襭 뫮 ⥭ ਥ  ++.
         㣮 ஭, ++ ।⠢ ।⢮  ᮧ
  ࠪ ⨯,     䥩ᮬ 짮⥫
   ॠ樥 쭮 ᫠.   6  ந
    뢠 ࠪ  ,   $$13.3 ,
      । ॠ ࠪ ⨯.  ⮣ -
    । 짮⥫᪨ ⨯ ⮫  䥪⨢
   ,   ⠭,   ᭮ ।⢠ ।
    ਠ⮢ ⨯,      ⮫
  䥪⨢묨.

  5.3.2 祭 ਬ 

  ணࠬ஢  뢠  (   )
  ॡ 襣 ।⥫쭮 뢠 , 祬
  ணࠬ஢  뢠  (   ).
    ।  祭 뢠  ⮬,  
   ᯮ짮.  । ,  業
   ⮬, ⮡ ᯥ   ⨯   権.
    ᬥ饭 業  ஥஢ ணࠬ. 筮
  ६, 祭  ࠧࠡ  ⨯, ⭮ 㯠
    ⫠  ࠧ ணࠬ.
      ਬ 祭 । ⨯ intset, ।⠢饣
  ⨥ "⢮ 楫":

             class intset {
               int cursize, maxsize;
               int  *x;
             public:
               intset(int m, int n);    //   m 楫  1..n
               ~intset();

               int member(int t) const; //   t 童?
               void insert(int t);      //    t

               void start(int& i) const { i = 0; }
               void ok(int& i) const    { return i<cursize; }
               void next(int& i) const  { return x[i++]; }
            };

   ஢ન ⮣  砫 ᮧ,  ⥬ ᯥ⠥
  ⢮ 砩 楫 ᥫ.  ⮥ ⢮ 楫
   ᯮ짮  ஢ન,   ७  
  ᫥⥫쭮.   設⢠  㦥, 筮,
   ࠧ ⨯ ⢠.  ᥣ  訡, ⮬
  㦭 㭪:

            #include <iostream.h>

            void error(const char *s)
            {
              cerr << "set: " << s << '\n';
              exit(1);
            }

       intset ᯮ  㭪樨 main(),  ன 
     ࠬ:  । ᫮ ᮧ
  砩 ᥫ,  ன -   祭:

            int main(int argc, char* argv[])
            {
              if (argc != 3) error("㦭   ࠬ");
              int count = 0;
              int m = atoi(argv[1]);    // ᫮ ⮢ ⢠
              int n = atoi(argv[2]);    //   1..n
              intset s(m,n);

              while (count<m) {
                int t = randint(n);
                if (s.member(t)==0) {
                    s.insert(t);
                    count++;
                }
              }

              print_in_order(&s);
            }

        祭 稪 ࠬ஢ ணࠬ argc ࠢ 3, 
   ணࠬ  ⮫쪮  ࠬ.   ⮬,   argv[0]
   ᥣ । ⥫ ࠬ, ᮤঠ騩  ணࠬ.
   㭪

            extern "C" int atoi(const char*)

    ⠭⭮ 筮 㭪樥, ८ࠧ饩 楫 
   ப ।⠢  ७  .  筮,
   ᫨     ⠪ ᠭ  ᢮ ணࠬ,  
       ᮮ⢥騩  䠩, ᮤঠ騩
   ᠭ ⠭  㭪権. 砩 ᫠
      ⠭⭮ 㭪樨 rand:

              extern "C" int rand();  //  ஦:
                                      // ᫠  ᮢᥬ 砩
              int randint(int u)      //  1..u
              {
                int r = rand();
                if (r < 0) r = -r;
                return 1 + r%u;
              }

   ஡ ॠ樨     짮⥫,
      砥  ᯮ짮 㭪樨-童.
    ࠧ頥 ᨢ 楫  ࠧ஬, ࠢ 
   ᨬ쭮 ࠧ ⢠,   㤠  ᨢ:

            intset::intset(int m, int n)  //   m 楫  1..n
            {
              if (m<1 || n<m) error("⨬ ࠧ intset");
              cursize = 0;
              maxsize = m;
              x = new int[maxsize];
            }

            intset::~intset()
            {
              delete x;
            }

     ⠪ ࠧ,   ࠭  ⢥
    饬 浪:

            void intset::insert(int t)
            {
              if (++cursize > maxsize) error("᫨誮  ⮢");
              int i = cursize-1;
              x[i] = t;

              while (i>0 && x[i-1]>x[i]) {
                 int t = x[i];     //  ⠬ x[i]  x[i-1]
                 x[i] = x[i-1];
                 x[i-1] = t;
                 i--;
              }
            }

   ⮡  , ᯮ ⮩  :

            int intset::member(int t) const  //  
            {
              int l = 0;
              int u = cursize-1;

              while (l <= u) {
                int m = (l+u)/2;
                if (t < x[m])
                   u = m-1;
                else if (t > x[m])
                   l = m+1;
                else
                   return 1;   // 
              }
              return 0;        //  
            }

       , 㦭 ।⠢ 짮⥫  権,  
       ࣠     ஬
   浪 ( 冷, ᯮ㥬  ।⠢ intset,
     ). ⢮  ᢮    ७
   㯮冷祭,     롨  ᨢ
   (   intset 㤥 ॠ   易 ᯨ᪠?).
       짮⥫ 砥  㭪樨: start() -  樠樨
   樨, ok() -  ஢ન,   ᫥騩 ,  next() -
    祭 ᫥饣 :

             class intset {
                // ...
                void start(int& i) const   { i = 0; }
                int ok(int& i) const       { return i<cursize; }
                int next(int& i) const     { return x[i++]; }
             };

   ⮡ ᯥ ᮢ ࠡ   権,  
    ,  ஬ ⠭ .  ⮣ 짮⥫
     楫 ࠬ. ᪮  ।⠢ ⢠
   㯮冷祭, ॠ  権 ਢ쭠. 
    । 㭪 print_in_order:

             void print_in_order(intset* set)
             {
               int var;
               set->sart(var);
               while (set->ok(var)) cout << set->next(var) << '\n';
             }

   㣮 ᯮᮡ ஥    ਢ  $$7.8.


   5.4   

    ⮬ ࠧ ᠭ ⥫ ᢮⢠ . ᠭ
   ᯮᮡ ᯥ    童  㭪,  
   童 ($$5.4.1). ᠭ,  ࠧ   童
   ($$5.4.2)   ᤥ ᠭ ᮢ 묨 ($$5.4.3), 
    ⮬  ⥫쭮  ($$5.4.4).  ⨥
   ᪨ 童 (static),  ᯮ  ।⠢
   権  , ⭮  ᠬ ,    ⤥
    ꥪ⠬ ($$5.4.5).  蠥 ਬ஬, 뢠騬,
     ந ਬ饥 () ꥤ ($$5.4.6).

   5.4.1 

    ।  : vector ()  matrix ().
      뢠 ᢮ ।⠢,     権
    ࠡ  ꥪ⠬  ⨯. ⨬,  । 㭪,
   㬭   .   ।, 
        ᠬ  0  3,   
     ⮦  ᠬ  0  3.   ⠬
    ᯥ稢 㭪樥 elem(),  筠 㭪 
    .  ।  㭪 multiply
   (㬭) ᫥騬 ࠧ:

             vector multiply(const matrix& m, const vector& v);
             {
               vector r;
               for (int i = 0; i<3; i++) { // r[i] = m[i] * v;
                   r.elem(i) = 0;
                   for (int j = 0; j<3; j++)
                       r.elem(i) +=m.elem(i,j) * v.elem(j);
               }
               return r;
             }

     ⢥ 襭,     祭
   䥪⨢.   맮 multiply() 㭪 elem() 㤥
   뢠 4*(1+4*3) ࠧ. ᫨  elem() ஢ 騩
   ஫ ࠭ ᨢ,   ⠪ ஫ 㤥 祭
   ⥫쭮  ६, 祬  믮 ᠬ 㭪樨,  
   १   ਣ  짮⥫.  㣮
   ஭, ᫨ elem()   ᯥ樠 ਠ 㯠 
   ஫,  ⥬ ᠬ  塞 䥩  ஬  楩
   ᮡ 㭪樥 㯠,  㦭 ⮫쪮  室 ஫.
       ᫨  뫮  ᤥ multiply 童  ᮢ
   vector  matrix,      ஫  
   饭   ,     ६   ᯥ樠쭮
   㭪樨 elem(). , 㭪    童  ᮢ.
      몥  ।⠢ 㭪樨,  饩
   童, ࠢ 㯠   童 . 㭪 -  童
   , -     ⮩ , 뢠 㣮
   ⮣ . 㭪   㣮 , ᫨  
   ᠭ  ᠭ  friend (). ਬ:

              class matrix;

              class vector {
                float v[4];
                // ...
                friend vector multiply(const matrix&, const vector&);
              };

              class matrix {
                vector v[4];
                // ...
                friend vector multiply(const matrix&, const vector&);
              };

   㭪-    ᮡ⥩,  ᪫祭 ࠢ
   㯠  ⮩  .  ⭮,  ⠪ 㭪樨
    ᯮ짮 㪠⥫ this, ᫨ ⮫쪮  ⢨⥫쭮
     童 . ᠭ friend  騬
   ᠭ.    㭪樨    ,
    ஬  뫠 ᠭ,   ⮬ ந室  ஢ન
    稥 㣨 ᠭ ⠪    ⮩ 
   . ᠭ friend  室   饩, ⠪  
   ⭮  ,    祭.
           㭪 multiply, ᯮ 
      ।⢥:

             vector multiply(const matrix& m, const vector& v)
             {
               vector r;
               for (int i = 0; i<3; i++) {  // r[i] = m[i] * v;
                   r.v[i] = 0;
                   for ( int j = 0; j<3; j++)
                       r.v[i] +=m.v[i][j] * v.v[j];
               }
               return r;
             }

        ⬥⨬,   㭪樨-童 㦥⢥ 㭪
    뢠  ᠭ ,   㦨. ⮬ 
    ꥬ  䥩  ࠢ 
   㭪樥-童.
        㭪-童     㣮 㣮 :

        class x {
           // ...
           void f();
        };

        class y {
           // ...
           friend void x::f();
        };

    ,   㭪樨    ﬨ
   㣮 .  ⮣  ⪠ ଠ :

          class x {
            friend class y;
            // ...
          };

    १ ⠪ ᠭ  㭪樨-童 y ⠭ ﬨ
    x.

   5.4.2 筥  童

       ࠧ稥   童 ᮢ
    稬 .  ⮣ ᯮ  :: (ࠧ襭
    ):

               class X {
                  int m;
               public:
                  int readm() const { return m; }
                  void setm(int m)  { X::m = m; }
              };

         㭪樨 X::setm() ࠬ m 뢠 童 m, ⮬  童
     , ⮫쪮 ᯮ 筥  X::m. ࠢ
    ࠭ 樨 ::    .
        稭饥  ::     .  ᮡ
      ᯮ짮 ⠪ ࠭   read, put,
    open, 묨   㭪樨-童,   
       㭪樨,  騥 童.
    ਬ:

              class my_file {
                 // ...
              public:
                 int open(const char*, const char*);
              };

              int my_file::jpen(const char* name, const char* spec)
              {
                // ...
                if (::open(name,flag)) {  // ᯮ open()  UNIX(2)
                   // ...
                }
                // ...
             }

    5.4.3  

    ᠭ    . ਬ:

             class set {
                struct setmem {
                   int mem;
                   setmem* next;
                   setmem(int m, setmem* n) { mem=m; next=n; }
                };
                setmem* first;
             public:
                set() { first=0; }
                insert(int m) { first = new setmem(m,first); }
                // ...
             };

   㯭   ࠭稢  
   ᪨ ꥬ饣 :

            setmem m1(1,0);  // 訡: setmem  室
                             //  쭮  

   ᫨ ⮫쪮 ᠭ     ᮢᥬ ,
     뢠   ⤥쭮, ᪮  ᠭ
     祭 ⠭묨:

           class setmem {
           friend class set;  // 㯭 ⮫쪮  童 set
             int mem;
             setmem* next;
             setmem(int m, setmem* n) { mem=m; next=n; }

             //  㣨  童
          };

          class set {
             setmem* first;
          public:
             set() { first=0; }
             insert(int m) { first = new setmem(m,first); }
             // ...
          };

    ᢮⢮  -  ᮪饭 ᫠  ,
    ⮪   ⮬,   蠥 ᢮ ᯮ짮
    ⨯ (. $$12.3).
       -童 ( )  ᯮ짮 
   ᠭ ꥬ饣   ⠪ ,    㣮
   童:

           class X {
              struct M1 { int m; };
           public:
              struct M2 { int m; };

              M1 f(M2);
          };

          void f()
          {   M1 a;      // 訡:  `M1'   
              M2 b;      // 訡:  `M1'   
              X::M1 c;   // 訡: X::M1  童
              X::M2 d;   // ଠ쭮
          }

   ⬥⨬,  ஫ 㯠 ந室    
   ᮢ.
        㭪樨-童    稭 ᫥
   筥 X::  ࠥ   ᠭ 㭪樨. ਬ:

         M1 X::f(M2 a)    // 訡:  `M1'   
            { /* ... */ }

        X::M1 X::f(M2 a)  // ଠ쭮
            { /* ... */ }

        X::M1 X::f(X::M2 a) // ଠ쭮,   筥 X:: 譥
            { /* ... */ }

   5.4.4 ᪨ 童

    -  ⨯,   ஥ ,    ꥪ
    ᮧ ᢮  童, ।⠢ . ,
    㤠筠 ॠ  ⨯ ॡ, ⮡ 
   ꥪ ⮣ ⨯   騥 . , ᫨ 
        . ਬ,  樮
   ⥬   ஢ ࠢ 砬  㦥
   ᯨ᮪ :

          class task {
             // ...
             static task* chain;
             // ...
          };

   ᠢ 童 chain  ᪨,  砥 ࠭, 
    㤥 ᮧ  ⢥ ᫥, ..  㤥 ᮧ
     ꥪ task.   室   
    task,    㯥  ⮩ , ᫨ ⮫쪮
   ᠭ  饩 .  ⮬ 砥  童  
    :

           if (task::chain == 0)  // - 

    㭪樨-童     chain. ᯮ짮
   ᪨ 童   ⭮ ᮪ ॡ 
    ६.
       뢠 童  ᪨,  ࠭稢  
       ᨬ  ⤥ ꥪ⮢ 
   .  ᢮⢮    㭪権-童, ⠪  
   童, ।⠢ :

           class task {
              // ...
              static task* task_chain;
              static void shedule(int);
              // ...
          };

       ᠭ ᪮ 童 -  ⮫쪮 ᠭ,  -
    ணࠬ   ⢥ ।  뢠
   ꥪ  㭪樨, ਬ, ⠪:

             task* task::task_chain = 0;
             void task::shedule(int p) { /* ... */ }

   ⢥,    童  ।  ࠧ.
       ⬥⨬,  㦥 ᫮ static  㦭   
   ᯮ짮  । ᪮ 童 . ᫨  
   ⢮,   筮: 㪠뢠    ,
    童   ᪨,  ᯮ 
   ᠭ 쭮 ꥪ  㭪樨?
        static   ᠬ ॣ㦥 㦥 ᫮  
    ++.  ᪮ 童, ।⠢饬 , ⭮
    ᭮  祭: "᪨ ࠧ頥" , ..
   ⨢ ꥪ⠬, ࠧ頥  ⥪  ᢮ ,
    "᪨"  ᫥  ࠭祭  , ..
   ⨢ ꥪ⠬, 騬 譥 뢠. 
   㭪-童 ⭮ ⮫쪮 ஥ 祭 static.

   5.4.5 ⥫  童

      童 .    㭪樨-童
    뢠 , ᪮ 楫  ᯮᮡ ਬ
   㪠⥫  㭪樨,    ਫ  $$4.6.9,  ࠢ
   ⥯ ⭮   ⠪ 㭪. ⥫  童  ,
   ਬ    &   筥 
   童 , ਬ, &class_name::member_name. ⮡ 
   ६ ⨯ "㪠⥫  童  X",  ᯮ짮
   ⥫  X::*. ਬ:

             #include <iostream.h>

             struct cl
             {
                char* val;
                void print(int x) { cout << val << x << '\n'; }
                cl(char* v) { val = v; }
             };

   ⥫  童    ᯮ짮 ⠪:

            typedef void (cl::*PMFI)(int);

            int main()
            {
              cl z1("z1 ");
              cl z2("z2 ");
              cl* p = &z2;
              PMFI pf = &cl::print;
              z1.print(1);
              (z1.*pf)(2);
              z2.print(3);
              (p->*pf)(4);
            }

   ᯮ짮 typedef   㤭 ਭ ⥫
     筮 ⨯ 砩. 樨 .*  ->* ࠨ
   㪠⥫   ꥪ, 뤠  १ 㭪,
     뢠. ਮ 樨 () , 祬  権
   .*  ->*, ⮬ 㦭 ᪮.
          㠫 㭪樨 ($$6.2.5) ᯥ譮
    㪠⥫  㭪樨.

   5.4.6   ꥤ

    ।  -  ,  童 ண 騥,
   .. ᠭ

           struct s { ...

     ⪠ ଠ ᠭ

           class s { public: ...

    ꥤ ।  ,  童
   ன       ($$R.9.5). ᫨ ⭮, 
      ६ ᯮ 祭 ⮫쪮  童
   ,    ꥤ,   .
   ਬ,  ᯮ짮 ꥤ  ࠭ ᥬ
   ࠭ :

            union tok_val {
               char* p;      // ப
               char v[8];    // 䨪 (  8 ᨬ)
               long i;       // 祭 楫
               double d;     // 祭 ᥫ  饩 窮
            };

   ஡  ꥤﬨ  ⮬,  ࠭  饬 砥
    ,  童 ᯮ   ,  ⮬
   ஫ ⨯ . ਬ:

             void strange(int i)
             {
               tok_val x;
               if (i)
                  x.p = "2";
               else
                  x.d = 2;
               sqrt(x.d);     // 訡, ᫨ i != 0
             }

   ஬ ⮣, । ⠪ ࠧ ꥤ 
   樠஢ ⠪ 騬  ⢥ ᯮᮡ:

             tok_val val1 = 12;   // 訡: int ᢠ  tok_val
             tok_val val2 = "12"; // 訡: char* ᢠ tok_val

    ࠢ쭮 樠樨  ᯮ짮 :

             union tok_val {
               char* p;    // ப
               char v[8];  // 䨪 (  8 ᨬ)
               long i;     // 祭 楫
               double d;   // 祭 ᥫ  饩 窮

               tok_val(const char*);  // 㦭 롨  p  v
               tok_val(int ii)    { i = ii; }
               tok_val(double dd) { d = dd; }
             };

    ᠭ  ࠧ   ⨯ 童 筮
    ॣ㧪  㭪樨 (. $$4.6.6  $$7.3). ਬ:

             void f()
             {
               tok_val a = 10;    // a.i = 10
               tok_val b = 10.0;  // b.d = 10.0
             }

   ᫨   (ਬ,  ⨯ char*  char[8]  int
    char  ..),  ।,  童 樠, ,
   稢 樠  믮 ணࠬ,  
   ⥫ ࠬ. ਬ:

             tok_val::tok_val(const char* pp)
             {
               if (strlen(pp) <= 8)
                  strncpy(v,pp,8);    // ⪠ ப
               else
                  p = pp;            //  ப
             }

      筮 .
       ⠭⭠ 㭪 strncpy()  strcpy() 
   ப,     ⥫ ࠬ, 騩
   ᨬ쭮 ᫮ 㥬 ᨬ.
       ,   樠樨 ꥤ ᯮ ,
     ࠭  砩 訡  ࠡ  ꥤ, 
   ᢠ 祭  ⨯,  롨ࠥ 祭 㣮
   ⨯.  ࠭  , ᫨  ꥤ
    ,  ஬ 㤥 ᫥ ⨯ ᨬ 祭 :

            class tok_val {
            public:
               enum Tag { I, D, S, N };

            private:
               union {
                 const char* p;
                 char v[8];
                 long i;
                 double d;
               };

               Tag tag;

               void check(Tag t) { if (tag != t) error(); }
             public:
               Tag get_tag() { return tag; }

               tok_val(const char* pp);
               tok_val(long ii)   { i = ii; tag = I; }
               tok_val(double dd) { d = dd; tag = D; }

               long& ival()        { check(I); return i; }
               double& fval()      { check(D); return d; }
               const char*& sval() { check(S); return p; }
               char* id()          { check(N); return v; }
            };

            tok_val::tok_val(const char* pp)
            {
              if (strlen(pp) <= 8)  { // ⪠ ப
                 tag = N;
                 strncpy(v,pp,8);
              }
              else {                  //  ப
                 tag = S;
                 p = pp;              // 뢠 ⮫쪮 㪠⥫
              }
            }

   ᯮ짮  tok_val  ⠪:

            void f()
            {
              tok_val t1("⪠");       // ᢠ v
              tok_val t2(" ப"); // ᢠ p
              char s[8];
              strncpy(s,t1.id(),8);         // ଠ쭮
              strncpy(s,t2.id(),8);         // check() 뤠 訡
            }

       ᠢ ⨯ Tag  㭪 get_tag()  饩 ,  ࠭㥬,
    ⨯ tok_val  ᯮ짮  ⨯ ࠬ.  ࠧ,
      ᫥ ⨯ ୠ⨢ ᠭ ࠬ஢
    ᮬ. , ਬ, ᠭ 㭪樨 ࠡ⪨ 訡,
      , ,   ࠬ  ⨯ char*,
   int  double:

             extern tok_val no_arg;

             void error(
                 const char* format,
                 tok_val a1 = no_arg,
                 tok_val a2 = no_arg,
                 tok_val a3 = no_arg);


   5.5   

   ᫨    ,  뢠 直 ࠧ 
   ᮧ ꥪ ⮣ . ᫨    ,
    뢠 直 ࠧ,  㭨⮦ ꥪ ⮣ .
   ꥪ  ᮧ :
     [1] ⮬᪨,  ᮧ  ࠧ,  
         ᠭ 砥  믮 ணࠬ,  㭨⮦
          室  ,  ஬  ᠭ;
     [2] ᪨,  ᮧ  ࠧ  ᪥ ணࠬ
          㭨⮦   襭;
     [3] ꥪ  ᢮ ,  ᮧ 樥 new
          㭨⮦ 樥 delete;
     [4] ꥪ-童,  ᮧ   ᮧ 㣮
            ᮧ ᨢ, ⮬ ண 
         .
   ஬ ⮣ ꥪ  ᮧ, ᫨  ࠦ 
   ᯮ   ($$7.3)   ६ ꥪ
   ($$R.12.2).    ⠪ ꥪ   .  ᫥
   ࠧ ।,  ꥪ ⭮   
   ஬  ஬.  ⢥ ਬ ᯮ
    table  $$5.3.1.

   5.5.1  ६

    쭮 ६ 뢠  ࠧ,  
   믮 ணࠬ 砥  ᠭ.  쭮
   ६ 뢠 直 ࠧ  室  ,  
   뫠 ᠭ.    ६ 뢠 
   浪, ⭮ 맮 ஢   ᮧ:

            void f(int i)
            {
              table aa;
              table bb;
              if (i>0) {
                  table cc;
                  // ...
              }
              // ...
            }

    aa  bb ᮧ (  ⠪ 浪)   맮
   f(),  㭨⮦     f()  ⭮ 浪 -
   bb, ⥬ aa. ᫨  ⥪饬 맮 f() i  ,  cc
   ᮧ ᫥ bb  㭨⮦ ० .
       ᪮ aa  bb - ꥪ  table, ᢠ aa=bb
   砥 ஢  童 bb  aa (. $$2.3.8). 
    ᢠ  ਢ   ( 筮
   ⥫쭮) १, ᫨ ᢠ ꥪ ,
    ஬ । :

             void h()
             {
                table t1(100);
                table t2 = t1;   // ⭮
                table t3(200);

                t3 = t2;         // ⭮
             }

    ⮬ ਬ  table 뢠 :  t1  t3.
     뢠  t2, ᪮  ꥪ 樠
   ᢠ.   ,   table 뢠 
   ࠧ:  t1, t2  t3! , ⠭⭠ 
   ᢠ -  ஢  童, ⮬ । 室
    h() t1, t2  t3  ᮤঠ 㪠⥫  ᨢ , 
    ண 뫠 뤥  ᢮   ᮧ t1.
   ⥫  , 뤥  ᨢ   ᮧ
   t3, 㤥 .  ⭮⥩   (. $$1.4.2
    $$7.6).

   5.5.2 ᪠ 

   ᬮਬ ⠪ ਬ:

          table tbl(100);

          void f(int i)
          {
             static table tbl2(i);
          }

          int main()
          {
            f(200);
            // ...
          }

    , ।  $$5.3.1, 㤥 뢠 :
    ࠧ  tbl   ࠧ  tbl2.  table::~table()
   ⠪ 㤥 맢 :  㭨⮦ tbl  tbl2  室
    main().   ᪨ ꥪ⮢  䠩
   뢠  ⮬  浪,     䠩
   ᠭ ꥪ⮢,     뢠  ⭮
   浪.  쭮 ᪮ ꥪ 뢠,
     믮 ணࠬ  ࠧ 砥 ।
   ꥪ.
       ࠤ樮 믮 main() ᬠਢ  믮
   ᥩ ணࠬ.  ᠬ ,   ⠪   . 
   ࠧ饭 ᪮ ꥪ   ஬  ()
   ஬  ணࠬ  ⢨, 
    믮  맮 main()   ()  室  main().
      맮 ஢  ஢  ᪨ ꥪ⮢
   ࠥ  ++ १砩  ஫.     ᯥ
   ᮮ⢥ 樠  㤠  ,
   ᯮ㥬  ⥪. ᬮਬ <iostream.h>. 㤠
    cin, cout  cerr?   樠? 
   ⢥ : ᪮  室 ⮪ ᯮ
   ७  ᨬ,  ந室 ⠫ 
   ஢,  ?  ⮩  祢 ⢥:  ⢨
   믮 ᮮ⢥騬 ࠬ  ࠬ 
   ᪠ main()   室   (. $$10.5.1).  ୠ⨢
   ᯮ짮 ஢  ஢  樠樨 
   㭨⮦   ,     祭
   ᯥ樠஢,  㪫,     㣮 .
      ᫨ ணࠬ 蠥 饭  㭪樨 exit(), 
   뢠    ஥ ᪨ ꥪ⮢.
   , ᫨ ணࠬ 蠥 饭  abort(), ⮣
    ந室. ⨬,  exit()  蠥
   ணࠬ . 맮 exit()    ਢ
    ᪮筮 ४ᨨ. ᫨ 㦭 ࠭,   㭨⮦
    ᪨, ⠪  ⮬᪨ ꥪ,  ᯮ짮
   ᮡ묨 ﬨ ($$9).
        ࠧࠡ⪥ ⥪ 뢠 室  
   㤮 ᮧ ⨯  ஬  ஬ ⮫쪮 
    楫: 樠樨  㭨⮦ ꥪ⮢.  ⨯
   ᯮ ⮫쪮  ࠧ  ࠧ饭 ᪮ ꥪ,
   ⮡ 맢   .

   5.5.3  

   ᬮਬ ਬ:

            main()
            {
               table* p = new table(100);
               table* q = new table(200);
               delete p;
               delete p;  // ⭮, 맮 訡  믮
             }

    table::table() 㤥 뢠 ,   
   table::~table().   祣  , ..  ++ 
   ࠭,   㤥 뢠 ⮫쪮  ꥪ,
   ᮧ 樥 new.  ⮬ ਬ q  㭨⮦ ,
    p 㭨⮦ !  ᨬ  ⨯ p  q ணࠬ
         訡. ,  ꥪ 
   㤠, 筮 뢠  訡,   ३ .   
   ६ ୮ 㤠 p - 쥧 訡. ୮ ਬ
   delete  ⮬  ᠬ 㪠⥫  ਢ  ᪮筮
   横  ணࠬ, ࠢ饩 ᢮ .   몥
   १ ୮ 㤠  ।,    
   ॠ樨.
       짮⥫  । ᢮ ॠ 権 new 
   delete (. $$3.2.6  $$6.7). ஬ ⮣,  ⠭
   ⢨     ﬨ new 
   delete (. $$5.5.6  $$6.7.2). 饭 ᨢ  ᢮
    㦤  $$5.5.5.

   5.5.4 ꥪ   童

   ᬮਬ ਬ:

            class classdef {
               table members;
               int no_of_members;
               // ...
               classdef(int size);
               ~classdef();
            };

    ⮣ ।, 祢,  ⮬, ⮡ classdef ᮤঠ
   童, 騩 ⠡楩 ࠧ஬ size,   ᫮: 
   ᯥ 맮  table::table()  ࠬ஬ size. 
    ᤥ, ਬ, ⠪:

           classdef::classdef(int size)
              :members(size)
           {
              no_of_members = size;
              // ...
            }


   ࠬ   童 (..  table::table()) 㪠뢠
    । (   ᠭ)  , ᮤঠ饣
   童 (..  । classdef::classdef()).  
   童 㤥 뢠  믮 ⥫ ⮣ , 
      ᯨ᮪ ࠬ஢.
       筮   ࠬ  ஢ 㣨 童
   (᫨   㣨 童):

             class classdef {
               table members;
               table friends;
               int no_of_members;
               // ...
               classdef(int size);
               ~classdef();
             };

   ᪨ ࠬ஢  童 ⤥   㣠 묨 ( 
   ﬨ),  ᯨ᮪ 樠஢  童   
   ந쭮 浪:

             classdef::classdef(int size)
                 : friends(size), members(size), no_of_members(size)
             {
               // ...
             }

    뢠  ⮬ 浪,  ஬   
   ᠭ .
        ᠭ ஢ ⢥  ⨯,
   樠  ᢠ  ⫨   㣠, 묨
   ᫮,  ꥪ⮢,  童   ஬,
    ﭭ 童   童 ⨯ 뫪. , 
   뢠 童 no_of_members  ਢ ਬ, ⠪
   ᠭ ஢  ᯮ짮  童 
   ⨯.
       ᫨  童  ॡ ࠬ஢,    㦭
     ᯨ᪮ ࠬ஢. , ᪮ 
   table::table()  ।  ⠭ 祭 ࠬ,
   ࠢ 15, 筮 ⠪ ।:

            classdef::classdef(int size)
                : members(size), no_of_members(size)
            {
               // ...
            }

    ࠧ ⠡ friends 㤥 ࠢ 15.
        ᫨ 㭨⮦ ꥪ ,  ᠬ ᮤন ꥪ
    (ਬ, classdef),  砫 믮 ⥫
    ꥬ饣 ,  ⥬  童  浪,
   ⭮  ᠭ.
        ᬮਬ  宦 ꥪ⮢   ⢥ 童
   ࠤ樮 ୠ⨢  襭:    㪠⥫
    童  樠஢ 童  :

             class classdef {
                table* members;
                table* friends;
                int no_of_members;
                // ...
             };

            classdef::classdef(int size)
            {
               members = new table(size);
               friends = new table;  // ᯮ ⠭
                                     // ࠧ table
               no_of_members = size;
               // ...
             }

   ᪮ ⠡ ᮧ   樨 new,  
   㭨⮦ 樥 delete:

            classdef::~classdef()
            {
              // ...
              delete members;
              delete friends;
            }

    ⤥쭮 ᮧ ꥪ   묨, 
   ,  members  friends 㪠뢠  ᨬ  
   ꥪ,      ࠧ  㤠. ஬
   ⮣, 㪠⥫  ꥪ  ᢮  㬬୮ 
    , 祬 ꥪ-童.

   5.5.5 ᨢ ꥪ⮢ 

   ⮡  뫮  ᨢ ꥪ⮢   ஬,
       ⠭ , .. ,
   뢠  ࠬ஢. ਬ,  ᮮ⢥⢨  ।

            table tbl[10];

   㤥 ᮧ ᨢ  10 ⠡,    樠
   맮 table::table(15), ᪮ 맮 table::table() 㤥
   ந室  䠪᪨ ࠬ஬ 15.
        ᠭ ᨢ ꥪ⮢  ।ᬮ७  㪠
   ࠬ  . ᫨ 童 ᨢ 易⥫쭮 
   樠஢ ࠧ묨 祭ﬨ,  稭  
   묨  ᪨ 童.
        㭨⮦ ᨢ,   뢠 
     ᨢ.  ᨢ,  ࠧ 
     new,   .   ࠧ饭  ᢮
    ᨢ  뢠  , ᪮ ࠭
    ⫨ 㪠⥫  ⤥ ꥪ ᨢ  㪠⥫  砫
   ᨢ, ਬ:

            void f()
            {
              table* t1 = new table;
              table* t2 = new table[10];
              delete t1;  // 㤠  ⠡
              delete t2;  // ⭮:
                          //  ᠬ  㤠 10 ⠡
            }

     砥 ணࠬ  㪠,  t2 - 㪠⥫
    ᨢ:

            void g(int sz)
            {
              table* t1 = new table;
              table* t2 = new table[sz];
              delete t1;
              delete[] t2;
            }

      㭪 ࠧ饭 ࠭ ᫮ ⮢   ࠧ頥
   ᨢ. ॡ ᯮ짮  㤠 ᨢ ⮫쪮 
   delete[] ᢮ 㭪 ࠧ饭  易 ࠭ 稪
   ᫠ ⮢   ᨢ. ᯮ ⠪ 易 
   ॠ ++ 뢠  ⢥  ६  
    訫 ᮢ⨬  .

   5.5.6 訥 ꥪ

   ᫨  襩 ணࠬ   ꥪ⮢, ࠧ頥 
   ᢮ ,   ,   ६ 
    ࠧ饭  㤠 ⠪ ꥪ⮢.  室  ⮩
   樨  ।  ⨬ ।⥫ 
   饣 祭,   । 易 ।
   ᢮  ᮧ⥫ ,   㤥
   । ᮮ⢥騥 㭪樨 ࠧ饭  㤠.
        ୥   name,  ᯮ짮  ਬ 
   table.    । ⠪:

            struct name {
               char* string;
               name* next;
               double value;

               name(char*, double, name*);
               ~name();

               void* operator new(size_t);
               void operator delete(void*, size_t);
             private:
               enum { NALL = 128 };
               static name* nfree;
             };

   㭪樨 name::operator new()  name::operator delete() 
   ᯮ짮 ()   㭪権 operator new()
    operator delete(). ணࠬ   ⭮ ⨯ 
    䥪⨢  ६   㭪樨 ࠧ饭 
   㤠, 祬 㭨ᠫ 㭪樨 operator new() 
   operator delete(). , ਬ, ࠧ ࠭ "᪨"
   , 筮  ꥪ⮢ ⨯ name,  易   ᯨ᮪;
   ⮣ 樨 ࠧ饭  㤠 ᢮   
    ᯨ᪮. ६ nfree ᯮ  砫 ᯨ᪠
   ᯮ짮 ᪮ :

              void* name::operator new(size_t)
              {
                register name* p = nfree;  // ᭠砫 뤥

                if (p)
                   nfree = p->next;
                else {                // 뤥  易  ᯨ᮪
                   name* q = (name*) new char[NALL*sizeof(name) ];
                   for (p=nfree=&q[NALL-1]; q<p; p--) p->next = p-1;
                   (p+1)->next = 0;
                }

                return p;
              }

   ।⥫ , 뢠 new, ࠭   ꥪ⮬ 
   ࠧ, ⮡  delete 믮﫠 ࠢ쭮. ⮣
   ⥫쭮 室    , ᫨
   ᯮ짮 ।⥫, ⠭   ⨯. ,
    設  㭪 name::operator new()  ࠭ ꥪ
   name ᯮ 16 ⮢, ⮣  ⠭⭠ 쭠
   㭪 operator new() ᯮ 20 ⮢.
       ⬥⨬,   ᠬ 㭪樨 name::operator new()  
   뤥 ⠪  ᯮᮡ:

            name* q= new name[NALL];

    맮 ᪮ ४, .. new 㤥 뢠
   name::name().
       ᢮  筮 ਢ쭮:

            void name::operator delete(void* p, size_t)
            {
               ((name*)p)->next = nfree;
               nfree = (name*) p;
            }

   ਢ ࠬ ⨯ void*  ⨯ name* 室, ᪮
   㭪 ᢮ 뢠 ᫥ 㭨⮦ ꥪ, ⠪ 
     ॠ쭮 ꥪ ⨯ name,   ⮫쪮 ᮪
    ࠧ஬ sizeof(name). ࠬ ⨯ size_t  ਢ
   㭪 name::operator new()  name::operator delete() 
   ᯮ짮.    ᯮ짮, 㤥   $$6.7.
   ⬥⨬,   㭪樨 ࠧ饭  㤠 ᯮ
   ⮫쪮  ꥪ⮢ ⨯ name,    ᨢ names.

   5.6 ࠦ

   1. (*1)  ணࠬ    3 ⠪, ⮡
       뫮 ᯮ짮 ᮬ table.
   2. (*1) । tnode ($$R.9)    ࠬ 
      ࠬ  .., । ॢ  ꥪ⮢ ⨯
      tnode    ࠬ  ࠬ  ..
   3. (*1) ।  intset ($$5.3.2)  ⢮ ப.
   4. (*1) ।  intset  ⢮ 㧫 ⨯ tnode.
       tnode ਤ㬠 ᠬ.
   5. (*3) ।   ࠧ, ࠭, ᫥  
       䬥᪨ ࠦ,   楫 ⠭ 
      権 +, -, *  /. 騩 䥩   룫拉
      ਬ୮ ⠪:

              class expr {
                // ...
              public:
                expr(char*);
                int eval();
                void print();
              };

       expr::expr()  ࠬ-ப,  ࠦ.
      㭪 expr::eval() 頥 祭 ࠦ,  expr::print()
      뤠 ।⠢ ࠦ  cout. ᯮ짮  㭪樨
       ⠪:

              expr("123/4+123*4-3");
              cout << "x = " << x.eval() << "\n";
              x.print();

         ।  expr:   ࢮ  ।⠢
       ᯮ 易 ᯨ᮪ 㧫,   ஬ - ப
       ᨬ. ᯥਬ  ࠧ묨 ଠ⠬ 
       ࠦ,  :   ⠢묨 ᪮,
        䨪᭮ ,  ᥬ୮   ..
   6. (*1) ।  char_queue (। ᨬ) ⠪, ⮡
       騩 䥩  ᥫ  ।⠢. 
       : (1) 易 ᯨ᮪  (2) .  ࠫ쭮
       㬠.
   7. (*2) ।  histogram (⮣ࠬ),  ஬ 
       ᥫ  । ࢠ,   
      ࠬ஢  ⮣ . । 㭪
      뤠 ⮣ࠬ.  ࠡ 祭, 室 
      ࢠ. ᪠:   <task.h>.
   8. (*2) । ᪮쪮 ᮢ, ஦ 砩 ᫠
       ।묨 ।ﬨ.    
      , 騩 ࠬ ।  㭪 draw,
       "᫥饥" 祭. ᪠:  
      <task.h>   intset.
   9. (*2) ९ ਬ date ($$5.2.2  $$5.2.4), char_stack
      ($$5.2.5)  intset ($$5.3.2),  ᯮ  㭪権-童
      ( ஢  ஢).  ᯮ ⮫쪮 class
       friend. ஢    ᨩ  ࠢ 
       ﬨ,   ᯮ 㭪樨-童.
   10.(*3)  ண 몠 ⠢ ।   ⠡
        , ।⠢饣   ⮩ ⠡. ᫥
      ࠭  ⮣ 몠, ⮡ 㧭,    
      ⠡ .
   11.(*2)   expr  ࠦ 5 ⠪, ⮡  ࠦ
       뫮 ᯮ짮 ६   ᢠ =.
      ᯮ   ⠡   ࠦ 10.
   12.(*1)   ணࠬ:

             #include <iostream.h>

             main()
             {
                cout << "ᥬ ਢ\n";
             }

        ⠪, ⮡  뤠:
             樠
             ᥬ ਢ
             
      㭪 main()  .

