

                       2

                    


                  "襭⢮ ⨦ ⮫쪮  
                   ".

                                   (.. નᮭ)


    ᠭ ᭮ ⨯ (char,  int, float  ..) 
 ᯮᮡ ஥   ᭮  ⨯ (㭪権, ஢, 㪠⥫
  ..). ᠭ   ணࠬ , 㪠  ⨯ , ,
 砫쭮 祭.  ⮩   ⠪ ,  ᠭ 
 ।, ⨯,   , ६  ꥪ⮢.
  祭 ࠫ ⠭ ++  ᯮᮡ 
 ᨬ᪨ ⠭. ਢ ਬ,  
   몠.  ᫥ ਬ, 騥
  ࠦ  ஢ 몠 ++,  ਢ  ᫥饩
 .  ⮩   㯮 ।⢠  ।
 짮⥫᪨ ⨯  権  .  㦤   5  7.



 2.1  

  (䨪) ᫥  ०, 祬  㤥 ᯮ짮
  ணࠬ   ++.  砥,  㦭 㪠  ⨯, ⮡
 ࠭ ,    ꥪ⠬ ⭮ .  ਢ
  ᪮쪮 ਬ஢,   ࠧࠧ ᠭ:

     char ch;
     int count = 1;
     char* name = "Njal";
     struct complex { float re, im; };
     complex cvar;
     extern complex sqrt(complex);
     extern int error_number;
     typedef complex point;
     float real(complex* p) { return p->re; };
     const double pi = 3.1415926535897932385;
     struct user;
     template<class T> abs(T a) { return a<0 ? -a : a; }
     enum beer { Carlsberg, Tuborg, Thor };

    ਬ஢ ,  ஫ ᠭ  ᢮   ਢ離
  ⨯  . 設⢮ 㪠 ᠭ ६ 
  ।ﬨ, ..  ᮧ ꥪ,   뫠 .
    ch, count, name  cvar ⠪ ꥪ⮬    
   ᮮ⢥饣 ࠧ.   㤥 ᯮ짮 
   ६,  ,    ⢥ .  real 
   ꥪ⮬ 㤥  㭪.
    ⠭ pi ꥪ⮬ 㤥 ᫮ 3.1415926535897932385.
    complex ꥪ⮬ 㤥  ⨯.  point ꥪ⮬ 
   ⨯ complex, ⮬ point ⠭ ᨭ  complex. 騥
   ᠭ 㦥   ।ﬨ:

     extern complex sqrt(complex);
     extern int error_number;
     struct user;

    砥,  ꥪ,  ,   ।
   -  㣮  ணࠬ.  㭪樨 sqrt   㪠
    - 㣮 ᠭ.   ६ error_number ⨯
   int  뤥  १ 㣮 ᠭ error_number.
      - 㣮 ᠭ ⨯ user,   ண  
   ,    ⨯.  ணࠬ  몥 ++   ⮫쪮
    ।  ,  ᠭ   .  
   ᠭ   ᮣᮢ  ⨯    ꥪ.
   ⮬  ਢ  ࠣ ᮤঠ  訡:

     int count;
     int count;               // 訡: ८।

     extern int error_number;
     extern short error_number; // 訡: ᮮ⢥⢨ ⨯

     ᫥饬 ࠣ    訡 ( ᯮ짮
   extern . #4.2):

    extern int error_number;
    extern int error_number;


    ᠭ 㪠뢠 "祭"  ꥪ⮢,  
  ।:

    struct complex { float re, im; };
    typedef complex point;
    float real(complex* p) { return  p->re };
    const double pi = 3.1415926535897932385;

   ⨯, 㭪権  ⠭ "祭" ⠥ ;
   ,   ⠭⠬, 砫쭮 祭 
  ᫥⢨ :

     int count = 1;
     char* name = "Bjarne";
     //...
     count = 2;
     name = "Marian";

       । ⮫쪮 ᫥饥   祭:

      char ch;

   类 ᠭ, ஥  祭,  ।.


   2.1.1   

  ᠭ ।   .  , 
    ᯮ짮 ⮫쪮  ।  ⥪ ணࠬ.
  ᫨  ᠭ  㭪樨 (筮  뢠 " "), 
     ࠥ  窨 ᠭ
    ,  ஬   ᠭ. ᫨   室
   ᠭ 㭪樨   ( 筮 뢠 " "),
     ࠥ  窨 ᠭ   䠩,
   ஬   ᠭ.
  ᠭ     뢠 ᠭ  ꥬ饬  
  쭮 ; ..    ८। ⠪,   㤥
   㣮 ꥪ  . ᫥ 室   ०
  祭  (᫨  뫮) ⠭. ਢ ਬ:

  int x;            // 쭮 x

  void f()
  {
      int x;        // 쭮 x 뢠 쭮 x
      x = 1;        // ᢮ 쭮 x
      {
          int x;    // 뢠 ࢮ 쭮 x
          x = 2;    // ᢮ ஬ 쭮 x
      }
      x = 3;        // ᢮ ࢮ 쭮 x
  }

  int* p = &x;      //   쭮 x


      ணࠬ   ८। .  ᮦ,
  祫   ண拉 ⠪ ८।. 騥
  - ⮣ 訡  ,  ⮬,  
  筮 ।. ⥫쭮, ८।  ᫥
  ᢥ  . ᫨  砥  ६ 
   ६  让 㭪樨 ⠪ ,  i  x,
   ᠬ 訢  ⭮.
        樨 ࠧ襭  
  ::   ⮬ 쭮 , ਬ:

     int x;

     void f2()
     {
       int x = 1;      // 뢠 쭮 x
       ::x = 2;        // ᢠ 쭮 x
     }

     ᯮ짮 ⮥ 쭮  .
       稭  窥  ᠭ (
  砭 ⥫,    砫 樠 - . $$R.3.2). 
  砥,    ᯮ짮   ⮣,   
  砫쭮 祭. ਬ:

     int x;

     void f3()
     {
        int x = x;    // 訡筮 ᢠ
      }

    ᢠ ⨬  襭 ᫠. ᫨  ⠥
   ࠭᫨஢  ணࠬ,   ।०: "ᯮ짮
     祭".   ⥬,  ਬ  ::, 
   ᯮ짮       祭  ࠧ ꥪ⮢
   . ਬ:

      int x = 11;

      void f4()         // 饭 ਬ
      {
        int y = x;   //  쭮 x
        int x = 22;
        y = x;       // 쭮 x
      }

   ६ y 樠 祭 쭮 x, .. 11,
    ⥬  ᢠ 祭 쭮 ६ x, .. 22.
     ଠ ࠬ஢ 㭪樨  ᠭ묨  ᠬ
   讬  㭪樨, ⮬  ᠭ   訡:

      void f5(int x)
      {
        int x;       // 訡
       }

    x ।     ⮩     .
       ᫨誮 ।,  쭮 ⮭ 訡.

   2.1.2  ꥪ  

    뤥   "६",    , 
   ᯮ짮  ६.
     ᢠ ⠪ ࠭ 룫騬 "६",
   ਬ, *p[a+10]=7. ⥫쭮,  ॡ 
   " ࠭饥  ".  ਢ 室  
   ࠢ筮 㪮⢠: " ꥪ -   
   ,  ᮬ 뢠 ࠦ, 뫠饥  ꥪ 
   㭪" ($$R.3.7).   (lvalue - left value, .. 稭
   ᫥) ࢮ砫쭮 ਯ뢠  ",   
   ᢠ  ᫥".   뫠   ⠭
   (. $$2.5). ,    ᠭ  ᯥ䨪樥 const,
   뢠 塞 ᮬ.

     2.1.3  ६  ꥪ⮢

   ᫨ ⮫쪮 ணࠬ  蠥 , ꥪ 㤥 ᮧ 
     ।  㭨⮦,  祧 
    . ꥪ  묨  ᮧ,
   樠 (祬 ⮫쪮  ࠧ)    
   ணࠬ. ᫨  ꥪ ᠭ  㦥 ᫮
   static,   ⠪    ணࠬ. 樠 
   ந室,    ࠧ ࠢ "室 १"
   ᠭ  ꥪ⮢, ਬ:

      int a = 1;

      void f()
      {
        int b = 1;   // 樠   맮 f()
        static int c = a;  // 樠 ⮫쪮  ࠧ
        cout << " a = " << a++
             << " b = " << b++
             << " c = " << c++ << '\n';
      }

      int main()
      {
        while (a < 4) f();
      }

    ணࠬ 뤠 ⠪ १:

      a = 1 b = 1 c = 1
      a = 2 b = 1 c = 2
      a = 3 b = 1 c = 3

     '' ਬ஢ ⮩   ⪮  ᪫祭
  ப #include <iostream>.  㦭     , 
  뤠 १.

    "++"  ६⮬, . . a++ 砥:  1
    ६ a.

   쭠 ६  쭠 ६ static,   뫠
    樠஢, 樠  㫥 祭 (#2.4.5).
      ᯮ 樨  new  delete, ணࠬ  ᮧ
   ꥪ, ६    ࠢ ᠬ (. $$3.2.6).


   2.2  

    (䨪)  ᫥⥫쭮 㪢  .
    ᨬ   㪢. 㪢 ⠥  ᨬ
   ન _.  ++  ࠭稢 ᫮ ᨬ  .
     ॠ 室 ணࠬ , 묨 ᮧ⥫
   ࠭ ࠢ   (ਬ, 稪),  ,
    ᮦ,  ⠭ ࠭祭. ஬ ⮣, 
   ⥬ ணࠬ, 室  믮 ணࠬ  ++, 
     㦠 ⢮ ᨬ, ⨬  䨪.
   ७ (ਬ, ᯮ짮 $  )  
   ७ᨬ ணࠬ.  ᯮ짮  ⢥ 
   㦥 ᫮ ++ (. $$R.2.4), ਬ:


          hello    this_is_a_most_unusially_long_name
          DEFINED  foO    bAr     u_name    HorseSense
          var0     var1   CLASS   _class    ___

   ਢ ਬ ᫥⥫쭮⥩ ᨬ,   
  ᯮ짮  䨪:

          012      a fool    $sys     class    3var
          pay.due  foo~bar   .name    if

     㪢  ࠧ묨, ⮬ Count 
  count - ࠧ .  롨 ,   ⫨騥
    㣠, ࠧ㬭.  , 稭騥  ᨬ
  ન, १ࢨ  ᯮ짮  ᠬ ॠ樨
     ணࠬ,  믮 ᮢ⭮  ࠡ祩,
  ⮬ ࠩ ᫥ ⠢ ⠪  
  ᢮ ணࠬ.
     ࠧ ணࠬ ࠭ ᥣ ६  ᠬ
   ᫥⥫쭮 ᨬ, ࠧ , ⮬ var10
  -  ,   騥   var  ᫮ 10.  ⮩  稭
  elseif -   (㦥),    㦥  else  if.

  2.3  

     (䨪஬)  ணࠬ 易 ⨯. 
    樨,   ਬ   (..  ꥪ,
   砥 ),  ⠪   権.
  ਢ ਬ:

        int error_number;
        float real(complex* p);

  ᪮ ६ error_number ᠭ  int (楫),  
  ᢠ,  ⠪  ᯮ짮  祭  䬥᪨
  ࠦ. 㭪 real  뢠  ࠬ஬, ᮤঠ騬
   complex.     ६,  㭪樨.
   ,   襬 ਬ int  complex,  
  ⨯. 筮  ⨯ 㦭, ⮡   ᠭ ⨯ ஥
  㣮 . ஬ ⮣,  ⨯  ᯮ짮
   ⢥ ࠭   sizeof (   ।
  ࠧ , 室  ꥪ⮢ ⮣ ⨯)  new ( 
    ࠧ  ᢮  ꥪ ⮣ ⨯).
  ਬ:

         int main()
         {
           int* p = new int;
           cout << "sizeof(int) = " << sizeof(int) '\n';
         }

    ⨯  ᯮ짮  樨  ८ࠧ
   ⨯  㣮 ($$3.2.5), ਬ:

         float f;
         char* p;
         //...
         long ll = long(p);     // ८ࠧ p  long
         int i = int(f);        // ८ࠧ f  int


  2.3.1  ᭮ ⨯

  ᭮ ⨯ ++ ।⠢ ᠬ ࠭  
  設   ᭮ ᯮᮡ ࠡ  . :

         char
         short int
         int
         long int

  ᫥ ⨯ ᯮ  ।⠢ ࠧ筮
  ࠧ 楫. ᫠  饩 窮 ।⠢ ⨯:

         float
         double
         long double

  騥 ⨯  ᯮ짮  ।⠢  楫,
  ᪨ 祭, ࠧ來 ᨢ  ..:

         unsigned char
         unsigned short int
         unsigned int
         unsigned long int

   ਢ ⨯,  ᯮ    
  ⨯:

         signed char
         signed short int
         signed int
         signed long int

     ᪮  㬮砭 祭 ⨯ int  묨, 
  ᮮ⢥騥 ⨯  signed  ᨭ ⨯ 
  ⮣ 㦥 ᫮.
   ⨯ signed char ।⠢ ᮡ :  3 ⨯ - unsigned char,
  signed char   char  ࠧ묨 (. ⠪ $$R.3.6.1).
      ⪮ (     ᫥⢨) ᫮ int 
   㪠뢠  ᫮ ⨯, .. long 砥 long int, unsigned -
  unsigned int. , ᫨  ᠭ  㪠 ⨯,  ।,
    int. ਬ,    । ꥪ ⨯ int:

           const a = 1;      // ०, ⨯  㪠
          static x;          //   砩

    筮 ய ⨯  ᠭ  ,   㬮砭
   㤥 ⨯ int, ⠥  ⨫.   맢 ⮭ 
  ⥫ 䥪 (. $$R.7.1).
      ࠭ ᨬ  ࠡ    室 ⨯ char.
  筮  ।⠢   8 ࠧ冷.   ꥪ⮢  ++
   ࠧ char,   । 祭 sizeof(char) ⮦⢥ 1.
   ᨬ  設 祭 ⨯ char   
    楫. 筮, 祭 ⨯ unsigned char ᥣ
  , ,    ⨯,  蠥 ७ᨬ
  ணࠬ. , ᯮ짮 unsigned char  char 
  ᭨ ᪮ 믮 ணࠬ. ⢥, 祭
  ⨯ signed char ᥣ .
        ᪮쪮 楫, ᪮쪮  ⨯
   ᪮쪮 ⨯  饩 窮, ⮡ ணࠬ  
  ᯮ짮  ⥬ .   設
  ⥫쭮 ࠧ ࠧ 뤥塞 , ६ 㯠
   ᪮ ᫥  祭 ࠧ ᭮ ⨯.
   ࠢ,  ᮡ ⭮ 設,  
  ⨬ ᭮ ⨯ (ਬ,   ⨯ int)  
  ६. ,  ⢨⥫쭮 ७ᨬ ணࠬ,
  ᯮ ⠪   ஢, .  ࠧ஢
  ᭮ ⨯ 믮 ᫥騥 ᮮ⭮襭:


   1==sizeof(char)<=sizeof(short)<=sizeof(int)<=sizeof(long)

   sizeof(float)<=sizeof(double)<=sizeof(long double)

   sizeof(I)==sizeof(signed I)==sizeof(unsigned I)

    I   ⨯ char, short, int  long.  ⮣
   ࠭,  char ।⠢  , 祬 8 ࠧ鸞, short
   -  , 祬 16 ࠧ鸞  long -  , 祬 32 ࠧ鸞.  char
   祭  ।⠢  ᨬ   ᨬ
    設.   砥 ⮫쪮 ,  ⨯ char 
   ।⠢ 楫   0..127. । 襥 -
   ᪮.
       楫  ᥣ 室  ⠪ ணࠬ, 
    ᬠਢ  ᨢ ࠧ冷. , 
  ࠢ, ᯮ짮 unsigned  int,   祣 襣,
   ⠪ ࠧ 뢠 먣   ࠧ 
  ।⠢ ⥫ 楫. 뢠 ६  unsigned,
   ࠭஢,   㤥 ⮫쪮 ⥫쭮, ᪮
  ⨬  ८ࠧ ⨯, ਬ:

      unsigned surprise = -1;

   । ⨬ (   뤠 ।०
   ).

  2.3.2   ८ࠧ ⨯

   ᢠ  ࠦ ᭮ ⨯  ᮢ襭 ᢮
  ᯮ짮 ᮢ⭮. 祭 ८ࠧ뢠 , 
   , ⠪ ࠧ, ⮡ ଠ  﫠. 
  ࠢ ८ࠧ   $$R.4  $$R.5.4.
     -⠪  樨,  ଠ   ﭠ 
   ᪠. ⥭樠 筨 ⠪ 権 ⠭
  ᢠ,   祭  ⨯ ᢠ 祭
  㣮 ⨯, 祬  ।⠢ ᫥ ᯮ
   ࠧ冷. ⨬,  ᫥騥 ᢠ 믮
   設,  ன 楫 ।⠢  ⥫쭮 ,  ᨬ
   8 ࠧ冷:

       int i1 = 256+255;
       char ch = i1        // ch == 255
       int i2 = ch;        // i2 == ?

   ᢠ ch=i1   ࠧ ( ᠬ !),  
   ᢠ 祭 ६ i2,  ६ ch 祭 "
  ", .. 8  ࠧ冷.   祭 ਬ i2? 
  設 DEC VAX,  ன char ।⠢  祭,  㤥
  -1,   設 Motorola 68K,  ன char - ,
   㤥 255.  ++  ᪨ ।  ஫
   権,  ஫  ⠯ ࠭樨  ᫨誮
  ᫮, ⮬   ஦묨.

  2.3.3  ந ⨯

  室  ᭮ ( । 짮⥫) ⨯,  
   ᫥ 権 ᠭ:

       *     㪠⥫
       &     뫪
       []    ᨢ
       ()    㭪

   ⠪   । ,  㣨, ந ⨯.
  ਬ:

       int* a;
       float v[10];
       char* p[20];   // ᨢ  20 ᨬ 㪠⥫
       void f(int);
       struct str { short length; char* p; };

  ࠢ ஥ ⨯    権 ஡ ᭥
   $$R.8. 祢  ⮨  ⮬,  ᠭ ꥪ ந
  ⨯  ࠦ  ᯮ짮, ਬ:

       int v[10];     // ᠭ 
       i = v[3];      // ᯮ짮  

       int* p;        // ᠭ 㪠⥫
       i = *p;        // ᯮ짮 㪠㥬 ꥪ

  祭, ᯮ㥬  ந ⨯, 筮 㤭
     ⮬,  樨 *  &  䨪묨, 
  []  () - 䨪묨. ⮬   ⨯, ᫨ ਮ
  権  ⢥ 楫,  ⠢ ᪮. ਬ, ਮ
  樨 [] , 祬  *,   :

      int* v[10];        // ᨢ 㪠⥫
      int (*p)[10];      // 㪠⥫ ᨢ

  設⢮   ,  룫  
  㯮ॡ塞 ⨯.
    ࠧ ᪮쪮    ᠭ.   ᮤন
     ᯨ᮪ ⤥塞   㣠 묨
  . ਬ,  ⠪   ६ 楫 ⨯:

       int x, y;    // int x; int y;

    뢠 ந ⨯,   뢠,  樨
  ᠭ ਬ ⮫쪮    (    ᥬ
  ⠫  ⮣  ᠭ). ਬ:

      int* p, y;        // int* p; int y;   int* y;
      int x, *p;        // int x; int* p;
      int v[10], *p;    // int v[10]; int* p;

   ⠪ ᠭ 뢠 ணࠬ, , ,  ᫥
  .

  2.3.4   void

   void ᨭ⠪᪨ ⥭ ᭮ ⨯,  ᯮ짮
    ⮫쪮  ந ⨯. ꥪ⮢ ⨯ void  .
      㪠⥫  ꥪ ⭮ ⨯ 
  㭪樨, 騥 祭.

     void f();    // f  頥 祭
     void* pv;    // 㪠⥫  ꥪ ⭮ ⨯

  ⥫ ந쭮 ⨯  ᢠ ६ ⨯ void*.
     ⮬ 㤭  ਬ, ᪮  void*
  ⨬ ᢥ 饭 (ࠧ묥). , 
   ⮬ ࠭祭 ᭮뢠 ᯮ짮 ⨯ void*. 
  ਯ뢠 ࠬࠬ 㭪権,     ⨭
  ⨯  ࠬ஢.  void*  ⠪ ⨯ ꥪ,
  頥 㭪ﬨ.
   ᯮ짮 ⠪ ꥪ⮢ 㦭 믮  
  ८ࠧ ⨯.  㭪樨 筮 室  ᠬ 
  ஢ ⥬,  ࠢ 묨
  ᠬ. ਢ ਬ:

      void* malloc(unsigned size);
      void free(void*);

      void f()          // ।   ⨫ 
      {
        int* pi = (int*)malloc(10*sizeof(int));
        char* pc = (char*)malloc(10);
        //...
        free(pi);
        free(pc);
      }

   祭: (⨯) ࠦ - ᯮ   樨
   ८ࠧ ࠦ  ⨯, ⮬ । ᢠ
   pi ⨯ void*, 頥  ࢮ 맮 malloc(), ८ࠧ
    ⨯ int. ਬ ᠭ  堨筮 ⨫; 訩 ⨫
   ࠢ ࠧ饭  ᢮    $$3.2.6.

   2.3.5  ⥫

   設⢠ ⨯ T 㪠⥫  T  ⨯ T*.  , 
  ६ ⨯ T*  ࠭  ꥪ ⨯ T. ⥫ 
  ᨢ  㭪樨,  ᮦ, ॡ  ᫮ :

      int* pi;
      char** cpp;             // 㪠⥫  㪠⥫  char
      int (*vp)[10];          // 㪠⥫  ᨢ  10 楫
      int (*fp)(char, char*); // 㪠⥫  㭪  ࠬࠬ
                              // char   char*,   int

     㪠⥫ﬨ -  ᢥ 饭
  (ࠧ묥), .. 饭  ꥪ,   ஥
  㪠⥫.   筮 뢠  ᢥ.
   ᢥ *  䨪᭮ 㭠୮ 樥.
  ਬ:

      char c1 = 'a';
      char* p = &c1;    // p ᮤন  c1
      char c2 = *p;    // c2 = 'a'

   ६,   㪠뢠 p,-  c1,  祭, ஥
   ࠭  c1, ࠢ 'a'. ⮬ ᢠ c2 祭 *p
    'a'.
    㪠⥫ﬨ  믮   䬥᪨ 樨.
     ⢥ ਬ ।⠢ 㭪, 뢠 ᫮
   ᨬ  ப, 稢饩 㫥 ᨬ (
    뢠):

       int strlen(char* p)
       {
         int i = 0;
         while (*p++) i++;
         return i;
       }

   ।  ப -㣮: ᭠砫   ,  ⥬
    砫 ப    .

        int strlen(char* p)
        {
          char* q = p;
          while (*q++) ;
          return q-p-1;
        }

  ப ᯮ 㪠⥫  㭪樨;  ᮡ 㦤
   $$4.6.9

  2.3.6  ᨢ

   ⨯ T T[size]  ⨯ "ᨢ  size ⮢ ⨯ T".
     0  size-1. ਬ:

       float v[3];   // ᨢ   ᥫ  饩 窮:
                     //     v[0], v[1], v[2]
       int a[2][5];  //  ᨢ,   楫 
       char* vpc;    // ᨢ  32 ᨬ 㪠⥫

    ᫥騬 ࠧ  横,  ஬  楫
   祭 ய 㪢:

       extern "C" int strlen(const char*);  //  <string.h>

       char alpha[] = "abcdefghijklmnopqrstuvwxyz";

       main()
       {
         int sz = strlen(alpha);

         for (int i=0; i<sz; i++) {
             char ch = alpha[i];
             cout << '\''<< ch << '\''
                  << " = " <<int(ch)
                  << " = 0" << oct(ch)
                  << " = 0x" << hex(ch) << '\n';
          }
       }

   㭪樨 oct()  hex() 뤠 ᢮ ࠬ 楫 ⨯
   쬥筮  ⭠筮  ᮮ⢥⢥.  㭪樨
  ᠭ  <iostream.h>.   ᫠ ᨬ  alpha
  ᯮ 㭪 strlen()  <string.h>,    
  뫮 ᯮ짮 ࠧ ᨢ alpha ($$2.4.4).  ⢠
  ᨬ ASCII १ 㤥 ⠪:

       'a' = 97 = 0141 = 0x61
       'b' = 98 = 0142 = 0x62
       'c' = 99 = 0143 = 0x63
       ...

  ⬥⨬,   㦭 㪠뢠 ࠧ ᨢ alpha: ࠭
  ⠭ , ⠢ ᫮ ᨬ  ப,   ⢥
  樠.  ᨢ ᨬ   ப 樠
  -  㤮,   ᮦ, ⢥ ᯮᮡ  ਬ
  ப. ᢠ ப ᨢ ⨬, ᪮
   몥 ᢠ ᨢ  ।, ਬ:

        char v[9];
        v = "a string";          // 訡

    ॠ ।⠢ ப  訬 ஬
  権 (. $$7.10).
     祢,  ப ਣ ⮫쪮  樠樨 ᨬ
  ᨢ;  㣨 ⨯ 室 ᯮ짮  ᫮
  . 祬,   ᯮ짮   ᨬ ᨢ.
  ਬ:

        int  v1[] = { 1, 2, 3, 4 };
        int  v2[] = { 'a', 'b', 'c', 'd' };

        char v3[] = { 1, 2, 3, 4 };
        char v4[] = { 'a', 'b', 'c', 'd' };

   v3  v4 - ᨢ   (  ) ᨬ; v4  稢
  㫥 ᨬ,  ⮣ ॡ ᮣ襭  ப  設⢮
   㭪権.  ᯮ ⠪ ᨢ char  ᠬ
  ⮢    訡.
      ᨢ ।⠢  ᨢ ᨢ.  
    ࠭ 祭 ᮢ ᯮ짮,   
    몠, .  -  ᮡ  
  ᫥ ࠦ (. $$3.2.2).  ஡  ⠪
  ᠭ:

        int bad[5,2];    // 訡

   ⠪

        int v[5][2];
        int bad = v[4,1];      // 訡
        int good = v[4][1];    // ࠢ쭮

   뢠
  ᨢ   ⮢,    ,  ᢮ ।,
  ᨢ  5 ⮢ ⨯ char:

        char v[2][5];

   ᫥饬 ਬ  ᨢ 樠  묨 㪢
  䠢,  ன -  訬 ࠬ.

        char v[2][5] = {
             { 'a', 'b', 'c', 'd', 'e' },
             { '0', '1', '2', '3', '4' }
        };

        main() {
            for (int i = 0; i<2; i++) {
              for (int j = 0; j<5; j++)
                  cout << "v[" << i << "][" << j
                       << "]=" << v[i][j] << "  ";
                  cout << '\n';

            }
        }

     १ 稬:

       v[0][0]=a v[0][1]=b v[0][2]=c v[0][3]=d v[0][4]=e
       v[1][0]=0 v[1][1]=1 v[1][2]=2 v[1][3]=3 v[1][4]=4


  2.3.7  ⥫  ᨢ

   ⥫  ᨢ  몥 ++ ᭮ 易.  ᨢ 
   ᯮ짮  㪠⥫    , ⮬ ਬ 
   ᨢ alpha    ⠪:

        int main()
        {
          char alpha[] = "abcdefghijklmnopqrstuvwxyz";
          char* p = alpha;
          char ch;

          while (ch = *p++)
                cout << ch << " = " << int (ch)
                     << " = 0" << oct(ch) << '\n';
        }

   ⠪  ᠭ p ᫥騬 ࠧ:

        char* p = &alpha[0];

   ⭮ ப ᯮ  맮 㭪権 
  ࠬ஬-ᨢ,  ᥣ ।  㪠⥫  
   .  ࠧ,  ᫥饬 ਬ   맮
  strlen ।     祭:

       void f()
       {
         extern "C" int strlen(const char*);  //  <string.h>
         char v[] = "Annemarie";
         char* p = v;
         strlen(p);
         strlen(v);
       }

    ⮬  ,    :   ᯮᮡ ⠪
   㭪, ⮡   맮 ᨢ v ஢ ($$4.6.3).
        ਬ  㪠⥫ 䬥᪨ 権 +,
  -, ++  --   ⨯ 㪠㥬 ꥪ⮢. ᫨ ⠪ 
  ਬ  㪠⥫ p ⨯ T*,  ⠥,  p 㪠뢠 
  ᨢ ꥪ⮢ ⨯ T.  p+1 砥 ᫥騩 
  ⮣ ᨢ,  p-1 - ।騩 .  ᫥, 
  祭 () p+1 㤥  sizeof(T) ⮢ , 祬 祭
  p. ⮬  ᫥饩 ணࠬ

      main()
      {
        char cv[10];
        int iv[10];

        char* pc = cv;
        int* pi = iv;

        cout << "char* " << long(pc+1)-long(pc) << '\n';
        cout << "int*  " << long(pi+1)-long(pi) << '\n';
      }

   ⮬ ⮣,   設  (Maccintosh) ᨬ   ,
   楫 -  , 稬:

        char* 1
        int*  4

  । ⠭ 㪠⥫ 뫨  樥 ८ࠧ
   ⨯ long ($$3.2.5).  ᯮ짮  ८ࠧ 
  "祢" ⨯ int, ᪮   ॠ 몠 ++
  㪠⥫     ⨯ int (.. sizeof(int)<sizeof(char*)).
      ⠭ 㪠⥫ । ⮫쪮  ⮬ 砥, 
    㪠뢠      ᨢ (  몥 
  ⥩ ࠭஢  䠪).  ⠭ 
  㪠⥫  㣮 ࠢ  (楫) ⮢ ᨢ, 室
   ⨬ 㪠⥫ﬨ.  ᪫뢠  㪠⥫    
  祭 楫 ⨯;    १⮬ 㤥 㪠⥫.
  ᫨  祭,  饥 㪠⥫   ⮣ 
  ᨢ,    ஥ 室 㪠⥫ ( 㪠⥫ 
  ᫥騩  ᨢ ),  १ ᯮ짮 ⠪
  祭 ।. ਢ ਬ:

        void f()
        {
          int v1[10];
          int v2[10];

          int i = &v1[5]-&v1[3];    // 2
          i = &v1[5]-&v2[3];    // । १

           int* p = v2+2;            // p == &v2[2]
                p = v2-2;            // *p ।
        }

   ࠢ, ᫮ 䬥᪨ 権  㪠⥫ﬨ  ॡ
    ᥣ  .
   ᪠,  
  設⢥ ॠ権 몠 ++  ஫  ࠭栬 ᨢ.
  ᠭ ᨢ   ᠬ, ᪮ 易⥫쭮
    㤥 ࠭ ᫮ ⮢ ᨢ.
  ⨥ ᨢ   ,  , ⨥ 몠 
  ஢.   ࠧ  (. $$1.4.3).

  2.3.8  

   ᨢ ।⠢ ᮡ ᮢ㯭 ⮢  ⨯, 
     ᮢ㯭 ⮢ ந
   (ࠪ᪨) ⨯. ਬ:

      struct address {
          char* name;         //  "Jim Dandy"
          long  number;       //   61
          char* street;       // 㫨 "South Street"
          char* town;         // த "New Providence"
          char* state[2];     //  'N' 'J'
          int   zip;          //  7974
      };

   ।  ⨯, 뢠 address,  
  ⮢ . ।   筮 騬, ⮡
    砨 ᮢ,    ਣ  ਬ. 
      ⮩   ।:   
    ++ 砥,  ᫥ 䨣୮ ᪮ ॡ
  窠  ⮩, ⮬    뢠.
      ६ ⨯ address  뢠 筮 ⠪ ,   
  㣨 ६,     樨 . (窠)  
   ⤥ 童 . ਬ:

      address jd;
      jd.name = "Jim Dandy";
      jd.number = 61;

  樠஢ ६ ⨯ struct  ⠪ ,  ᨢ.
  ਬ:

       address jd = {
          "Jim Dandy",
           61, "South Street",
           "New Providence", {'N','J'}, 7974
       };

      楫 ᯮ짮  ($$5.2.4). ⬥⨬,
   jd.state  樠஢ ப "NJ".  ப
  稢 㫥 ᨬ '\0',   ப "NJ"  ᨬ,
      , 祬 頥  jd.state.
    ꥪ⠬   c  㪠⥫,
  ᯮ  ->. ਬ:

       void print_addr(address* p)
      {
        cout << p->name << '\n'
             << p->number << ' ' << p->street << '\n'
             << p->town << '\n'
             << p->state[0] << p->state[1]
             << ' ' << p->zip << '\n';
      }

   ꥪ ୮ ⨯   ᢮, ।  䠪᪨
  ࠬ 㭪権  饭 㭪ﬨ  ⢥ १. ਬ:

      address current;

     address set_current(address next)
     {
       address prev = current;
       current = next;
       return prev;
     }

  㣨 ⨬ 樨, ਬ, ⠪,  ࠢ (==  !=),
  ।.  짮⥫  ᠬ ।  樨
  (.  7).
      ꥪ ୮ ⨯  易⥫쭮 ࠢ 㬬
  ࠧ஢   童.  ந室  ⮩ 稭, 
    設 ॡ ࠧ ꥪ । ⨯,
  ⮫쪮 ࠢ   ன 饩  ⥬ 樨
  ࠭ (  ⮬,  ࠡ  ⠪ ࠢ 㤥
   䥪⨢ ).  ਬ -  ࠢ 楫 
  ᫮ ࠭.  १ ࠢ   "ન" 
  . ,  㦥 㯮襩 設  sizeof(address)
  ࠢ 24,   22,   뫮 .
     ⠪ 㯮,  ⨯  ᯮ짮 ࠧ ᫥ 
    ᠭ,   ⮣,  㤥 襭  ᠭ.
  ਬ:

       struct link{
             link* previous;
             link* successor;
        };

    ꥪ ⨯      ,  
      ᠭ. ⮬ ᠭ

        struct no_good {
           no_good member;
        };

    訡 (࠭   ﭨ ⠭ ࠧ no_good).
   ⮡   ( )  ⨯ 뫠  
   㣠,          ண
   ୮ ⨯. ਬ:

        struct list;        // 㤥 । 

        struct link {
             link* pre;
             link* suc;
             list* member_of;
        };

        struct list {
             link* head;
        };

   ᫨   뫮 ࢮ ᠭ list, ᠭ 童 link ਢ  
  ᨭ⠪᪮ 訡.
   ⠪ ᯮ짮  ୮ ⨯   ⮣,  ⨯ 㤥
  ।, ᫨ ⮫쪮  ᯮ짮  ।  ࠧ
  . ਬ:

          class S;        // 'S' -  ண ⨯

          extern S a;

          S f();

          void g(S);

   ਢ ᠭ  ᯮ짮  ᫥ ⮣,  ⨯ S
  㤥 ।:

          void h()
          {
            S a;        // 訡: S - ᠭ
            f();        // 訡: S - ᠭ
            g(a);       // 訡: S - ᠭ
          }

  2.3.9  ⭮ ⨯

    ⨯  ࠧ묨  ⮣,   
      童. ਬ,  । ࠧ ⨯:

          struct s1 { int a; };
          struct s2 { int a; };

    १ :

          s1 x;
          s2 y = x;    // 訡: ᮮ⢥⢨ ⨯

   ஬ ⮣,  ⨯ ⫨   ᭮ ⨯, ⮬
   稬:

          s1 x;
          int i = x;    // 訡: ᮮ⢥⢨ ⨯

   , , ,  ।  ⨯,   
    ⨯.  ᠭ, 稭饬 㦥 ᫮ typedef, 뢠
    ६ 㪠 ⨯,      ⨯.
   ਢ ਬ:

          typedef char* Pchar;
          Pchar p1, p2;
          char* p3 = p1;

     㤮 ।⢮ ᮪饭 .

   2.3.10  뫪

   뫪  ᬠਢ     ꥪ.
    ᭮ 뫪 ᯮ   ࠬ஢  頥
   㭪ﬨ 祭 ,  ⠪  ॣ㧪 権 (.$$7).
    X& 砥 뫪  X. ਬ:

         int i = 1;
         int& r = i;    // r  i  뫠      楫
         int x = r;     // x = 1
         r = 2;         // i = 2;

  뫪   樠஢, ..
    ,    .  , 
  樠 뫪 ᮢ襭 ⫨砥  樨 ᢠ.
    㪠뢠 樨  뫪,      ᠬ 뫪
   , ਬ,

        int ii = 0;
        int& rr = ii;
        rr++;        // ii 㢥稢  1

    ++ ⨬,  rr++  㢥稢 ᠬ
  뫪 rr;  ⮣ ++ ਬ  楫, ..  ६ ii.
  ⥫쭮, ᫥ 樠樨 祭 뫪   
  :  ᥣ 㪠뢠   ꥪ,  ஬ 뫠 ਢ易
    樠樨. ⮡  㪠⥫  ꥪ,
  砥 뫪 rr,   &rr.
  祢 ॠ樥 뫪  㦨 ﭭ 㪠⥫,
   ᯮ ⮫쪮  ᢥ 饭.  樠
  뫪 㤥 ਢ쭮, ᫨  ⢥ 樠 㪠 
  (.. ꥪ,  ண  ; . $$R.3.7).
  樠  ⨯ T   ᮬ. , 樠
   &T     ᮬ,    ⨯ T.  ⠪ 
   ᫥饥:
  [1] -,  ᫨ 室, ਬ ८ࠧ ⨯
      (.$$R.8.4.3);
  [2] ⥬ 稢襥 祭 頥  ६ ६;
  [3] ,  ⮩ ६ ᯮ  ⢥ 樠
      뫪.
    ᠭ:

        double& dr = 1;          // 訡: 㦥 
        const double& cdr = 1;   // ଠ쭮

     ⠪:

        double* cdrp;    // 뫪, ।⠢  㪠⥫
        double temp;
        temp = double(1);
        cdrp = &temp;

  뫪  ६  뫪  ⠭ ࠧ  ᫥饩
  稭:  ࢮ 砥 ᮧ ६ ६ ॢ
  訡, ᪮ ᢠ ⮩ ६ 砥 ᢠ
  ६ ६,    ⮬  祧.
  ⢥,   ஬ 砥  ஡  .
   뫪  ⠭  ᯮ  ࠬ 㭪権
  (.$$R.6.3).
  뫪  ᯮ짮  㭪樨,   祭 ᢮
  ࠬ. ਬ:

       void incr(int& aa) { aa++; }

       void f()
       {
         int x = 1;
         incr(x);     // x = 2
       }

   । । ࠬ஢    ᥬ⨪,  
  樠, ⮬  맮 㭪樨 incr  ࠬ aa
  ⠭ 㣨   x. , ,  
  ᢮ ࠬ 㭪権, ⮡  뢠 ணࠬ.  設⢥
  砥 ।⥫쭥, ⮡ 㭪 頫 १ 
  ࠧ,  ⮡ ᯮ짮 ࠬ ⨯ 㪠⥫:

         int next(int p) { return p+1; }
         void inc(int* p) { (*p)++; }

         void g()
         {
           int x = 1;
           x = next(x);            // x = 2
           inc(&x);                // x = 3
         }

   ஬ ᫥,   뫮  । 㭪樨,
   ᯮ㥬   ࠢ, ⠪     ᢠ.
    ᭮ ਬ  筮 室  ।
   ਢ 짮⥫᪨ ⨯.  ⢥ ਬ ।
   ⮩ 樠⨢ ᨢ. 筥  । 
   pair:

          struct pair {
             char* name;  // ப
             int val;     // 楫
          };

   砥  ⮬,   ப 뢠 ஥ 楫 祭.
  㤭  㭪  ᪠  find(),   ࠡ⠥  ன
  , ।⠢饩 樠⨢ ᨢ.     ⫨筮 
  㣨 ப ᮤন  pair (: ப  祭 ). 
   ਬ -   ᨢ. ⮡ ᮪ ਬ, ᯮ
  ।쭮 ⮩,   䥪⨢ :

           const int large = 1024;
           static pair vec[large+1];

           pair* find(const char* p)
        /*
           // ࠡ⠥  ⢮  "pair":
           //  p, ᫨ 室, 頥  "pair",
           //  ⨢ 砥 頥 ᯮ짮 "pair"
        */
       {
           for (int i=0; vec[i].name; i++)
               if (strcmp(p,vec[i].name)==0) return &vec[i];

           if (i == large) return &vec[large-1];

           return &vec[i];
         }

   㭪 ᯮ 㭪 value(),  ॠ ᨢ 楫,
  㥬 ப ( ਢ筥 ப ஢ 楫묨):

         int& value(const char* p)
         {
           pair* res = find(p);
           if (res->name == 0) {  //    ப  砫,
                                  //   樠஢
             res->name = new char[strlen(p)+1];
             strcpy(res->name,p);
             res->val = 0;      // 砫쭮 祭 ࠢ 0
          }
          return res->val;
        }

     ࠬ (ப) value() 室 ꥪ,
   ।⠢騩 楫 (   祭 ᮮ⢥饣 楫) 
   頥 뫪  .  㭪樨  ᯮ짮, ਬ, ⠪:

         const int MAX = 256;    //   ᠬ  ᫮

         main()
         // 뢠  ᫮  室 ⮪
        {
          char buf[MAX];

          while (cin>>buf) value(buf)++;

          for (int i=0; vec[i].name; i++)
              cout << vec[i].name << ": " << vec [i].val<< '\n';
         }

    横 while  ⠭⭮ 室 ⮪ cin ⠥  
   ᫮  뢠   buf (.  10),  ⮬ 
   ࠧ 祭 稪, 易  뢠 ப, 㢥稢.
   稪 ᪨  樠⨢ ᨢ vec   㭪樨
   find().  横 for ⠥ 稢 ⠡ ࠧ ᫮  cin
      ⮩.  室 ⮪

          aa bb bb aa aa bb aa aa

   ணࠬ 뤠:

          aa: 5
          bb: 3

       蠡   ॣ㦥 樨 [] ($$8.8)
  筮   ᨢ  ⮣ ਬ  饣
  樠⨢ ᨢ.

  2.4  

   ++   祭  ᭮ ⨯:
  ᨬ ⠭, 楫 ⠭  ⠭  饩 窮.
  ஬ ⮣,  (0)  ᯮ짮  祭 㪠⥫
  ந쭮 ⨯,  ᨬ ப  ⠭⠬ ⨯
  char[].   । ᨬ᪨ ⠭.
  ᪠ ⠭ -  , 祭 ண   
    .  ++ ᨬ᪨ ⠭  
  ६ ᯮᮡ: (1)  㦥 ᫮ const  ।,
   易    祭 ந쭮 ⨯;
  (2) ⢮ 楫 ⠭  ।  ᫥;
  (3) ⠭⮩   ᨢ  㭪樨.

  2.4.1   ⠭

   ⠭     : ,
  쬥, ⭠  ᨬ ⠭. 
  ⠭ ᯮ  ᥣ  룫 ⢥:

          0    1234    976    12345678901234567890

  筠 ⠭  ⨯ int,  ᫨  㬥頥  ,
  ⢮  int,  ⨢ 砥  ⨯ long. ࠭ 
  ।०  ⠭, 稭  ॢ蠥 ࠭ ଠ
  ।⠢ ᥫ.
  ⠭, 稭  ,   ᫥ x (0x), 
  ⭠ ᫮ ( ᭮ 16),  ⠭, 
  稭  ,   ᫥ ,  쬥
  ᫮ ( ᭮ 8). ਢ ਬ 쬥 ⠭:

          0        02        077        0123

     ࠢ ᮮ⢥⢥: 0, 2, 63, 83.
   ⭠筮   ⠭ 룫 ⠪:

          0x0      0x2       0x3f       0x53

  㪢 a,  b, c, d, e  f     㪢
  ᯮ  ।⠢ ᥫ 10, 11, 12, 13, 14  15,
  ᮮ⢥⢥. 쬥筠   ⭠筠   
  室    ࠧ冷, 
  ᯮ짮    ᥫ    䥪.
  ਬ,  設,  ன int ।⠢  16-ࠧ來
  ᫮  ⥫쭮 , 0xffff  ⥫쭮 筮
  ᫮ -1. ᫨   ।⠢ 楫 ᯮ짮 襥 ᫮
  ࠧ冷,   뫮  ᫮ 65535.
     砭 U  ᯮ짮    ⠭ ⨯
  unsigned. 筮, 砭 L   ⠭ ⨯ long.
  ਬ:

            void f(int);
            void f(unsigned int);
            void f(long int);

            void g()
            {
              f(3);      // 맮 f(int)
              f(3U);     // 맮 f(unsigned int)
              f(3L);     // 맮 f(long int)
            }


   2.4.2  ⠭  饩 窮

   ⠭  饩 窮  ⨯ double. ࠭ 
   ।०  ⠪ ⠭, 祭   㪫뢠 
   ଠ, ࠭  ।⠢ ᥫ  饩 窮. ਢ
   ਬ ⠭  饩 窮:

           1.23    .23      0.23     1.    1.0     1.2e10    1.23e-15

  ⬥⨬,   ⠭  饩 窮    ஡.
  ਬ, 65.43  e-21   ⠭⮩  饩 窮, ࠭
  ᯮ    ⤥ ᥬ:

            65.43    e    -    21

   맮 ᨭ⠪ 訡.
  ᫨ 㦭 ⠭  饩 窮 ⨯ float,    ,
  ᯮ 砭 f:

            3.14159265f     2.0f     2.997925f


  2.4.3   ⠭

  쭮 ⠭⮩  ᨬ, 祭   窨,
  ਬ, 'a'  '0'.  ⠭   ⠭⠬,
     楫 祭 ᨬ  , ਭ⮣ 
  設,  ன 믮 ணࠬ.
   易⥫쭮    ᨬ,    設,
   ணࠬ ࠭᫨஢.  ࠧ, ᫨  ᪠
  ணࠬ  設, ᯮ饩  ᨬ
  ASCII,  祭 '0' ࠢ 48,  ᫨ 設 ᯮ  EBCDIC,
    㤥 ࠢ 240. ᯮ짮 ᨬ ⠭  
  筮 楫  蠥 ७ᨬ ணࠬ.
   ᯥ樠 樨 ᨬ, 稭騥  ⭮
  ஡ ,  ⠭ :

         ப                NL(LF)    \n
        ਧ⠫쭠 ⠡    HT        \t
        ⨪쭠 ⠡      VT        \v
                             BS        \b
         ⪨             CR        \r
        ॢ ଠ             FF        \f
                              BEL       \a
        ⭠ ஡       \         \\
                         ?         \?
        筠 窠           '         \'
         窠             "         \"
        㫥 ᨬ              NUL       \0
        쬥筮 ᫮          ooo       \ooo
        ⭠筮 ᫮     hhh       \xhhh

  ᬮ   ,   樨   ᨬ. 
  ᨬ쭮 ⠭ - char.  ⠪  ᨬ  
  쬥筮 ᫠,  ।⠢ ,   ६
  쬥묨 ࠬ (। ࠬ  \)   
  ⭠筮 ᫠
  (। ⭠묨 ࠬ  \x). ᫮ ⭠
    ⠪ ᫥⥫쭮 ࠭祭. ᫥⥫쭮
  쬥  ⭠  蠥  ᨬ,
   騬 ⠪ ன. ਢ ਬ:

      '\6'      '\x6'        6        ASCII ack
      '\60'     '\x30'       48       ASCII '0'
      '\137'    '\x05f'      95       ASCII '_'

  ⨬ ᯮᮡ  ।⠢  ᨬ   ᨬ
  設.  ⭮,  ⠪ ࠧ ᨬ 
    ᨬ ப (. ᫥騩 ࠧ). ⨬, 
  ᫨  ᨬ
  ᯮ ᫮ ଠ ,  蠥 ७ᨬ
  ணࠬ  設  ࠧ묨 ࠬ ᨬ.

  2.4.4  ப

  ப -  ᫥⥫쭮 ᨬ, 祭   窨:

          " ப"

   ப ᮤন   ᨬ , 祬  :
   ப 稢 㫥 ᨬ ('\0'), 騬
  祭 0. ⮬

         sizeof("asdf")==5;

   ப ⠥ "ᨢ  ᮮ⢥饣 ᫠ ᨬ",
  ⮬ ⨯ "asdf"  char[5].  ப 뢠 
  ""   ⨯ char[1]. ⬥⨬,    ப s 믮
  strlen(s)==sizeof(s)-1, ᪮ 㭪 strlen()  뢠
  騩 ᨬ '\0'.
      ப  ᯮ짮  ।⠢ 
  ᨬ ᯥ樠 樨  \.  ⭮,  ப 
   ᠬ ᨬ  窨 "  ᨬ \.  ᥣ 
  ⠪ ᨬ 뢠 㦭 ᨬ  ப '\n', ਬ:

         cout << "㪮 ᨣ   ᮮ饭\007\n"

    7 -  祭  ASCII ᨬ BEL (ᨣ),  
  ७ᨬ  砥  \a.
      ப "騩" ᨬ  ப:

        "  ப,
          ᨭ⠪᪠ 訡"

   襩 來 ணࠬ  ப  ࠧ
  ஡, ਬ:

         char alpha[] = "abcdefghijklmnopqrstuvwxyz"
                        "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

  ,  騥, ப  ꥤ  , ⮬
  ᨢ alpha   ࠧ 樠஢  
   ப:

          "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

   ப   ᨬ '\0',  設⢮ ணࠬ
    ᫥    -  ᨬ. ਬ,
  ப "asdf\000hjkl"  ⠭ 㭪樨 strcpy()  strlen()
   ᬠਢ  ப "asdf".
     ᫨    ப ᫥⥫쭮 쬥 
  ᫮ ⠭,  ࠧ㬭 㪠   . 
  ⮩ ப  ⠪  ᫨誮 , ⮡   ࠧ뢠,
  ⭮       ⤥ ᨬ.
   ⭠ ⠭ ᯮ  ࠧ鸞. ᬮਬ
  ᫥騥 ਬ:

         char v1[] = "a\x0fah\0129";    // 'a' '\xfa' 'h' '\12' '9'
         char v2[] = "a\xfah\129";      // 'a' '\xfa' 'h' '\12' '9'
         char v3[] = "a\xfad\127";      // 'a' '\xfad' '\127'

  2.4.5  

   (0)  ⨯ int.  ⠭ ८ࠧ ($$R.4)
  0  ᯮ짮  ⠭ 楫 ⨯,  ⨯  饩
  窮,  ⨯ 㪠⥫.  ࠧ  ꥪ, ᫨
    㪠 0.   ⨯  ᯮ짮, ।
  ⥪⮬. 筮 ( 易⥫쭮)  ।⠢
  ᫥⥫쭮 ࠧ冷 " 㫨" 室饩 .

  2.5   ⠭

    ᠭ ꥪ 㦥 ᫮ const,  ॢ
   ꥪ  ६  ⠭, ਬ:

         const int model = 90;
         const int v[] = { 1, 2, 3, 4 };

  ᪮ ⠭  祣 ᢮,   
  樠஢. 뢠 - ꥪ  const,  ࠭㥬,
    祭     :

        model = 200;        // 訡
        model++;            // 訡

  ⬥⨬,  ᯥ䨪 const ᪮॥ ࠭稢 
  ᯮ짮 ꥪ, 祬 㪠뢠,  ᫥ ࠧ ꥪ.
     ࠧ㬭    ᠭ 㭪樨  ⨯
  頥 祭 const:

       const char* peek(int i)    //  㪠⥫  ப-⠭
      {
        return hidden[i];
      }

  ਢ 㭪  뫮  ᯮ짮  । ப,
  饭  ,   ணࠬ,   㤥 .
   , ࠭  ᯮ짮 ⥬ 䠪⮬,  ꥪ
   const,  ࠧ 楫 (筮,   
  "ࠧ㬭" ࠭).  祢 -  ,  
  ⠭  㦭 ⢮ , ᪮  祭 ⭮
  ࠭. , 樠  ⠭,  ࠢ ( 
  ᥣ)  ﭭ ࠦ, ஥  ᫨ 
  ⠯ ࠭樨. ,  ᨢ ⠭ 筮 室
  ⢮ , ᪮  饬 砥 ࠭  ,
    ᨢ ᯮ  ࠦ.    ⮬ 砥
    設  ⨬, ᫨  ⠪ ᨢ
   饭   .
     㪠⥫,      ꥪ⠬:  ᠬ 㪠⥫
    㪠㥬 ꥪ⮬.  ᫨  ᠭ 㪠⥫  "䨪"
  const,  ⠭⮩   ᠬ ꥪ,   㪠⥫  ,
  ਬ:

         const char* pc = "asdf";    // 㪠⥫  ⠭
         pc[3] = 'a';                // 訡
         pc = "ghjk";                // ଠ쭮

  ⮡   ⠭ ᠬ 㪠⥫,   㪠㥬 ꥪ,
  㦭 ᯮ짮  * । const. ਬ:

        char *const cp = "asdf";    // 㪠⥫-⠭
        cp[3] = 'a';                // ଠ쭮
        cp = "ghjk";                // 訡

  ⮡ ᤥ ⠭⠬  㪠⥫,  ꥪ,   
  const, ਬ:

       const char *const cpc = "asdf";  // 㪠⥫-⠭  const
       cpc[3] = 'a';                    // 訡
       cpc = "ghjk";                    // 訡

  ꥪ    ⠭⮩  饭    
  㪠⥫,     ६  塞, ᫨  
   㣨 ᯮᮡ. ᮡ  㤮 ᯮ짮  ࠬ஢
  㭪樨. ᠢ ࠬ-㪠⥫ 㭪樨  const,  頥
     㪠㥬 ꥪ, ਬ:

      char* strcpy(char* p, const char* q); //    *q

  ⥫  ⠭  ᢮  ६, .. 
   ਭ ।. ,  ⠭  ᢠ 㪠⥫
   ᯥ䨪樨 const,  ⠭    祭,
  ਬ:

        int a = 1;
        const int c = 2;
        const int* p1 = &c;    // ଠ쭮
        const int* p2 = &a;    // ଠ쭮
        int* p3 = &c;          // 訡
        *p3 = 7;               //  祭 c

  2.5.1.  ᫥

   ᯮᮡ 뢠   楫묨 ⠭⠬,   
  㤮, 祬 ᠭ  const. ਬ:

        enum { ASM, AUTO, BREAK };

   ।  楫 ⠭,  뢠 ⠬
  ᫥,   ᢮ 祭. ᪮  㬮砭 祭
  ⮢ ᫥  稭  0    饬 浪,
   ਢ ᫥ ⭮ ।:

         const ASM = 0;
         const AUTO = 1;
         const BREAK = 2;

  ᫥   , ਬ:

         enum keyword { ASM, AUTO, BREAK };

   ᫥ ⠭  ⨯.   ⠭
  ८ࠧ ⨯ ᫥   ਢ  ⨯ int.
  ⭮ ८ࠧ ( ⨯ int  ᫥)   
  . ਬ:

           void f()
           {
             keyword k = ASM;
             int i = ASM;
                 k = i     // 訡
                 k = keyword(i);
                 i = k;
                 k = 4;    // 訡
            }

  ᫥ ८ࠧ , 祬   ८ࠧ
   int  ᫥: 設⢮ 祭 ⨯ int  
  ।⠢   ᫥.
  ᠢ ६  ⨯ keyword  祢 int,  
   짮⥫, ⠪  ࠭ । ଠ  ⮬,
   㤥 ᯮ짮  ६. ਬ,  ᫥饣
  

            keyword key;

            switch (key) {
            case ASM:
             // 믮 -
                break;
            case BREAK:
             // 믮 -
                break;
            }

  ࠭  뤠 ।०, ᪮   
  祭 ⨯ keyword ᯮ ⮫쪮 .
      祭 ⮢ ᫥    . ਬ:

            enum int16 {
                sign=0100000,
                most_significant=040000,
                least_significant=1
            };

   祭 易⥫쭮   ࠧ묨, ⥫묨
     饬 浪.


     2.6.  

    ᮧ ਢ쭮 ணࠬ ࠭   㯠
  ,  ॡ  , 祬  뤥 
  .   ᯮᮡ 릠  ஥ ⢮ :
  [1]    ६  묨 祭ﬨ;
  [2] ᯮ짮       ࠭ ࠧ ꥪ⮢
       ࠧ ६.
   ᯮᮡ ॠ   ,  ன -  
  ꥤ.  ,  㣨 뢠 . ᪮ 祭
   権  易   ᭮  ⨬樥 ணࠬ,  
  ᪮,  ࠢ,   ७ᨬ,  ணࠬ ᫥
  襭쪮 㬠, ० 祬 ᯮ짮 .   
   ࠡ  묨, ਬ,  ᯮ짮 ᪨
  뤥塞 , 祬 ࠭ ⢥  .

  2.6.1  

   ⥫ ᯮ짮  ਧ, ਭ饣
  ⮫쪮  祭 ( ਬ: , ) ⨯ char,  ꥪ ⨯
  char   ++ 訬 ꥪ⮬,   ᨬ
  ࠧ  . ,   ᮡ ६
     祭 , ।    .
     , ᫨   । ᫥ 
  㪠 ᫮ ࠧ冷, ஥   . ⨬
  ﭭ .     ࠡ  묨 ﬨ,
     ࠧ饭     ⭮ 設:

         struct sreg {
                unsigned enable : 1;
                unsigned page : 3;
                unsigned : 1;        //  ᯮ
                unsigned mode : 2;
                unsigned : 4;        //  ᯮ
                unsigned access : 1;
                unsigned length : 1;
                unsigned non_resident : 1;
          };

  ਢ  뢠 ࠧ 㫥
  ॣ ﭨ DEC PDP11/45 (।,    ᫮
  ࠧ ᫥  ࠢ).    ਬ  뢠   ⠪   㣮
   ਬ :   ⥬ 
  ꥪ, ࠧ饭  । .   
  楫 ⨯ ($$R.3.6.1  $$R.9.6),   ᯮ 筮 㣨
  ꥪ⠬ 楫 ⨯.   ᪫祭:    .
    樮 ⥬   ⫠稪 ⨯ sreg  
  ᯮ짮 ᫥騬 ࠧ:

              sreg* sr0 = (sreg*)0777572;
              //...
              if (sr0->access) {        // 襭 ࠢ 㯠
                  // ࠧ  樨
                 sr0->access = 0;
              }

     ,
   ਬ   㯠 ᪮쪨 ६   , 
   易⥫쭮  .    , 
    設⢥ 設 ६ ⠥ ꥬ ,
   㦭  ࠡ  㯠묨 묨.
     ⠪ ணࠬ,  ⥫쭮 ᮪頫  ꥬ,
   ᫨  ६,  ﬨ, ८ࠧ뢠 
   ६ ⨯ char! ஬ ⮣,   char  int 筮
   ந室  ॥, 祬   .  -  
   㤮 ⪠ ଠ  ᪨ 権  祭
    ᥭ ଠ樨   ᫮.

   2.6.2. ꥤ

   ᬮਬ ⠡ ,  ன   ᮤন  
    祭. 祭    ப,  楫 ᫮:

              struct entry {
                 char* name;
                 char  type;
                 char* string_value;  // ᯮ ᫨ type == 's'
                 int   int_value;     // ᯮ ᫨ type == 'i'
              };
              void print_entry(entry* p)
              {
                switch(p->type) {
                case 's':
                     cout << p->string_value;
                     break;
                case 'i':
                     cout << p->int_value;
                     break;
                default:
                     cerr << "type corrupted\n";
                     break;
                }
              }

   ᪮ ६
   string_value  int_value    ᯮ짮 ६,
   祢,    ய .    ࠢ,
   ᠢ  ६  童 ꥤ, ਬ, ⠪:

               struct entry {
                    char* name;
                    char  type;
                    union {
                       char* string_value; // ᯮ ᫨ type == 's'
                       int   int_value;    // ᯮ ᫨ type == 'i'
                    };
               };

   ࠭,   뤥   entry 童
  string_value  int_value  ࠧ   , 
   ⮬  㦭    ணࠬ, ࠡ騥  entry.
   ⮣ ᫥,   童 ꥤ   ⠪ 
  ꥬ ,   訩 童 ꥤ.
        ᯮᮡ ࠡ  ꥤ 砥  ⮬, ⮡
  롨 祭   ⮣  ᠬ 童,   뢠.
  ,   ணࠬ 㤭 ࠭஢,  ꥤ
  ᯮ ⮫쪮 ⠪ ᯮᮡ,   १ ᯮ짮
   ⮣ 童    㤭 㦨 訡.
    ந ꥤ  ⠪ ,  ᯥ
  ࠢ   祭  ⨯   ⥪騬 ⨯ 童
  ꥤ ($$5.4.6).
       ꥤ ᯮ  "ᥢ८ࠧ" ⨯
  ( ᭮    ணࠬ, ਢ訥  몠,  
   । ८ࠧ ⨯,   १ 室 뢠
  ࠭). ਢ ਬ ⠪ "८ࠧ"  int  int*
   設 VAX, ஥ ⨣  ᮢ ࠧ冷:

           struct fudge {
                union {
                  int  i;
                  int* p;
                };
           };

           fudge a;
           a.i = 4095;
           int* p = a.p;    // ४⭮ ᯮ짮

   ⢨⥫쭮    ८ࠧ ⨯, ..  
  設 int  int*  ࠧ ꥬ ,   㣨 楫
    ࠧ  ,   ᫮. 
  ᯮ짮 ꥤ   ७ᨬ, ⮣ 
   ७ᨬ ᯮᮡ   ८ࠧ
  ⨯ ($$3.2.5).
      ꥤ ᯮ ᯥ樠쭮, ⮡ 
  ८ࠧ ⨯. ਬ,  ᯮ짮 fudge, ⮡
  㧭,  ।⠢ 㪠⥫ 0:

           fudge.p = 0;
           int i = fudge.i;    // i 易⥫쭮   0

     ꥤ   ,    ᤥ 
  ࠢ ⨯. ਬ, fudge   ⠪:

           union fudge {
                 int  i;
                 int* p;
           };

   ᯮ짮 (४⭮) 筮 ⠪ ,   ࠭.   ⥬,
   ꥤ  ᯮ짮   ४
   ࠢ ᯮᮡ (. $$5.4.6).


  2.7  ࠦ

  1. (*1)  ணࠬ  "Hello, world" (. $$1.3.1).
  2. (*1)   ᠭ  $$2.1 ᤥ ᫥饥: ᫨ ᠭ
       ।,   ᮮ⢥饥 ।;
     ᫨  ᠭ  ।,    ᠭ,
     ஥  﫮  ६  ।.
  3. (*1)  ᠭ ᫥ ꥪ⮢: 㪠⥫  ᨬ;
     ᨢ  10 楫; 뫪  ᨢ  10 楫; 㪠⥫
      ᨢ ᨬ ப; 㪠⥫  㪠⥫  ᨬ;
     楫-⠭; 㪠⥫  楫-⠭; ⠭⭮
     㪠⥫  楫. ᠭ ᭠ 樠樥.
  4. (*1.5)  ணࠬ,  ⠥ ࠧ ᭮ ⨯
      ⨯ 㪠⥫. ᯮ  sizeof.
  5. (*1.5)  ணࠬ,  ⠥ 㪢  'a'  'z'  
      '0'  '9'   楫 祭. த   ᠬ  㣨
      ᨬ. த , ᯮ ⭠
     .
  6. (*1) ⠩ ᫥⥫쭮 ࠧ冷 ।⠢ 㪠⥫
     0  襩 設. ᪠: .$$2.6.2.
  7. (*1.5)  㭪,  冷   ࠬ ⨯
     double.
  8. (*2)   ᯮ㥬  設 訥  訥
     祭 ᫥ ⨯: char, short,int,long, float, double,
     long double, unsigned, char*, int*  void*?   -
     ᮡ ࠭祭   祭? ਬ,   int* 
      楫?  ࠢ   ꥪ  ⨯?
     ਬ,   楫   ?
  9. (*1)  ᨬ쭠  쭮 , ஥
      ᯮ짮  襩 ॠ樨 ++ ?  ᨬ쭠
      譥 ?   - ࠭祭  ᨬ,
       ᯮ짮  ?
 10. (*1)  㭪,   ⠬ 祭  楫.
      ⢥ ⨯ ࠬ஢ ᯮ int*.   㭪
      ⥬  祭, ᯮ  ⢥ ⨯ ࠬ஢ int&.
 11. (*1)   ࠧ ᨢ str  ᫥饬 ਬ:
        char str[] = "a short string";
       ப "a short string"?
 12. (*1.5) ⠢ ⠡   楢   ᫠ 
        .  ணࠬ,  . த
      :  ࠧ - ᯮ ᨢ   楢
      ⢠ ,  㣮 ࠧ - ᯮ ᨢ ,
        ᮤন    ⢮   .
 13. (*1)   typedef । ⨯: unsigned char, ⠭
     unsigned char, 㪠⥫  楫, 㪠⥫  㪠⥫ 
     ᨬ, 㪠⥫  ᨢ ᨬ, ᨢ  7 㪠⥫
      楫, 㪠⥫  ᨢ  7 㪠⥫  楫  ᨢ 
     8 ᨢ  7 㪠⥫  楫.
 14. (*1) । 㭪樨 f(char), g(char&)  h(const char&) 
     맢 , ᯮ  ⢥ ࠬ஢ 'a', 49, 3300, c, uc, 
     sc,  c - char, uc - unsigned char  sc - signed char. 
     맮  ?   맮 ࠭ ਤ
      ६ ६?

