
               4

                         祫,
                        ४ - .
                       - . 

   ਢ ணࠬ   ᪮쪨 ࠧ쭮
  ࠭᫨㥬 ,  ࠤ樨 뢠 䠩.  ⮩ 
  ᠭ,  ࠧ쭮 ࠭᫨㥬 㭪樨  뢠  㣠,
   ࠧ    騥 ,   
  ⨢稢 ⨯, ᯮ㥬  ࠧ 䠩 ணࠬ.
  ஡ 㦤 㭪樨,  ⮬ ᫥:
  । ࠬ஢, ॣ㧪  㭪樨,
  ⠭ 祭 ࠬ஢, 㪠⥫  㭪樨 , ⢥,
  ᠭ  । 㭪権.    㦤
  ஢ 몠.

  4.1 

   䠩  몥 ++ ᢮  ⮬,   । 䠩
    ($$R.3.2).    
  㭪権 ( ᪨, ⠪  ⠭),  ⠪ 
  ६ ( ᪨, ⠪   ᯥ䨪樥 const). ஬
  ⮣, 䠩  ࠤ樮 楩 ࠭  ⥬, 
  ⠪ 楩 ࠭樨. 筮 ⥬ ࠭, ࠭᫨ 
  ।⠢ 짮⥫ ணࠬ  ++  ⢮ 䠩,
    ⥬, ஥ .  ⮩  㤥
  㦤  ᭮ ࠤ樮 ᯮ짮 䠩.
        ணࠬ    䠩,  ࠢ, ,
  ᪮ ணࠬ ⠭ 㭪権  ணࠬ 樮
  ⥬    ⥪⮢   ணࠬ 짮⥫.
  ,   ணࠬ 짮⥫   䠩 筮
  㤮  ࠪ筮.  ணࠬ  䠩 
    饩  ணࠬ   ࠭
   ন  . ᫨ 楩 ࠭樨
   䠩,    讬    ᫥
   ࠭᫨஢.   ணࠬ  ᫨誮 讣
  ࠧ ६  ࠭  ⥫쭮 ᮪, ᫨
   ࠧ  䠩 室饣 ࠧ.
       ୥  ਬ  ஬. 襭 뫮   
   䠩.   ⠥  ࠭᫨஢, 
    ஡  浪 ᠭ.  ࠩ 
   "饥" ᠭ ਤ   ⥪, ⮡
  ࠭  ࠧ  ᯮ  㣠 㭪
  expr(), term()  prim().  ⥪ ணࠬ ,  
  ⮨   ⥩: ᪨  (᪠),
  ᮡ⢥ , ⠡   ࠩ. ,  䠪
    ࠦ  ᠬ ணࠬ.  ᠬ  
    ணࠬ஢  ⠪.   ᫥ 
  ணࠬ.  ᫨  뢠  ४樨 
  ணࠬ஢, ᮯ஢  ⨬樨  ⠪ "譮"
  ணࠬ,  ࠢ  ᫥ ᮧ  ᪮쪨 䠩
     㤮⢠.
         ⮡ ࠧ쭠 ࠭ ⠫ , ணࠬ
   ।ᬮ ᠭ,   ࠭ 
  筮 ᢥ  ⨯  ࠭樨 䠩, ⠢饣
  ⮫쪮  ணࠬ. ॡ ⨢稢 ᯮ짮
     ⨯  ணࠬ, 饩  ᪮쪨 ࠧ쭮
  ࠭᫨㥬 ⥩, ⠪  ࠢ,    ணࠬ,
  饩   䠩.   ⮫쪮  ⮬ 砥, 
  ᠭ, 室騥  ࠧ  ࠭樨, 
  ᮣᮢ.  襩 ⥬ ணࠬ஢  ।⢠,
   ᯮᮡ ⠭, 믮  .  ⭮, 
  ⨢ 㦨 । 痢.  痢 -  ணࠬ,
   뢠   ࠧ쭮 ࠭᫨㥬  ணࠬ.
     訡 뢠 稪.

  4.2 뢠

  ᫨   । ,  ,  饥  
  ன 㭪樨  ,       ⨯,
  祭, 㭪  ꥪ    ࠭樨 
  ணࠬ. 묨 ᫮,  ணࠬ   ⮫쪮 
   ⨯, 祭, 㭪  ꥪ   .
  ᬮਬ  ਬ  䠩:

            // file1.c
               int a = 1;
               int f() { /* -  */ }

            // file2.c
               extern int a;
               int f();
               void g() { a = f(); }

   㭪樨 g() ᯮ  ᠬ a  f(),  । 
  䠩 file1.c. 㦥 ᫮ extern 뢠,  ᠭ
  a  䠩 file2.c  ⮫쪮 ᠭ,   ।.
  ᫨  ⢮ 樠 a,  extern 
  ந஢ , ᪮ ᠭ  樠樥 ᥣ
  ⠥ ।.  ꥪ  ணࠬ  ।
  ⮫쪮  ࠧ. 뢠    ⭮,  
  ᠭ   ᮣᮢ  ⨯. ਬ:

                // file1.c:
                   int a = 1;
                   int b = 1;
                   extern int c;

                // file2.c:
                   int a;
                   extern double b;
                   extern int c;

   ᮤন  訡: ६ a ।  ("int a;"
  -  ।, 饥 "int a=0;"); b ᠭ , 祬
   ࠧ묨 ⨯; c ᠭ ,  ।.  訡
  (訡 뢠) ࠭,  ࠡ뢠 䠩
   ⤥쭮, 㦨  ,    
  㦨 ।஬ 痢.
       ணࠬ ⨬  ,    ++:

                // file1.c:
                   int a;
                   int f() { return a; }

               // file2.c:
                  int a;
                  int g() { return f(); }

      -, 訡  맮 f()  file2.c, ᪮  ⮬
  䠩 f()  ᠭ. -, 䠩 ணࠬ   
  ࠢ쭮 易, ᪮ a । .
      ᫨  ᠭ  static,  ⠭ 쭮  ⮬
  䠩. ਬ:

              // file1.c:
                 static int a = 6;
                 static int f() { /* ... */ }

             // file2.c:
                static int a = 7;
                static int f() { /* ... */ }

  ਢ ணࠬ ࠢ쭠, ᪮ a  f । 
  ᪨.   䠩 ᢮ ६ a  㭪 f().
      ᫨ ६  㭪樨    ணࠬ ᠭ 
  static,   ⮩  ணࠬ  ࠧ, ᪮  㦭
  뢠  㣨 . 뢠 㭪樨  ᪨
      ⮩ 稭,  ࠭ ।⠢
   ᮧ  ⮩ ਠ 樨 맮 㭪樨.
  ᫨  ꥪ  㭪樨 쭮   䠩,  ,
   ꥪ  ७ 뢠. ⭮, ᫨ 
  ꥪ  㭪樨 쭮   䠩,   
  譥 뢠.
       筮 ,   ⨯, .. ᮢ  ᫥,
    뢠.   ᮢ  ᫥
    㭨묨  ᥩ ணࠬ   ⢥
  ।. ⮬, ᫨     ।
   ,  -  ࠢ 訡:

              // file1.c:
                 struct S { int a; char b; };
                 extern void f(S*);

              // file2.c:
                 struct S { int a; char b; };
                 void f(S* p) { /* ... */ }

    ஦:  筮  ᠭ 
    ﭨ 設⢮ ⥬ ணࠬ஢ ++. 
  㡫஢  맢 쭮 ⮭ 訡 ( 
   ࠧ 䠩   ࠧ묨).
       㭪樨-⠭  ७ 뢠,
      㬮砭 ࠢ  ⠭.  ⨯,
  ..  typedef,   ᢮ 䠩, ⮬ ᠭ
      䠩  ⨢  :

               // file1.c:
                  typedef int T;
                  const int a = 7;
                  inline T f(int i) { return i+a; }

               // file2.c:
                  typedef void T;
                  const int a = 8;
                  inline T f(double d) { cout<<d; }

  ⠭   譥 뢠 ⮫쪮   
  ᠭ:

               // file3.c:
                  extern const int a;
                  const int a = 77;

               // file4.c:
                  extern const int a;
                  void g() { cout<<a; }

   ⮬ ਬ g() ⠥ 77.

  4.3  䠩

    ꥪ  㭪樨   ᮣᮢ   
  ᠭ.   ᮣᮢ  ⨯  室 ⥪,
  ࠡ뢠 ࠭஬,  뢠  ணࠬ. 
  ⮩,   ᮢ襭, ᯮᮡ  ᮣᮢ
  ᠭ  ࠧ 䠩. :   室 䠩,
  ᮤঠ騥   । ,  䠩,
   ᮤঠ 䥩 ଠ.
      ।⢮ 祭 ⥪⮢ 㦨 ப #include,
    ᮡ   䠩 ( ࠭樨)
  ᪮쪮 室 䠩 ணࠬ. 

           #include "砥-䠩"

   ப,  ன  뫠 ,  ᮤন 䠩
  砥-䠩. ⢥,  ᮤন   ⥪⮬
   ++, ᪮  㤥  ࠭.  ࠢ, 
  祭 ॠ ⤥쭮 ணࠬ, 뢠 ९஬
  ++.  뢠 ⥬ ணࠬ஢ । ᮡ⢥
  ࠭樥  ࠡ⪨ ⠪   室 ⥪. 
   㣮 襭:  ࠭, ।⢥ ࠡ
   室 ⥪⮬, ࠡ뢠  祭 䠩   
    ⥪.  ⮩ ⥬ ணࠬ஢,  ன
  ࠡ⠥ , ⮡ 㢨 १  祭 䠩,
  㦭  :

           CC -E file.c

     ࠡ⪨ 䠩 file.c ᪠ ९
  ( ⮫쪮!),  ⮬,   CC  䫠 -E ᪠ ᠬ
  ࠭.
       祭 䠩  ⠭ ⠫ (筮 ⠫
    INCLUDE)   祪 ᯮ짮 㣫 ᪮
  <  >. ਬ:

          #include <stream.h>    // 祭  ⠭⭮ ⠫
          #include "myheader.h"  // 祭  ⥪饣 ⠫

  祭  ⠭ ⠫   २⢮,  
   ⠫   易  ⭮ ணࠬ (筮
  砫 砥 䠩   ⠫ /usr/include/CC, 
  ⥬  /usr/include).  ᮦ,  ⮩  ஡ ⢥:

          #include < stream.h>  // <stream.h>  㤥 

      뫮  , ᫨   ࠧ । 祭 䠩
  ॡ  ࠭. 筮 砥 䠩 ᮤঠ
  ⮫쪮 ᠭ,     ।, ॡ騥 ⢥
  ࠭୮ ࠡ⪨. ஬ ⮣, ⥬ ணࠬ஢
   ।⥫쭮 ࠭᫨஢ 
  䠩, ᫨, 筮,  ⮫쪮 ࠧ,  ᯮᮡ ᤥ
  ,   ᥬ⨪ ணࠬ.
      ,   ᮤঠ  䠩:

      । ⨯           struct point { int x, y; };
       ⨯               template<class T>
                                    class V { /* ... */ }
      ᠭ 㭪権            extern int strlen(const char*);
      ।                 inline char get() { return *p++; }
      㭪権-⠭
      ᠭ              extern int a;
      । ⠭        const float pi = 3.141593;
      ᫥                enum bool { false, true };
      ᠭ                class Matrix;
       祭 䠩    #include <signal.h>
      ம।            #define Case break;case
      ਨ                 /* ஢ઠ   䠩 */

   ᫥ ⮣,  ⮨    䠩,  
   ॡ 몠,   ᮢ  ࠧ㬭 ᯮ짮 祭
   䠩.  㣮 ஭,  筮 䠩    :

      ।  㭪権  char get() { return *p++; }
      ।            int a;
      । ⠢        const tb[i] = { /* ... */ };
      ⠭

    ࠤ樨  䠩  ७ .h,  䠩,
   ᮤঠ騥 । 㭪権  , ७ .c. 
    뢠 "h-䠩"  "-䠩" ᮮ⢥⢥. ᯮ
    㣨 ७   䠩: .C, cxx, .cpp 
   .cc. ਭ⮥ ७    ᢮ ࠢ筮 㪮⢥.
   ।⢠ 뢠  $$4.7. ⬥⨬ ⮫쪮,   ++ 
   ᯮ  ⮫ ப,   , ᪮ ++  ।
     ᠬ 몥: । ⠭ (const),
   㭪権-⠭ (inline), 騥   ⮩
   樨 맮,  蠡 ⨯, 騥 ஦ ᥬ⢮
   ⨯  㭪権 ($$8).
          䠩 । ⮫쪮 ,
     ⠢, ⠭   ࠣ᪮ 稭.
    設⢮ ࠭஢  ⮫쪮 ࠧ㬭, ⮡
   । ᮧ 㦭  ⠢ ⠭. 
   ,  ⮩ ਠ ᥣ   騬,  
   ࠭  뢠    ।, ⮡ ᮧ
    ணࠬ.

   4.3.1 ⢥  䠩

    ᥣ ࠧ ணࠬ  ᪮쪮 䠩 ᫥騬
   ࠧ:  ।  㭪権    ஥
   ᫮ 室 䠩,   ⨯, 室  裡 
   ,   ⢥ 筮 䠩.  室
   䠩    䠩. ணࠬ
     ࠧ   室 䠩 .c:
   lex.c, syn.c, table.c  main.c.  䠩 dc.h 㤥
   ᮤঠ ᠭ  , ஥ ᯮ 
   祬   .c 䠩:

            // dc.h: 饥 ᠭ  

            #include <iostream.h>

            enum token_value {
                 NAME,      NUMBER,     END,
                 PLUS='+',  MINUS='-',  MUL='*', DIV='/',
                 PRINT=';', ASSIGN='=', LP='(',  RP=')'
            };

            extern int no_of_errors;
            extern double error(const char* s);
            extern token_value get_token();
            extern token_value curr_tok;
            extern double number_value;
            extern char name_string[256];
            extern double expr();
            extern double term();
            extern double prim();

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

            extern name* look(const char* p, int ins = 0);
            inline name* insert(const char* s) { return look(s,1); }

   ᫨  ਢ ᠬ , lex.c   ⠪ :

            // lex.c:   ᪨ 

            #include "dc.h"
            #include <ctype.h>

            token_value curr_tok;
            double number_value;
            char name_string[256];

            token_value get_token() { /* ... */ }

   ᯮ ⠢  䠩,  쥬,
    ᠭ  ꥪ,  짮⥫, 易⥫쭮
     ⮬ 䠩,   ꥪ ।. ⢨⥫쭮,
    ࠡ⪥ 䠩 lex.c ࠭ ⮫  ᠭﬨ

            extern token_value get_token();
            // ...
            token_value get_token() { /* ... */ }

     ࠭ 㦨  宦  ⨯,
   㪠  ᠭ  . ਬ, ᫨  㭪
   get_token() 뫠 ᠭ  ⨯ token_value,  । 
   ⨯ int, ࠭ 䠩 lex.c   訡: ᮮ⢥⢨
   ⨯.
         syn.c   ⠪ :

             // syn.c: ᨭ⠪᪨   ᫥

             #include "dc.h"

             double prim() { /* ... */ }
             double term() { /* ... */ }
             double expr() { /* ... */ }

         table.c   ⠪ :

             // table.c: ⠡   㭪 ᪠

             #include "dc.h"

             extern char* strcmp(const char*, const char*);
             extern char* strcpy(char*, const char*);
             extern int strlen(const char*);

             const int TBLSZ = 23;
             name* table[TBLSZ];

             name* look(char* p, int ins) { /* ... */ }

   ⬥⨬,  ࠧ ப 㭪樨 ᠭ  ᠬ 䠩 table.c,
   ࠭   ஢ ᮣᮢ  ᠭ  ⨯.
   ᥣ   ᮮ⢥騩  䠩,
   祬 뢠  䠩 .c ஥   extern.  
   ਢ  祭 "᫨誮 ",  ⠪ 祭 譮,
   ᪮    ᪮ 믮 ணࠬ   ࠧ, 
   ணࠬ   ६. ⨬, 㭪 strlen() ᭮
   뢠  ਢ  䠩 main.c.  ⮫쪮 譨
    ᨬ  ⥭樠 筨 訡, .. ࠭
    ᬮ 㦨 宦   ᠭ strlen() (祬,
     ᤥ । 痢).  ஡   ,
   ᫨   䠩 dc.h ᮤঠ  ᠭ extern,  ࢮ砫쭮
    ।.  ०   襬 ਬ,
   ᪮  ⨯筠  ணࠬ  .  祭 ⢥
    ணࠬ,   ਢ  訡  ⠪ ணࠬ,
    㤭 ᮯ஢. ⠪, ।० ᤥ!
        , ਢ 䠩 main.c:

            // main.c: 樠, ᭮ 横, ࠡ⪠ 訡

            #include "dc.h"

            double error(char* s) { /* ... */ }

            extern int strlen(const char*);

            int main(int argc, char* argv[]) { /* ... */ }

      砥  䠩 뢠 讥 㤮⢮.
     ਨ  䠩  ⠭⭮
   ⥪   몠,  ⢮ ⨯ (
   , ⠪  ⠭   ਫ; .  5-9).
    ⠪ 砥 ⥪   ࠭樨  稭
   砬 ப  䠩. ন 
   䠩 ⥪,  ࠢ, ⠡쭮   ।. 
   祭 ਣ  ࠭,  ࠡ뢠 .  ,
   㦥  ᯥ樠쭮 祭  ᢮ ࠭஬.  
   ⮤ ஥ ⠪ ࠭  .

   4.3.2 ⢥  䠩

    ணࠬ      䠩 
   室   ணࠬ, ⤥   
    ᠬ⥫쭮 祭.  ⠪ ணࠬ ⨬,
     筮 䠩  ।,  ᠭ ⠬
   室    稭.    ⮫쪮 ਨ.
    ୠ⨢ 襭:    ணࠬ
    ᢮  䠩,  ஬ । ।⢠,
   ।⠢塞 㣨 .    䠩 .c 㤥
   ᢮ 䠩 .h, ।騩,   ।⠢ .  䠩
   .c 㤥   ᢮ 䠩 .h, ⠪   㣨 䠩 .h,
   室  ᢮ ॡ⥩.
       ஡㥬 ᯮ짮 ⠪ ࣠ ணࠬ 
   . ⨬,  㭪 error() 㦭 ࠪ᪨  
   㭪 ணࠬ,  ᠬ ᯮ ⮫쪮 <iostream.h>. 
    ⨯筠  㭪権, ࠡ뢠 訡.
    ⤥   䠩 main.c:

            // error.h: ࠡ⪠ 訡

            extern int no_of_errors;

            extern double error(const char* s);

            // error.c

            #include <iostream.h>
            #include "error.h"

            int no_of_errors;

            double error(const char* s) { /* ... */ }

    ⠪ 室  ࠧ ணࠬ   䠩 .c
    .h  ᬠਢ  ,  ஬ 䠩 .h 
    䥩,  䠩 .c ।  ॠ.
             ⥩ , ஬
    ࠡ⪨ 訡.   䠪  ࠧ
   :

            // table.h: ᠭ ⠡ 

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

            extern name* look(const char* p, int ins = 0);
            inline name* insert(const char* s) { return look(s,1); }

            // table.h: । ⠡ 

            #include "error.h"
            #include <string.h>
            #include "table.h"

            const int TBLSZ = 23;
            name* table[TBLSZ];

            name* look(const char* p, int ins) { /* ... */ }

   ,  ⥯ ᠭ ப 㭪権   砥
   䠩 <string.h>.  ᠬ 㤠   筨 訡.

           // lex.h: ᠭ    ᪮ 

           enum token_value {
             NAME,       NUMBER,        END,
             PLUS='+',   MINUS='-',     MUL='*',
             PRINT=';',  ASSIGN='=',    LP='(',   RP= ')'
          };

          extern token_value curr_tok;
          extern double number_value;
          extern char name_string[256];

          extern token_value get_token();

   䥩  ᪨ ஬ 筮 ⠭. ᪮
   筮 ᮮ⢥ ⨯  ᥬ, 짮⥫
   㭪樨 get_token() ।⠢    number_value
    name_string,  묨 ࠡ⠥ ᠬ ᪨ .

          // lex.c: ।    ᪮ 

          #include <iostream.h>
          #include <ctype.h>
          #include "error.h"
          #include "lex.h"

          token_value curr_tok;
          double number_value;
          char name_string[256];

          token_value get_token() { /* ... */ }

   䥩  ᨭ⠪᪨ ஬ । ⪮:

          // syn.h: ᠭ  ᨭ⠪᪮   ᫥

          extern double expr();
          extern double term();
          extern double prim();

          // syn.c: ।  ᨭ⠪᪮   ᫥

          #include "error.h"
          #include "lex.h"
          #include "syn.h"

          double prim() { /* ... */ }
          double term() { /* ... */ }
          double expr() { /* ... */ }

    筮, । ᭮ ணࠬ ਢ쭮:

          // main.c: ᭮ ணࠬ

          #include <iostream.h>
          #include "error.h"
          #include "lex.h"
          #include "syn.h"
          #include "table.h"

          int main(int argc, char* argv[]) { /* ... */ }

       ᫮  䠩 ᫥ ᯮ짮  
   ணࠬ    䠪஢. 設⢮  ।
   ᯮᮡ ࠡ⪨ 䠩   襩 ⥬,  
   ᮡ⢥  ++. ਬ, ᫨  ।   ࠡ
   ६  ᪮쪨 䠩,  ࠡ⪠ ᪮쪨
    䠩 㤭. 㣮 ਬ:  ,
    ⨥  ⥭ 10 䠩  50 ப  
   ⢥  ६, 祬 ⨥  ⥭  䠩  500
   ப.  १ ਤ 襭쪮 㬠, ० 祬
   ࠧ  ணࠬ, ᯮ ⢥ 
   䠩. ।०: 筮  ࠢ  ⢮, 騬
   ਬ୮  10  䠩 ( ⠭ 
   䠩). ᫨   㤥 ࠧ ணࠬ   ᪨
     묨 䠩 (ਬ, ᮧ   
   ᢮  䠩),   祭   ࠢ塞
   ⢮  ⥭  䠩.

   4.4 뢠  ணࠬ  㣨 몠

  ணࠬ  ++  ᮤঠ , ᠭ  㣨 몠, 
  ,  ࠣ  ++ ᯮ  ணࠬ,
  ᠭ  㣨 몠.    ணࠬ
  ࠣ, ᠭ  ࠧ 몠, , ᠭ  
  몥,   ⥬ ணࠬ஢  ࠧ묨 ᮣ襭ﬨ 
  뢠, 筮 㤭. ਬ, ࠧ 모  ࠧ
  ॠ樨  몠  ࠧ ᯮ짮 ॣ஢
   । ࠬ஢, 浪 ࠧ饭 ࠬ஢  ⥪,
  㯠 ⠪ ஥ ⨯,  楫  ப, ଠ⮬
   㭪権,  ࠭ । । 痢, ꥬ
  ஫ ⨯,  ॡ  । 痢. ⮡
   ,   ᠭ 譨 㪠 ᫮
  뢠. ਬ, ᫥饥 ᠭ  strcpy 譥
  㭪樥  㪠뢠,    뢠 ᮣ᭮ 浪
  뢠  :

               extern "C" char* strcpy(char*, const char*);

   ⮣ ᠭ ⫨砥  १ 筮 ᠭ

               extern char* strcpy(char*, const char*);

  ⮫쪮 浪 뢠  뢠 strcpy() 㭪権. 
  ᥬ⨪ 맮 ,  ⭮, ஫ 䠪᪨ ࠬ஢
      . ᠭ extern "C"  
  ᯮ짮   ⮬,  모   ++,   
  ॠ樨,   . ⬥⨬,   ᠭ extern "C"
  㯮  ⭮  浪 뢠,    ,  
  ⠪ ᠭ ᯮ  裡  ࠭  ᥬ஬.
   모  । ⥯ 稭 浪 뢠
   .
      ⮬⥫쭮  "C"   ᠭ 譨, 
    㪠 ⠪ ᯥ䨪 ࠧ  㯯
  ᠭ. ਬ:

                extern "C" {
                   char* strcpy(char*, const char);
                   int strcmp(const char*, const char*)
                   int strlen(const char*)
                   // ...
                }

    ⠪      䠩 , ⮡
   㪠,   稭 뢠  ++, ਬ:

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

   筮   ⠪ ਥ  ⠭⭮ 筮 䠩
      ⠪ 䠩  ++.   襭 
    ᫮ ࠭樨:

                #ifdef __cplusplus
                extern "C" {
                #endif

                    char* strcpy(char*, const char*);
                    int strcmp(const char*, const char*);
                    int strlen(const char*);
                    // ...

                 #ifdef __cplusplus
                 }
                 #endif

   ।। ம। __cplusplus 㦭, ⮡ 
    extern "C" { ...}, ᫨  䠩 ᯮ
    .
        ᪮  extern "C" { ... }  ⮫쪮 
   冷 뢠,    ᮤঠ  ᠭ,
   ਬ:

                extern "C" {
                  // ந ᠭ

                  // ਬ:

                  static int st;
                  int glob;
                }

          
   뢠 ꥪ⮢, ⮬ -० st 稭 ७
   뢠,  glob ⠥ 쭮 ६.
          ࠧ,  ᠭ extern "C"  ⮫쪮 
   冷 뢠     冷 맮 㭪樨.  ⭮,
   㭪, ᠭ  extern "C",  ࠢ 稭 ࠢ
   ஫ ⨯  ८ࠧ 䠪᪨ ࠬ஢,   C++
   ஦, 祬  . ਬ:

               extern "C" int f();

               int g()
               {
                 return f(1);  // 訡: ࠬ஢   
               }

   4.5  ᮧ ⥪

   ࠭ ⠪  (  ⮩  ⮦): "
    ⥪", "᪠  ⠪- ⥪".  
     ணࠬ  ++?  ᮦ, ⢥  
   ᯮ㥬 ⥬.  ⮬ ࠧ   ⮬, 
   ᮧ  ᯮ짮 ⥪  ⮩ ᨨ ⥬ .
   㣨 ⥬  ।⠢ 宦 . ⥪
   ⮨  䠩 .o,    १ ࠭樨
   䠩 .c. 筮    ᪮쪮 䠩 .h,  
   ᮤঠ 室  맮 䠩 .o ᠭ.
   ᬮਬ  ⢥ ਬ,   ⪮  ७ ⢠
   짮⥫  筮 㤮 । ஥
   ⢮ ⠭ ⥬᪨ 㭪権.  䠩
     ⠪ :

                extern "C" { // ⠭ ⥬᪨ 㭪樨
                             //  ࠢ ᠭ  

                   double sqrt(double); // ⢮ <math.h>
                   double sin(double);
                   double cos(double);
                   double exp(double);
                   double log(double);
                   // ...

                 }

   ।  㭪権  室  䠩 sqrt.c, sin.c,
   cos.c, exp.c  log.c, ᮮ⢥⢥.
        ⥪   math.a  ᮧ   ⠪
   :

                $ CC -c sqrt.c sin.c cos.c exp.c log.c
                $ ar cr math.a sqrt.o sin.o cos.o exp.o log.o
                $ ranlib math.a

    ᨬ $  ਣ襭 ⥬.
        砫 ࠭᫨ 室 ⥪,   㫨
    ⥬  .  ar (娢) ᮧ 娢  
   math.a. ,  ண 㯠  㭪 娢 .
   ᫨  襩 ⥬   ranlib (    㦭),
   ,  ࠩ ,    ࠢ筮 㪮⢥
   뫪   ar. ⮡ ᯮ짮 ⥪  ᢮
   ணࠬ,   ० ࠭樨 ᫥騬 ࠧ:

                $ CC myprog.c math.a

        ⠥ :    ⥪ math.a?   뫮 
   ।⢥ ᯮ짮 䠩 .o, ਬ ⠪:

                $ CC myprog.c sqrt.o sin.o cos.o exp.o log.o

     ⮬,     㤭 ࠢ쭮 㪠, 
   䠩 .o ⢨⥫쭮 㦭.  ਢ  
   ᯮ짮   . ᫨   myprog 뢠 ⮫쪮
   sqrt()  cos(), ⮣, , 筮  ⠪ :

                 $ CC myprog.c sqrt.o cos.o

     㤥 ୮, .. 㭪 cos() 뢠 sin().
         痢,  뢠  CC  ࠡ⪨
   䠩 .a ( 襬 砥  䠩 math.a), 㬥  ⢠
   䠩, ࠧ ⥪,  ⮫쪮 㦭 䠩
   .o. 묨 ᫮, 뢠  ⥪  
    ணࠬ  ।   ( ⮬ ᫥ ।
   㭪権  ६, ᯮ㥬 ⮫쪮 ७ 㭪ﬨ,
     짮⥫   㧭).    ६ 
   १ ணࠬ  ⮫쪮 쭮 室
   ᫮ ।.


   4.6 㭪樨

    ࠭ ᯮᮡ   ++ - ⢨ - 
   맮 㭪樨,  믮 ⠪ ⢨. । 㭪樨
    ᠭ ⮣,   믮. ᠭ 㭪樨
   뢠 .

   4.6.1 ᠭ 㭪権

   ᠭ 㭪樨 ᮤন  , ⨯ 頥 祭
   (᫨  )  ᫮  ⨯ ࠬ஢,  
     맮 㭪樨. ਬ:

              extern double sqrt(double);
              extern elem* next_elem();
              extern char* strcpy(char* to, const char* from);
              extern void exit(int);

       ⨪ । ࠬ஢ ⮦⢥ ᥬ⨪
   樠樨: ஢ ⨯ 䠪᪨ ࠬ஢ , ᫨
   㦭, ந室  ८ࠧ ⨯. , ᫨
    ਢ ᠭ,   ᫥饬 ।:

              double sr2 = sqrt(2);

   ᮤন ࠢ 맮 㭪樨 sqrt()  祭  饩
   窮 2.0. ஫  ८ࠧ ⨯ 䠪᪮ ࠬ
     ++ ஬ 祭.
        ᠭ 㭪樨  㪠뢠  ࠬ஢. 
   砥 ⥭ ணࠬ,  ࠭   
   .

   4.6.2 । 㭪権

    뢠  ணࠬ 㭪   -  
   ।, 祬 ⮫쪮  ࠧ. । 㭪樨 -  
   ᠭ,  ஬ ᮤন ⥫ 㭪樨. ਬ:

         extern void swap(int*, int*);  // ᠭ

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

    ⠪ । 砨,   । 㭪樨  ᯮ
    ࠬ:

         void search(table* t, const char* key, const char*)
         {
            // ⨩ ࠬ  ᯮ

            // ...
         }

      ⮣ ਬ, ࠬ  ᯮ, ᫨
      .  㭪樨   饭
   ணࠬ  ᫨ 뢠   쭥襥 ७. 
     १ࢨ஢   । 㭪樨 
   ᯮ㥬 ࠬ ࠭,  㣨 㭪樨,
   ᮤঠ騥 맮 ,  ਤ .
        ਫ,  㭪  ।  ⠭
   (inline). ਬ:

           inline fac(int i) { return i<2 ? 1 : n*fac(n-1); }

   䨪 inline 㦨 ᪠ ࠭,  맮
   㭪樨 fac  ॠ ⠭  ⥫,    
   筮 堭 맮 㭪権 ($$R.7.1.2). 訩 ⨬騩
   ࠭  樨 맮 fac(6)   ᯮ짮
   ⠭ 720. -  ४ᨢ 맮 㭪権-⠭,
    ⠪ 㭪権-⠭, ४ᨢ    室
   ,  ⢥ত,   맮 㭪樨-⠭
   ⢨⥫쭮 ॠ ⠭  ⥫. ⥯ ⨬樨,
   ஢ ࠭஬,  ଠ, ⮬ 
   ࠭ ᮧ  6*5*4*3*2*1, 㣨 - 6*fac(5), 
    ࠭ ⨬஢ 맮 fac(6).
        ⮡ ॠ 맮 ⠭ ⠫  
     ᫨誮 ࠧ ⥬ ணࠬ஢, 㦭, ⮡ 
   ⮫쪮 ।,   ᠭ 㭪樨-⠭ 室
    ⥪饩  .  ⠫쭮 ᯥ䨪 inline
      ᥬ⨪ 맮.

   4.6.3 । ࠬ஢

    맮 㭪樨 뤥    ଠ ࠬ஢,
     ଠ ࠬ 樠 祭
   ᮮ⢥饣 䠪᪮ ࠬ. ⨪ ।
   ࠬ஢ ⮦⢥ ᥬ⨪ 樠樨.  ⭮, ᢥ
   ⨯ ଠ쭮  ᮮ⢥饣  䠪᪮ ࠬ, 
   믮  ⠭  짮⥫᪨ ८ࠧ ⨯.
    ᯥ樠 ࠢ । ᨢ ($$4.6.5).
     । ࠬ,  ஫ ⨯ ($$4.6.8),
      ⠭⭮ 祭 ࠬ ($$4.6.7).
   ᬮਬ 㭪:

             void f(int val, int& ref)
             {
                val++;
                ref++;
             }

    맮 f()  ࠦ val++ 㢥稢 쭠 
   ࢮ 䠪᪮ ࠬ, ⮣   ref++ - ᠬ ன
   䠪᪨ ࠬ 㢥稢 ᠬ. ⮬  㭪樨

             void g()
             {
               int i = 1;
               int j = 1;
               f(i,j);
             }

   㢥 祭 j,   i.  ࠬ i । 
   祭,  ன ࠬ j ।  뫪.  $$2.3.10
    ਫ,  㭪樨,   ᢮ ।
    뫪 ࠬ, 㤭 ,   ⮬   
   (. ⠪ $$10.2.2).  訥 ꥪ, 祢, ࠧ
   䥪⨢ ।  뫪, 祬  祭. ࠢ 
    ࠬ  ᯥ䨪樥 const, ⮡ ࠭஢, 
   ।  뫪 ᯮ ⮫쪮  䥪⨢, 
   뢠 㭪    祭 ꥪ:

              void f(const large& arg)
              {
                // 祭 "arg"    
                // 権 ८ࠧ ⨯
              }

   ᫨  ᠭ ࠬ 뫪 const  㪠,  
   ᬠਢ  ७  । ꥪ:

             void g(large& arg); // ⠥,   g() arg 㤥 

    ࠫ: ᯮ const ,  .
       筮 ⠪ , ᠭ ࠬ, 饣 㪠⥫, 
   ᯥ䨪樥 const   ⮬,  㪠㥬 ꥪ  㤥
     뢠 㭪樨. ਬ:

             extern int strlen(const char*);  //  <string.h>
             extern char* strcpy(char* to, const char* from);
             extern int strcmp(const char*, const char*);

   祭 ⠪ ਥ    ⮬ ணࠬ.
       ⬥⨬,  ᥬ⨪ । ࠬ஢ ⫨砥  ᥬ⨪
   ᢠ.  ࠧ稥 ⢥  ࠬ஢, 
   const  뫪,  ⠪  ࠬ஢  ⨯, ।
   짮⥫ ($1.4.2).
       ࠫ, ⠭  ࠬ, ॡ騩 ८ࠧ,
    ।  ࠬ ⨯ const&,   ᯥ䨪樨
   const । . ᪠ ८ࠧ  ࠬ ⨯
   const T&,  ࠭㥬,    ਭ 祭  ⮣ 
   ⢠,   ࠬ ⨯ T, 祭 ண ।
    室   ६ ६.

           float fsqrt(const float&);  // 㭪 sqrt  ⨫ ࠭

           void g(double d)
           {
             float r;

             r = fsqrt(2.0f);  // । 뫪  ६
                               // ६, ᮤঠ 2.0f
             r = fsqrt(r);     // । 뫪  r
             r = fsqrt(d);     // । 뫪  ६
                               // ६, ᮤঠ float(d)
          }

     ८ࠧ ⨯  ࠬ஢-뫮  ᯥ䨪樨
   const   ⮣, ⮡   訡, 易
    ᯮ짮  । ࠬ஢ ६ ६:

         void update(float& i);

         void g(double d)
         {
           float r;

           update(2.0f);    // 訡: ࠬ-⠭
           update(r);       // ଠ쭮: । 뫪  r
           update(d);       // 訡:  㦭 ८ࠧ뢠 ⨯

        }

   4.6.4 頥 祭

   ᫨ 㭪  ᠭ  void,    祭.
   ਬ:

       int f() { }    // 訡
       void g() { }   // ଠ쭮

   頥 祭 㪠뢠   return  ⥫ 㭪樨.
   ਬ:

      int fac(int n) { return (n>1) ? n*fac(n-1) : 1; }

    ⥫ 㭪樨   ᪮쪮 ஢ return:

      int fac(int n)
      {
        if (n > 1)
           return n*fac(n-1);
        else
           return 1;
      }

    । ࠬ஢,  饭 祭 㭪樨
   ⭠ 樠樨. ⠥,   return
   樠 ६,  ⨯ 頥 祭.
    ࠦ   return ᢥ  ⨯ 㭪樨, 
   ந  ⠭  짮⥫᪨ ८ࠧ
   ⨯. ਬ:

         double f()
         {
           // ...
           return 1;   //  ८ࠧ  double(1)
         }

       맮 㭪樨 ᮧ    ଠ
   ࠬ஢  ⮬᪨ ६.    ᫥
   室  㭪樨 㤥 ᭮ ᯮ짮, ⮬ ࠧ㬭
    㪠⥫   ६. ন ,
     ஥ ⠪ 㪠⥫,   ।᪠㥬
   ࠧ:

          int* f()
          {
            int local = 1;
            // ...
            return &local;    // 訡
          }

    訡  ⮫ ⨯筠,  室 訡,  ⨯ 㭪樨 -
   뫪:

          int& f()
          {
            int local = 1;
            // ...
            return local;   // 訡
         }

    , ࠭ ।०  ⮬,  頥 뫪
     ६.  㣮 ਬ:

         int& f() { return 1; }  // 訡

   4.6.5 ࠬ-ᨢ

   ᫨  ⢥ ࠬ 㭪樨 㪠 ᨢ,  ।
   㪠⥫    . ਬ:

           int strlen(const char*);

           void f()
           {
             char v[] = "ᨢ";
             strlen(v);
             strlen("");
           }

    砥,  䠪᪨ ࠬ ⨯ T[] ८ࠧ  ⨯ T*,
    ⥬ ।. ⮬ ᢠ  ଠ쭮
   ࠬ-ᨢ    . 묨 ᫮,
   ᨢ ⫨  㣨 ⨯ ⥬,    ।
      ।  祭.
       뢠 㭪樨 ࠧ । ᨢ ⥭.
    ⭮,   ᪮쪮 ᯮᮡ   㤭.
   ० ᥣ,  ப 稢 㫥 ᨬ,   
   ࠧ  ᫨.  ।   ࠬ,
   騩 ࠧ ᨢ. 㣮 ᯮᮡ: ।
   , ᮤঠ 㪠⥫  ᨢ  ࠧ ᨢ, 
   ।   ࠬ (. ⠪ $$1.2.5). ਬ:

           void compute1(int* vec_ptr, int vec_size);  // 1- ᯮᮡ

           struct vec {               // 2- ᯮᮡ
             int* ptr;
             int size;
           };

           void compute2(vec v);

       묨 ᨢ,     
   ᯮ짮 ᨢ 㪠⥫, ᢥ  砨  
   ᨢ. ਬ:

          char* day[] = {
              "mon", "tue", "wed", "thu", "fri", "sat", "sun"
          };

    ᬮਬ 㭪, ࠡ  㬥 ᨢ - 楩.
   ᫨ ࠧ  ᮢ   ⠯ ࠭樨, 
   ஡ :

          void print_m34(int m[3][4])
          {
             for (int i = 0; i<3; i++) {
                 for (int j = 0; j<4; J++)
                     cout << ' ' << m[i][j];
                 cout << '\n';
            }
          }

     筮,  -० ।  㪠⥫,  ࠧ୮
  ਢ    ᠭ.
     ࢠ ࠧ୮  ᫥   
  ($$R.8.2.4), ⮬   ।  ࠬ:

         void print_mi4(int m[][4], int dim1)
         {
            for ( int i = 0; i<dim1; i++) {
                for ( int j = 0; j<4; j++)
                    cout << ' ' << m[i][j];
                cout << '\n';
            }
         }

       ᫮ 砩 -   ।  ࠧ୮.
    "祢" 襭  ਣ:

        void print_mij(int m[][], int dim1, int dim2)   // 訡
        {
          for ( int i = 0; i<dim1; i++) {
              for ( int j = 0; j<dim2; j++)
                  cout << ' ' << m[i][j];
              cout << '\n';
          }
       }

   -, ᠭ ࠬ m[][] ⨬, ᪮ 
   ᫥   ୮ ᨢ 㦭 
    ࠧ୮. -, ࠦ m[i][j]
     *(*(m+i)+j),  ,  ᥩ ,  , 
      ணࠬ. ਢ ࠢ쭮 襭:

          void print_mij(int** m, int dim1, int dim2)
          {
             for (int i = 0; i< dim1; i++) {
                 for (int j = 0; j<dim2; j++)
                   cout << ' ' << ((int*)m)[i*dim2+j];  // ⠭
                 cout << '\n';
            }
          }

   ࠦ, ᯮ㥬  롮  , ⭮
   ⮬, ஥ ᮧ  ⮩  楫 ࠭,  ⭠
   ᫥ ࠧ୮.   ⥫ ६,
   ⮡  ࠦ ⠫ ⭥:

         int* v = (int*)m;
         // ...
         v[i*dim2+j]

    ⠪ 筮 ⠭   ணࠬ 뢠.
    । ⨯ ୮ ᨢ  ᮮ⢥饩
   樥 ஢.  짮⥫    , 
   ࠧ   ᨢ (. ࠦ 18  $$7.13).

   4.6.6 ॣ㧪  㭪樨

   筮    ࠧ 㭪 ࠧ . ᫨ 
   ᪮쪮 㭪権 믮     ⢨  ꥪ⠬
   ࠧ ⨯,  㤮    ᥬ ⨬ 㭪.
   ॣ㧪  뢠  ᯮ짮  祭
   ࠧ 権  ࠧ묨 ⨯. ⢥ 㦥  ᭮
   権 ++ ਬ ॣ㧪. ⢨⥫쭮:  権
   ᫮  ⮫쪮   +,   ᯮ  ᫮
    楫 ᥫ,  ᥫ  饩 窮,  㪠⥫. 
   室   ࠭  樨, ।
   짮⥫, ..  㭪樨. ਬ:

            void print(int);          //  楫
            void print(const char*)   //  ப ᨬ

       ࠭  ⠪ ॣ㦥 㭪 饥 ⮫쪮
    - . 祢,   ⠪ 㭪樨 室,  
    ᯮᮡ   ९ 뤥 ॣ㦥 㭪権.
    ࠧ, । ॣ㦥 㭪権 㦨, ०
   ᥣ,  㤮⢠ .   㭪権  ⠪ ࠤ樮묨
   ,  sqrt, print  open,  ⨬ 㤮⢮ ७ॣ.
   ᫨ ᠬ  ࠥ  ᥬ ஫, ਬ,
    ⠪ ,  + , *   << ($$7.2),   
    ($$5.2.4  $$7.3.1),  ⠪ 㤮⢮ ⠭ ⢥
   䠪஬.  맮 㭪樨   f ࠭ 
   ࠧ,   㭪 f ᫥ 뢠.  ⮣
   ࠢ ⨯ 䠪᪨ ࠬ஢, 㪠  맮,  ⨯
   ଠ ࠬ஢  ᠭ 㭪権   f.  १
   뢠  㭪,  ன ଠ ࠬ 訬
   ࠧ ᮯ⠢  ࠬࠬ 맮,  뤠 訡
   ᫨ ⠪ 㭪樨  諮. ਬ:

           void print(double);
           void print(long);

           void f()
           {
             print(1L);    // print(long)
             print(1.0);   // print(double)
             print(1);     // 訡, 筮:  뢠
                           // print(long(1))  print(double(1)) ?
           }

   ஡ ࠢ ᮯ⠢ ࠬ஢ ᠭ  $$R.13.2. 
   筮 ਢ  . ࠢ ਬ  ᫥饬
   浪  뢠  ਮ:
     [1] 筮 ᮯ⠢: ᮯ⠢ ந諮  直
         ८ࠧ ⨯  ⮫쪮  묨 ८ࠧﬨ
         (ਬ,  ᨢ  㪠⥫,  㭪樨  㪠⥫
          㭪  ⨯ T  const T).
     [2] ⠢  ᯮ짮 ⠭ 楫᫥
         ८ࠧ, ।  $$R.4.1 (.. char  int,
         short  int      int),  ⠪
         ८ࠧ float  double.
     [3] ⠢  ᯮ짮 ⠭ ८ࠧ,
         ।  $$R.4 (ਬ, int  double, derived* 
         base*, unsigned  int).
     [4] ⠢  ᯮ짮 짮⥫᪨ ८ࠧ
         ($$R.12.3).
     [5] ⠢  ᯮ짮  ...  ᠭ
         㭪樨.
   ᫨   ᮯ⠢  ᠬ ਮ⭮ ࠢ,
    맮 ⠥ ,   訡.  ࠢ
   ᮯ⠢ ࠬ஢ ࠡ  ⮬ ࠢ ८ࠧ
   ᫮ ⨯    ++.   ⠪ ᠭ 㭪樨
   print:

          void print(int);
          void print(const char*);
          void print(double);
          void print(long);
          void print(char);

    १ ᫥ 맮 print()  ⠪:

        void h(char c, int i, short s, float f)
        {
         print(c);    // 筮 ᮯ⠢: 뢠 print(char)
         print(i);    // 筮 ᮯ⠢: 뢠 print(int)
         print(s);    // ⠭⭮ 楫᫥ ८ࠧ:
                      // 뢠 print(int)
         print(f);    // ⠭⭮ ८ࠧ:
                      // 뢠 print(double)

         print('a');  // 筮 ᮯ⠢: 뢠 print(char)
         print(49);   // 筮 ᮯ⠢: 뢠 print(int)
         print(0);    // 筮 ᮯ⠢: 뢠 print(int)
         print("a");  // 筮 ᮯ⠢:
                      // 뢠 print(const char*)
        }

   饭 print(0) ਢ  맮 print(int),  0  ⨯ int.
   饭 print('a') ਢ  맮 print(char), .. 'a' - ⨯
   char ($$R.2.5.2).
      ⬥⨬,   ࠧ襭 ।  ॣ㧪 
    冷 ᠭ ᬠਢ 㭪権,  ⨯ 頥
   㭪ﬨ 祭   뢠.
      室   ࠢ  ࠭஢,  ᫨ 䥪⨢
    筮 ᫥ ⥫쭮 ࠧ 
   ᬠਢ ⨯,  뢠 㭪, ॠ ᠬ
   ⮩ . ਬ:

            int pow(int, int);
            double pow(double, double);     //  <math.h>
            complex pow(double, complex);   //  <complex.h>
            complex pow(complex, int);
            complex pow(complex, double);
            complex pow(complex, complex);

            void k(complex z)
            {
              int i = pow(2,2);       // 뢠 pow(int,int)
              double d = pow(2.0,2);  // 뢠 pow(double,double)
              complex z2 = pow(2,z);  // 뢠 pow(double,complex)
              complex z3 = pow(z,2);  // 뢠 pow(complex,int)
              complex z4 = pow(z,z);  // 뢠 pow(complex,complex)
           }

   4.6.7 ⠭ 祭 ࠬ஢

    饬 砥  㭪樨    ࠬ஢, 祬  ᠬ
       ᯮ㥬 .  ⭮, 
   ᢮⢥ 㭪, 騬 ꥪ (ਬ, ࠬ,
   . $$5.2.4).    ᯮ짮  㭪権 
   ਬ 易⥫ ࠬ. ᬮਬ  ⢥ ਬ
   㭪  楫 ᫠.  ࠧ㬭 ਬ  ⢥
   易⥫쭮 ࠬ ᭮ ᫥ ⠥ ᫠,
     設⢥ 砥 ᫠    
   楫 祭.  㭪

            void print (int value, int base =10);

            void F()
            {
               print(31);
               print(31,10);
               print(31,16);
               print(31,2);
            }

   ⠥ ⠪ ᫠:

           31 31 1f 11111

    ⠭⭮ 祭 ࠬ  뫮  ᯮ짮
   ॣ㧪 㭪樨 print:

           void print(int value, int base);
           inline void print(int value) { print(value,10); }

     ᫥ ਠ ⥪ ணࠬ  ⮫  
      㭪 print,   ⮬ ᯥ 㤮 
     .
        ⠭⭮ ࠬ ᢥ  ⨯ 㪠 祭
    ࠭樨 ᠭ 㭪樨,  祭 ⮣ ࠬ 
     맮 㭪樨.  ⠭⭮ 祭  ⮫쪮
       ࠬ஢:

          int f(int, int =0, char* =0);   // ଠ쭮
          int g(int =0, int =0, char*);   // 訡
          int h(int =0, int, char* =0);   // 訡

   ⬥⨬,    ⥪ 稥 ஡  ᨬ *  =
   쬠 ⢥, ᪮ *=  樥 ᢠ:

         int nasty(char*=0);      // ᨭ⠪᪠ 訡

   4.6.8 । ᫮ ࠬ஢

    㭪樨,  ᠭ   㪠 ᫮
    ⨯  ⨬ ࠬ஢.  ᯨ᮪ ଠ
   ࠬ஢ 蠥 ᮬ (...),  砥:
   ", ,  ᪮쪮 㬥⮢". ਬ:

         int printf(const char* ...);

    맮 printf 易⥫쭮   㪠 ࠬ
   ⨯ char*,    (    )  㣨
   ࠬ.  ਬ:

        printf("Hello, world\n");
        printf("My name is %s %s\n", first_name, second_name);
        printf("%d + %d = %d\n", 2,3,5);

      㭪樨   ᯮ ᢮ 䠪᪨
   ࠬ஢ 㯭 ࠭ ଠ樥.  砥 㭪樨
   printf  ࠬ  ப, ᯥ饩 ଠ 뢮.
     ᮤঠ ᯥ樠 ᨬ,   ࠢ쭮
   ਭ ᫥騥 ࠬ. ਬ, %s 砥  -"㤥
   䠪᪨ ࠬ ⨯ char*", %d 砥 -"㤥 䠪᪨
   ࠬ ⨯ int" (. $$10.6).  ࠭ ⮣  , 
   ⮬    㡥,   ࠬ ⢨⥫쭮
     맮   ᮮ⢥騥 ⨯. ਬ,
   ᫥騩 맮

        printf("My name is %s %s\n",2);

   ଠ쭮 ࠭᫨,  ਢ ( 襬 砥)  
   뤠.  ஢ ᠬ.
      祢,  ࠧ ࠬ ᠭ,  ࠭   ᢥ
    ஫  ⠭ ८ࠧ ⨯ ⮣ ࠬ.
   ⮬ char  short ।  int,  float  double, 
   짮⥫, ,    㣮.
        த㬠 ணࠬ  ॡ,  
   ᪫祭,  ᪮쪮 㭪権,   㪠   ⨯
   ࠬ஢. ⮡  ஫ ⨯ ࠬ஢,  ᯮ짮
   ॣ㧪 㭪権  ⠭ 祭 ࠬ஢, 祬
   ࠬ, ⨯   뫨 ᠭ.  ⠭
   室 ⮫쪮 ⮣,     ⮫쪮 ⨯, 
    ᫮ ࠬ஢.  ᥣ  ᯮ
    । 䥩  ⥪ ⠭ 㭪権  ,
   ᫨ ⨬ 㭪  :

         extern "C" int fprintf(FILE*, const char* ...);
         extern "C" int execl(const char* ...);

       ⠭  ம।, 室騩  <stdarg.h>,
    롮  ࠬ஢  㭪権. ᬮਬ 㭪
   ॠ樨  訡,  ࠬ ன 뢠 ⥯ 殮
   訡.    ᫥ ந쭮 ᫮ ப. 㦭
   ⠢ ᮮ饭  訡  ⮬,   ᫮  
   ।  ⤥쭠 ப:

        extern void error(int ...)
        extern char* itoa(int);

        main(int argc, char* argv[])
        {
           switch (argc) {
           case 1:
              error(0,argv[0],(char*)0);
              break;
           case 2:
              error(0,argv[0],argv[1],(char*)0);
              break;
           default:
              error(1,argv[0],
                    "With",itoa(argc-1),"arguments",(char*)0);
           }
           // ...
         }

   㭪 itoa 頥 ப ᨬ, ।⠢  楫
   ࠬ. 㭪 ॠ樨  訡  । ⠪:

         #include <stdarg.h>

         void error(int severity ...)
         /*
            "severity" (⥯ 殮 訡) ᫥
           ᯨ᮪ ப, 騩 㫥
        */
        {
          va_list ap;
          va_start(ap,severity);   // 砫 ࠬ஢

          for (;;) {
              char* p = va_arg(ap,char*);
              if (p == 0) break;
              cerr << p << ' ';
          }

          va_end(ap);     // ⪠ ࠬ஢

          cerr << '\n';
          if (severity) exit(severity);
        }

      砫  맮 va_start() ।  樠
   va_list. ࠬࠬ ம। va_start   ⨯
   va_list  ᫥ ଠ ࠬ.  롮ન  浪
   ᠭ ࠬ஢ ᯮ ம। va_arg().
     饭  va_arg 㦭  ⨯  䠪᪮
   ࠬ.  va_arg() ।,  ࠬ ⠪ ⨯
     맮,  筮   ஢ .
   । 室  㭪樨,  ன 뫮 饭  va_start,
   室 맢 va_end. 稭  ⮬,   va_start()
     ⠪ 樨  ⥪, -  ४ 
    㭪樨 ⠭ .  va_end() ࠭ 
   ⥫  ⥪.
      ਢ 0  (char*)0 室 ⮬,  sizeof(int)
    易 ᮢ  sizeof(char*).  ਬ 
     ᫮,  묨 室 ⠫
   ணࠬ, ᫨  訫  ஫ ⨯, ᯮ
   .

   4.6.9 ⥫  㭪

    ⮫쪮  樨  㭪ﬨ: 맮  ⨥ .
   ⥫, 祭   ᫥ 樨, 
   ᫥⢨ ᯮ짮  맮 㭪樨. ਬ:

           void error(char* p) { /* ... */ }

           void (*efct)(char*);   // 㪠⥫  㭪

           void f()
           {
             efct = &error;       // efct ஥  㭪 error
             (*efct)("error");    // 맮 error १ 㪠⥫ efct
           }

       맮 㭪樨   㪠⥫ (efct  襬 ਬ)
    砫 ਬ  ᢥ  㪠⥫ - *efct.
   ᪮ ਮ 樨 맮 () , 祬 ਮ
   ᢥ *,    *efct("error").  㤥
    *(efct("error")),   訡.  ⮩ 
   稭 ᪮ 㦭   ᠭ 㪠⥫  㭪. ,
     efct("error") , .. ࠭ , 
   efct  㪠⥫  㭪,  ᮧ , 騥
   맮 㦭 㭪樨.
      ⬥⨬,  ଠ ࠬ  㪠⥫  㭪 뢠
   ⠪ ,     㭪.  ᢠ 㪠⥫  㭪
   ॡ 筮 ᮮ⢥⢨ ⨯ 㭪樨  ⨯ ᢠ
   祭. ਬ:

            void (*pf)(char*);          // 㪠⥫  void(char*)
            void f1(char*);             // void(char*);
            int f2(char*);              // int(char*);
            void f3(int*);              // void(int*);

            void f()
            {
              pf = &f1;                 // ଠ쭮
              pf = &f2;                 // 訡:   ⨯ 頥
                                        // 祭
              pf = &f3;                 // 訡:   ⨯ ࠬ

              (*pf)("asdf");            // ଠ쭮
              (*pf)(1);                 // 訡:   ⨯ ࠬ

              int i = (*pf)("qwer");    // 訡: void ᢠ int
            }

    ࠢ । ࠬ஢    筮 맮,
      맮   㪠⥫.
          뢠 㤮  ⨯ 㪠⥫  㭪 ,
    祬  ६ ᯮ짮 筮 ᫮ . ਬ:

    typedef int (*SIG_TYP)(int);    //  <signal.h>
    typedef void (SIG_ARG_TYP)(int);
    SIG_TYP signal(int, SIG_ARG_TYP);

           뢠  ᨢ 㪠⥫  㭪樨. ਬ,
     ॠ ⥬   ।  , ࠢ塞
    , ᯮ ᨢ 㪠⥫  㭪樨, ॠ騥 .
       ஡  ⠪ ।,   ᠬ
    騩  ᮪:

           typedef void (*PF)();

           PF edit_ops[] = { //  ।
               &cut, &paste, &snarf, &search
           };

           PF file_ops[] = { // ࠢ 䠩
              &open, &reshape, &close, &write

           };

       ।  樠஢ 㪠⥫,   
      ᪠ 㭪樨, ॠ騥 ࠭   .
     롮 ந室 ⨥  :

           PF* button2 = edit_ops;
           PF* button3 = file_ops;

      饩 ணࠬ ।  । 襥 ᫮
     ꥪ⮢, ⮡     . ਬ, 室
     - ࠭ ப,  ⥪,  㤥 뤠 
      樨.  ࠡ  ⥬  祭  
     㤥 ﭭ . 筮    ।⠢
       祭 㪠⥫, 易   襩. ᫨
     짮⥫ ࠫ  ,  ।, ਬ,
       3   2,  ᮮ⢥  ॠ
     맮:

            (*button2[3])();

         ⮡  業 魮 樨 㪠⥫  㭪,
     ⮨   ணࠬ  .   
      , ᫨   㭪樨  ⠡ .
     쭮  ᮧ     .
         ⥫  㭪樨  ॠ ᪨
     ணࠬ, .. ⠪ ணࠬ,   ਬ
      ꥪ⠬ ࠧ ⨯:

             typedef int (*CFT)(void*,void*);

             void sort(void* base, unsigned n, unsigned int sz, CFT cmp)
             /*
                ஢  "base"  n ⮢
                 饬 浪;
                ᯮ 㭪 ࠢ,   㪠뢠 cmp.
                 ⮢ ࠢ "sz".

                 祭 䥪⨢: ஢ 쪮 ⮤
              */
              {
                for (int i=0; i<n-1; i++)
                    for (int j=n-1; i<j; j--) {
                       char* pj = (char*)base+j*sz;  // b[j]
                       char* pj1 = pj - sz;          // b[j-1]
                       if ((*cmp)(pj,pj1) < 0) {
                       //  ⠬ b[j]  b[j-1]
                          for (int k = 0; k<sz; k++) {
                              char temp = pj[k];
                              pj[k] = pj1[k];
                              pj1[k] = temp;
                          }
                        }
                      }
               }

      ணࠬ sort ⥭ ⨯ 㥬 ꥪ⮢; ⭮
     ⮫쪮  ᫮ (ࠧ ᨢ), ࠧ    㭪,
       ࠢ ꥪ.  ࠫ  㭪樨 sort()
     ⠪  ,   qsort() - ⠭⭮ 㭪樨 ஢
      ⥪ .  㭪 ᯮ 騥 ணࠬ.
     ,    sort()  ஢ ⠡  ⠪
     ன:

              struct user {
                 char* name;     // 
                 char* id;       // ஫
                 int dept;       // ⤥
              };

              typedef user* Puser;

              user heads[] = {
                   "Ritchie D.M.",      "dmr",   11271,
                   "Sethi R.",          "ravi",  11272,
                   "SZYmanski T.G.",    "tgs",   11273,
                   "Schryer N.L.",      "nls",   11274,
                   "Schryer N.L.",      "nls",   11275
                   "Kernighan B.W.",    "bwk",   11276
              };

              void print_id(Puser v, int n)
              {
                for (int i=0; i<n; i++)
                    cout << v[i].name << '\t'
                         << v[i].id << '\t'
                         << v[i].dept << '\n';
              }

   ⮡   ஢, 㦭 砫 ।
   室騥 㭪樨 ࠢ. 㭪 ࠢ  
   ⥫쭮 ᫮, ᫨   ࠬ  ண,
   , ᫨  ࠢ,  ⥫쭮 ᫮  ⨢ 砥:

              int cmp1(const void* p, const void* q)
              // ࠢ ப, ᮤঠ 
              {
                return strcmp(Puser(p)->name, Puser(q)->name);
              }

              int cmp2(const void* p, const void* q)
              // ࠢ ஢ ࠧ
              {
                return Puser(p)->dept - Puser(q)->dept;
              }

    ணࠬ   ⠥ १:

             int main()
             {
               sort(heads,6,sizeof(user), cmp1);
               print_id(heads,6);    //  䠢⭮ 浪
               cout << "\n";
               sort(heads,6,sizeof(user),cmp2);
               print_id(heads,6);    //  ࠬ ⤥
             }

      ⨬      㭪樨-⠭,  
   ॣ㦥 㭪樨 ($$R.13.3).
      ⬥⨬,   ८ࠧ 㪠⥫  - 
   㪠⥫ ⨯ void*  믮  ࠬ 㭪樨, 뢠
   १ 㪠⥫  . ⮬ 㭪

           int cmp3(const mytype*, const mytype*);

    ᯮ짮  ⢥ ࠬ  sort().
   㯨 ,  蠥   ᠭ ᫮, 
   cmp3()  뢠  ࠬࠬ ⨯ mytype*. ᫨ 
   ᯥ樠쭮    ᫮,   ᯮ짮
    ८ࠧ ⨯.

   4.7 ।⢠

   ।⢠ 몠 ।  $$R.16.  ++   ࠧ
    ஫, 祬  .    ⠪ ᮢ: ᯮ
   ம। ⮫쪮 ⮣,      .
    , ⠥,  ࠪ᪨  
   ந  ᢨ⥫⢮  ⪮
   몠, ணࠬ  ணࠬ. ।⢠ ᮧ ।
   㤭  ࠡ 㦥 ⥬ ணࠬ, ᪮
    ࠡ뢠 ணࠬ ⥪   ࠭樨. ⮬, ᫨
    ணࠬ ᯮ ।⢠,
    ࢨ, ।⠢塞 ⠪ ணࠬ,  ⫠稪,
   䨫஢騪, ணࠬ ४ 뫮, 㤥  
   . ᫨ -⠪   ᯮ짮
   ப,  砫 ⥫쭮  ᠭ ९
   ++  襬 ࠢ筮 㪮⢥   ࠩ  ᫨誮 㬭.
      ⮥ ம।  :

          #define   ⮪-ப

    ⥪ ணࠬ ᥬ    ⮪-ப. ਬ,
          ꥪ = 
   㤥  
          ꥪ = ⮪-ப
      ம।   ࠬ. ਬ:

          #define mac(a,b)  argument1: a argument2: b

    ஢맮 mac     ப, ।⠢騥
   ࠬ.  ⠭   a  b  ம।
   mac(). ⮬ ப

         expanded = mac(foo bar, yuk yuk)

    ⠭ ८ࠧ 

         expanded = argument1: foo bar argument2: yuk yuk

     ந  ॣ㦠. ᨢ ஢맮 ⠢
   । ९஬ ᫨誮 ᫮ :

        // 訡:
        #define print(a,b) cout<<(a)<<(b)
        #define print(a,b,c)  cout<<(a)<<(b)<<(c)

        // ᫨誮 ᫮:
        #define fac(n) (n>1) ?n*fac(n-1) :1

     ९ ࠡ⠥  ப  ࠪ᪨ 祣   
   ᨭ⠪ C++, ⨯ 몠   . ࠭
     ⮫쪮  㦥  ம।, ⮬
   訡    ஢ 㦥 ᫥ ⠭,   
   । ந.  १  쭮 ⠭
   ᮮ饭  訡.
     ⨬ ⠪ ம।:

        #define Case break;case
        #define forever for(;;)

      ᮢ襭 譨 ம।:

        #define PI 3.141593
        #define BEGIN {
        #define END }

   騥 ம।  ਢ  訡:

        #define SQUARE(a) a*a
        #define INCR_xx (xx)++
        #define DISP = 4

   ⮡ 㡥  ⮬, 筮 ஡ ᤥ ⠭
    ⠪ ਬ:

        int xx = 0;          //  稪

        void f() {
          int xx = 0;        // 쭠 ६
          xx = SQUARE(xx+2); // xx = xx +2*xx+2;
          INCR_xx;           // 㢥稢 쭠 ६ xx
          if (a-DISP==b) {   // a-=4==b
             // ...
          }
        }

   뫪     ம। ᯮ 
  ࠧ襭   ($$2.1.1),  ,   ,
  砩  ࠬ ம।  ᪮. ਬ:

         #define MIN(a,b) (((a)<(b))?(a):(b))

     ᫨ ம। 筮 ᫮,  ॡ ਩
   ,  ࠧ㬭  ਩  /*  */, ᪮
   ॠ樨 ++  ᯮ짮 ९ ,  
  ᯮ ਨ  //. ਬ:

         #define m2(a) something(a)   /* 㡮᫥ ਩ */

        ।  ᮧ ᢮ ᮡ⢥ ,
  ࠢ, ᪮॥ ᥣ,  㤥 ⥭ 㣨. ஬ ⮣, ९
   ।⠢ 쭮 ᫠ ।⢠. ᫨  
  ਢ쭠, , ᪮॥ ᥣ, 㦨,      
  ।  ,  १砩 㤭.  ⢥
  ୠ⨢ ࠤ樮 ᯮ짮 ।   
  樨 const, inline  蠡 ⨯. ਬ:

          const int answer = 42;
          template<class T>
             inline T min(T a, T b) { return (a<b)?a:b; }

  4.8 ࠦ

  1. (*1) ⠢ ᫥騥 ᠭ: 㭪  ࠬࠬ ⨯
     㪠⥫  ᨬ  뫪  楫,  祭;
     㪠⥫  ⠪ 㭪; 㭪  ࠬ஬, 騬 ⨯
     ⠪ 㪠⥫; 㭪,  ⠪ 㪠⥫. 
     । 㭪樨,  ன ࠬ  頥 祭
      ⨯ ⠪ 㪠⥫. ᪠: ᯮ typedef.
  2. (*1)   ᫥饥 ᠭ?    ਣ?
           typedef int (rifii&) (int, int);
  3. (*1.5)  ணࠬ,  ⮩,  뤠 "Hello, world".
      砥  (name)  ࠬ  ப  뤠
     "Hello, name".  ணࠬ ⠪, ⮡  砫
     ந쭮 ᫮   ᥬ  뤠 ᢮ ਢ⢨:
     "Hello, ...".
  4. (1.5)  ணࠬ, ,    ப
     ந쭮 ᫮  䠩,   䠩 ९뢠
       㣨  cout. ᪮  ணࠬ ந室
     ⥭ 䠩,     cat   ᫮
     concatenation - ⥭).
  5. (*2) ॢ  ணࠬ  몠   ++. 
      䠩 ⠪, ⮡  ᮤঠ ᠭ 
     뢠 㭪権  ᠭ ⨯  ࠬ஢.  
       #define  ﬨ enum, const 
     inline.   䠩 .c  ᠭ 譨,  ।
     㭪権 ਢ  , ᮮ⢥饬 ++. 맮 malloc() 
     free()  ﬨ new  delete.  㦭 樨
     ਢ.
  6. (*2)  㭪 sort() ($$4.6.9), ᯮ 
     䥪⨢  ஢.
  7. (*2) ᬮ  ।  tnode  $$R.9.3. 
     㭪,   ᫮  ॢ 㧫 tnode. 
     㭪  뢮 㧫 ॢ tnode.  㭪,
      ந ⠪ 뢮  䠢⭮ 浪.
       tnode ⠪, ⮡   ᮤঠ
     ⮫쪮 㪠⥫  ᫮ ந쭮 , ஥ ࠧ頥
       new  ᢮ .  㭪 ⠪, ⮡
      ࠡ⠫   ன tnode.
  8. (*1)  㭪 itoa(),  ᯮ짮  ਬ
      $$4.6.8.
  9. (*2) ,  ⠭  䠩   襩
     ⥬. ன  ⠫ /usr/include  /usr/include/CC
     (   ⠫,  ࠭ ⠭ 
     䠩 襩 ⥬). ⠩  訩 
     䠩.
  10. (*2)  㭪,  㤥 ॢ稢 㬥
     ᨢ. (  ᨢ ⠭ ᫥).
  11. (*2)   ணࠬ,  ⠥ ᨬ 
     cin     cout  ஢ .  ᯮ짮
     ᫥騩 ⮩ ⮤ 樨:  ᨬ s ஢
     ।⠢ 砥  १ 樨 s^key[i], 
     key - ᨢ ᨬ, ।   ப. 
      ᨢ key ᯮ  横᪮ 浪,   㤥
     ⠭  室 ⮪. ࢮ砫 ⥪ 砥
      ਬ ⮩  樨  ⥬  ⠬ key.
     ᫨ ᨢ key   (   ப),  
     ந室.
  12. (*3)  ணࠬ,   ஢ ⥪,
     ஢ ᠭ  ᯮᮡ,   (.. ᨢ
     key) ⥭. ᪠: . D Kahn "The Codebreakers",
     Macmillan, 1967, New York, . 207-213.
  13. (*3)  㭪 ࠡ⪨ 訡,  ࠬ 
      ଠ饩 ப-ࠬ printf()  ᮤন ଠ
     %s, %c  %d.    ᫥ ந쭮 ⢮
     ᫮ ࠬ஢. 㭪 printf()  ᯮ. ᫨ 
     ଠ %s  㣨 ଠ⮢  ⥭,   $$10.6.
     ᯮ <stdarg.h>.
  14. (*1)    ࠫ   ⨯ 㪠⥫  㭪樨,
      ।   typedef?
  15. (*2) ᫥ ࠧ ணࠬ, ⮡  ।⠢
      ࠧ ᯮ㥬  ࠪ⨪ ⨫ . 
     ᯮ  㪢?  ᯮ ?  
      ᯮ ⠪ ,  i  x?
  16. (*1)  訡 ᮤঠ  ᫥ ம।?
           #define PI = 3.141593;
           #define MAX(a,b) a>b?a:b
           #define fac(a) (a)*fac((a)-1)
  17. (*3)  ய  묨 ﬨ,  
     ९ .  ⠩  cin,  १ 뢠
      cout. 砫 ॠ ம।  ࠬ஢.
     ᪠:  ணࠬ   ⠡  
     ᨭ⠪᪨ , 묨  ᯮ짮.
  18. (*2)  ணࠬ,   ७   (2)
       ⠭⭮ 㭪樨 sqrt(),   砩  ணࠬ
     <math.h>.   ࠦ   㭪樨 sqrt()
      ࠭.
  19. (*2)  㭪 print()  $$4.6.7.

