३ ॢ. 

   㪮⢮    ணࠬ஢ ( 몥 )

  Copyright ३ ॢ
 Email: abs@opentech.olvit.ru
---------------------------------------------------------------------------

     

६ -  ⠪ "祪"  ,
 ஬  ࠭  .
  ६ ﭭ  ,
祭   .

ਬ,     ६   "x".

        -----
       / x /
     ---------------
     | 饥     |
     | 祭,   |
     | ਬ 12 |
     ---------------

६     樨 .
 몥   砥  ࠢ⢠.

        x = 12  ;

 ⠥   " ࠢ 12",
  "᢮ ६  祭 12",
  "  騪    ᫮ 12".

 ப  ⥩訬 ,
  .   ஢ ⠢ 窠  ⮩.

ᬮਬ 

        x = x + 3;

  ࠢ. ᫨ ᬠਢ  ப  ⥬᪮
ࠢ,    襭.  ᠬ   ᠭ:

        1) " 祭 ६ "
        2) "ਡ   3"
        3) "  祭  ६ ",
            ॢ     ० 祭.

 ॠ ᢠ   :   .

        _ = _ ;

   筮 ⮨   ६  
뢠 ᫥ ࠢ १.

᫨  ६ 砥   ,  
砥 "⠢  ⥪饥 祭 ⮩ ६".

 ⮬ ⥪饥 祭 ᠬ ६  ,
  .  , "⮥  騪 祭"
 ⠢ 騪 ! 뭨 , 㣠  ⠥  騪.

⠪:

        x = x + 3 ;

 ᥩ 祭 x  12

砫     ᢠ.

                x + 3

        -----
       / x /
     ---------------
     |  12   |     |
     --------|------
             |
             |
             |   祭 (  ᫮ 12)  騪   ""
             |
             V
          x
         ⠢塞
           ᫮
            12    +    3    ---->   .

                                      15.
                                       x   ࠢ 12
                                    ( 騪  ᫮ 12)

  ᠬ ᢠ:

        x = 15 ;

             |
             |
             |  १  騪   ""
             | (ॡ   ० 祭, ᫨ 뫮)
        -----|
       / x / |
     --------|------
     |  12   V     |
     ---------------

⠫:
        -----
       / x /
     ---------------
     |  15         |
     ---------------

 ६  ⥬   ⥯ 室  祭,
 . ⮬  "६".

  몠 ணࠬ஢, ਬ  Pascal  Modula,
 ᢠ 砥 ᨬ :=    =
 㬥蠥 ⠭,    =  ਢ몭 쭮 .
 砩.

 ࠢ  祭 ६  ᯮ짮 ᪮쪮 ࠧ:

        z = x * x + 2 * x;

   ६:

        z -  १.
        x - 㦥  - 祭.

        x * x 砥 "㬭   " ( ⮬ ᠬ 祭,
              饥  騪   !)

        x * 2 砥 "  祭 "

        +     砥 ᫮.

६  .
 室 ⮬,  , ᫨  ६  
ᯮ짮  ६,    ⨫  , ਬ:

         = 1;



         = 1;

     "" ६ "",   ⢨ 
ந諮 .  訡  १砩 殮. ᫨  ६
 ,   ६     ⠤
樨 ணࠬ.

६,   ࠭ 楫 ᫠ ( ..., -2, -1, 0, 1, 2, 3, ...),
 ⠪:

        int ६1;
        int ६2;

 ࠧ ᪮쪮   ப:

        int ६1, ६2;

int 砥 ᮪饭  ᫮ integer - "楫".

     

ணࠬ ⮨  ,   ⢨.
 믮 ᫥⥫쭮  ⮬ 浪,
 ஬  ᠭ.

        /*    */
        int x, y;      /* 0 */

        /*    ,   ⮬ ᮧ 2 騪 
           楫 ᥫ
         */

        /*   - . */
        /*  筥   ஢ ᢠ  䬥⨪ */

        x = 3;          /* 1 */
        y = 4;          /* 2 */
        x = x + y;      /* 3 */
        y = y - 1;      /* 4 */
        x = y;          /* 5 */

祭 ६ (,    騪)  ⠪ ࠧ:

                           x       y
/* 0 */                    

/* ᫥ 1 */           3       
/* ᫥ 2 */           3       4
/* ᫥ 3 */           7       4
/* ᫥ 4 */           7       3
/* ᫥ 5 */           3       3

  , ६,       
ᢠ, ⨬ ஬  .

᫥  x = y;    x  y ᨭ.
 ,  "ॢ訢 ⠡祪    騪  騪"
 ந室.  ⮣,  騪   x  y ᮤঠ
 祭,       ⮣  ᫠.

        -----                       -----
       / x /                       / y /
     ---------------             ---------------
     |  3      *<--|--------<----|-- 3         |
     ---------------    1)       ---------------
        2), 3)                       4)

1)  騪 y   ᫠ 3 (ﭭ 祭).
2) ஥ ᮤন 騪 x 㭨⮦.
3) ᫮ 3   騪 x.
4)  室 騪 y ० ⠫ 3.

祭 楫 ६  뢥  ࠭ ஬ :

        printf("%d\n", x);

 㤥 ᬠਢ   "᪨".

 楫묨 ᫠  ந ⠪ 䬥᪨ 樨:

        x + y   ᫮
        x - y   ⠭
        x * y   㬭
        x / y    楫 (   ⪮; १ - 楫)
        x % y   ᫨ ⮪   楫

        5 / 2  2
        5 % 2  1

  ᢠ ᯮ ⠪ ᮪饭:

                               
x = x + 1;              "㢥  1"        x++;    ( ++x; )
x = x - 1;              "㬥  1"        x--;    ( --x; )
x = x + y;              "ਡ y"           x += y;
x = x * y;              "㬭  y"         x *= y;
x = x / y;              "  y"         x /= y;

 ⮬ ᫥ x++;    x += 1;

      *   *

筮  믮 ᫥⥫쭮,
 ⮬ 浪,  ஬  ᠭ  ணࠬ.

        1;      |
        2;      |
        3;      |
        4;      V

      

        if(᫮) ;

        ...த...

⠥ ⠪:

         ᫮.

        ᫨  ⨭,  믮 ,
             ⥬ 믮 த.

        ᫨  ,  ࠧ 믮 த,
                믮.

᫨   믮  ⨭ ᫮ ᪮쪮 ஢,
     ᪮ { ... } -  ⠪ 뢠
"⠢ ".

        if(᫮) {
                1;
                2;
                ...
        }
        த

᫥ } 窠  ⮩   (  ⠢,   㦭).

᫮  ࠦ  奬 ⠪:

                |
                |
                |
        ----------------
     ---|  ᫮ |----
     |  ----------------   |
     |                     |
     V                     V
   ⨭               
     |                     |
     V                     |
------------               |
|  |               |
------------               |
     |                     |
     ------->-------<-------
                |
                |
                V
          த
                |

  ଠ,   "":

        if(᫮) _᫨_⨭;
        else        _᫨_;

" ,  㣮" (   ࠧ)

                |
                |
                |
        ----------------
     ---|  ᫮ |-----------
     |  ----------------          |
     |                            |
     V                            V
   ⨭                      
     |                            |
     V                            |
-------------------------    -----------------------
| _᫨_⨭ |    | _᫨_ |
-------------------------    -----------------------
     |                            |
     ------->-------<--------------
                |
                |
                V
          த
                |

ਬ1:

        if(x > 10)
                printf("  \n");

ਬ2:

        int x, y, z;

        if(x < y)       z = 1;
        else            z = 2;

᫮:

         ⢥ ᫮  ᯮ짮  
        (ࠢ  ६, ࠦ, ⠭)

        x <  y          
        x >  y          
        x <= y            ࠢ
        x >= y            ࠢ
        x == y          ࠢ
        x != y           ࠢ

            ⢥ १ 樨 ࠢ 뤠
        1, ᫨ ࠢ ⨭
        0, ᫨  .

 ࠧ,  ᠬ  ᫮  ࠡ⠥ ⠪:

        if(᫮) ....

᫨ ᫮                                 -  ᫮ ⠥ .
᫨ ᫮     ... -2, -1, 1, 2, 3, ... -  ᫮ ⨭.

 ।.

   ⭮ ⥪,  ࠢ  楫 㫥  ᪠:

if(x != 0) ... ;        ᮪頥           if(x)  ... ;
if(x == 0) ... ;        ᮪頥           if(!x) ... ;
---------------------------------------------------------------------------

ਬ:

        int x, y, z;

        if(x == 1){ y = 2; z = x + y; }
        else      { y = 1; z = x - y; }

---------------------------------------------------------------------------

ਬ  묨 ᫮묨 ࠬ:

        if(x == 1){
                printf(" ࠢ 1\n");
                if(y == 2){
                        printf("४ ࠢ 2\n");
                }
        } else {
                printf("  ࠢ 1\n");
        }
---------------------------------------------------------------------------

 ਬ ᫥⥫쭮 ᫮ ஢,
ॡ ࠧ ਠ:

        if(x == 1)
                printf(" ࠢ 1\n");
        else if(x == 2)
                printf(" ࠢ 2\n");
        else if(x == 3){
                printf(" ࠢ 3\n");
                y = 1;
        } else
                printf("।ᬮ७ 祭 \n");
---------------------------------------------------------------------------

 ᫮ - ਢ몭  ⮬,  ࠢ 砥  ==,
  =
 = 砥 "᢮ 祭",   "ࠢ  ࠢ⢮".

      while ("  ,  ⨭")

        while(᫮)
                ;
        ...த...



        while(᫮){
                ;
                ...
        }
        ...த...

                |
                V
                |
      +------>--+
      |         |
      |         V
     |     ---------------------
     |     | ஢  |-------> ᫨  ()
     A     ---------------------             |
     |         |                             |
     |         V                             |
     |     ᫨ ⨭ ( )            |
     |         |                             |
     |         V                             |
     |                               V
      |         |                             |
      |         |                             |
      +-----<---+                             |
                                              |
                +-------<---------------------+
                |
                V
            த

ਬ:
        int x;

        x = 10;
        while(x > 0){
                printf("x=%d\n", x);
                x = x - 1;
        }
        printf(".\n");
        printf("x ⠫ ࠢ %d.\n", x);       /* ⠥ 0 */

""  ⮬,   ⥫  ᪮쪮 ࠧ.

⮡ 横 稫, -⥫ 横  
- ६,  ன  ⨭ ᫮ ७.

      ", , "

᫮   ᫮묨.

            < 10  ...;
           ᨭ   ...;
            ...;

 몥  ⠪ ᫮ 뢠 ⠪:

        if(᫮1 && ᫮2) ...;           /* ""   */
        if(᫮1 || ᫮2) ...;           /* "" */
        if(! ᫮1)           ...;           /* ""  */

ਬ:

        if(4 < x && x <= 12) ...;

뫮  ࠢ쭮 

        if(4 < x <= 12) ...;

  ணࠬ஢     ࠢ!

 ਬ:

        if(x < 3 || y > 4) ...;

        if( ! (x < 3 || y > 4)) ...;

      for (" ")

 横       ਠ⮢ 横 while.
 㦨 筮  믮 । ⢨ ᪮쪮 ࠧ,
 " ⨭ ᫮",  "믮 N-ࠧ".

 ⠪ 横  "६ 横"  "稪 ७".

        int i;

        i = a;  /* 砫쭠 樠 */

        while(i < b){

                ⥫_横;

                i += c; /* 㢥祭 稪 */
        }
        ...த...

९뢠  

        int i;

        for(i=a; i < b; i += c)
                ⥫_横;

⥫_横 㤥 믮  祭 i
        a
        a+c
        a+c+c
        ...

         i < b

 ⥩襬 砥

        for(i=1; i <= N; i++)
                printf("i=%d\n", i);

i 砥 " ७".

 横 㦨  ७  ⢨  ࠧ
 ࠧ 祭 ࠬ.

      break ("뢠  横")

 break ⠢ ࢠ 믮 ⥫ 横
 ࠧ ३  த ணࠬ.

        while(᫮1){
                1;

                if(᫮2)
                        break;  ------->----+
                                            |
                2;                 |
        }                                   |
        ...த...<--------<---------+



        for(i=0; ᫮1; i++){
                1;

                if(᫮2)
                        break;  ------->----+
                                            |
                2;                 |
        }                                   |
        ...த...<--------<---------+

   ࣠뢠 ⥫
窨 室  横 ( ⥫ ᫮).

ਬ:

        for(i=0; i < 20; i++){
                printf("i=%d\n", i);
                if(i == 7){
                        printf("break loop!\n");
                        break;          /* 뢠  横 */
                }
                printf("more\n");
        }
        printf("finished, i=%d\n", i);  /* ⠥ 7 */

 ⭮,     ࣠뢠 ᪮ 横:

        for(;;){        /*  ᪮筮 横 */
                1;

                if(᫮2)
                        break;  ------->----+
                                            |
                2;                 |
        }                                   |
        ...த...<--------<---------+

  ᠬ  横    ,
⠪ 横 த ᪮筮.
᫮ த ⠥ ᥣ ⨭.

⢥ ᯮᮡ    -
 ᤥ break ( - ᫮)  ⥫ 横,   ᠭ.

᪮ 横  ⠪ ࣠  
        while(1){
                ...
        }

       ()

        printf("⥪");

⠥  ࠭ ⥪.

        printf("⥪\n");

⠥  ࠭ ⥪  室   ப.

        printf("᫮1 ᫮2 ");
        printf("᫮3\n");

⠥

᫮1 ᫮2 ᫮3
 室   ப.

᫨ 室   ப   , ᨬ \n,
 ⥪ த   ⥪饩 ப.

        printf("%d", x);

⠥  ⥪⮢   ६ x.
樠쭠  %d 砥
" ६  ᯨ᪠ ᫥ ⮩
    祭   楫 ᫠".

        printf(" ࠢ %d - -\n", x);

⠥ ᭠砫 ⥪

                 ࠢ

⥬ 祭 ६ x  楫 ᫮,
⥬ ⥪
                - -

 室   ப (᪮ 㪠 ᨬ \n).

     ᪮쪮 祭 ६:

        int x, y;

        x = 12; y = 15;
        printf("  %d, ४  %d, .\n", x, y);
                                                    ~~~~~~

  ࠡ⠥ ⠪.
ப "  %d, ४  %d\n" 뢠 .
 ⠥ ଠ ᫥ ࠢ  ⠥ ⥪
  ,    ᨬ %d.
 ࠦ ᨬ _

          _

    ६  ᯨ᪠ ~~~~ 
⠥   楫 ᫮.

          12_

  ᭮ ⠥ ⥪    %d

          12, ४  _

    ६  ᯨ᪠  ⠥ :

          12, ४  15_

 ⠥ ⥪,  ॢ ப \n.
 ⮫쪮 ப ଠ 稫,  printf 襭.

          12, ४  15, .
        _

   ⮫쪮 祭 ६,   祭 䬥᪨
ࠦ:

        printf("ࠢ: %d\n", 12 + 3 * 5);

஫ ,  ⠥:

        int x, y, z;

        x = 13;
        y = 23;
        z = 34;

        printf("x=%d xx=%d\nzzz=%d\n", x, y - 1, z * 2 + 1);

  ଠ   ॢ ப,
⮬ 㤥 ⠭:

        x=13 xx=22
        zzz=69
        _

,  । ⥬   ⠭묨,
ࠦ  ᯨ᪥ ᫥ ଠ .

 ⠥

        printf("x=%d\n y=%d\n", x, y);

x=13
 y=23
_

஡ । y  ⮬,   
 ப ଠ ᫥ ᨬ \n !!!
 ⥫.

     

㭪樥 뢠 ࠣ ணࠬ,
  । ,
   祭 ( 祣).

५ 㭪樨  ⮬,    믮  ࠧ
 ࠧ 祪 ணࠬ.

㭪 ⮨ 

              - ᠭ ⮣,   - 
                           뢠 ஢ .

                 -  묨 祭ﬨ ࠬ஢,
                                ࠧ ᫨.
                          맮   ᪮쪮 㣮.

 ⥩襩 㭪樨 룫廊 ⠪:

        int func(int x){

                /*   ᪮쪮 ஢,
                    ஬ return();
                 */

                return x+1;
        }

---------------------------------------------------------------------------

        int func(...

 㭪   func
( 뢠 ணࠬ,    ६).

        int 砥,  㭪 頥 楫 祭.
---------------------------------------------------------------------------

        ...(int x)...

 ᯨ᮪ 㬥⮢ ( ࠬ஢) 㭪樨.
---------------------------------------------------------------------------

              ...){
              ...
        }

 ⥫ 㭪樨 -  ᫥⥫쭮 
६  ஢.
---------------------------------------------------------------------------

                return ࠦ;

  室  㭪樨    맮  ⮬ 祭
ࠦ.
---------------------------------------------------------------------------

 ⮩ ਬ  ⮩ 㭪樨:

        int y;
        ...
        y = func(5);            /* a */
        ...த...       /* b */

 ࠣ ࠡ⠥ ᫥騬 ࠧ:

        y = func(5);

 ⮩ 窥 
        1) "뢠  㬠",
            맮 ந襫  ⠪- ப, ⠪- 
           襩 ணࠬ.

        2) ਬ   㭪樨 func.

            int func(int x){...

         맢 㭪  func(5).
         ,   ⥫ 㭪樨 x 砥 砫쭮 祭 5.

              㭪 ( ⥫) ॢ頥 

                int x;

                x = 5;
                return x+1;

        3) x+1  6.

             믮  return.

            믮 ⠪:

            "⠥  㬠" - 㤠 뫠 맢 㭪 func,
            ᬮਬ   .  뫮

                y = func(5);

           ન func(5)  塞   ࠦ,
           ᫥   return;

                y = 6;

        4) 믮塞    室  த.

---------------------------------------------------------------------------

        int y, z, w;

        y = func(5);
        z = func(6);
        w = func(7) + func(8) + 1;

ॢ 

        y = 6;
        z = 7;
        w = 8 + 9 + 1;

 ⮬   ࠧ "룭"  । 㭪樨 func(),
ன     ࠧ묨 祭ﬨ ࠬ x
 ୥ ⭮   맮.

       

ணࠬ  楫 ⮨  㭪権.
  㭪権    main(),

          main   .

        ( ᠬ  ⮬ । ⢥  樠
          ६; ᬮ ᫥騥 樨).

 main() - ⢥ 㭪  ணࠬ.

---------------------------------------------------------------------------

 ணࠬ ⠪:

        #include       /* ᪠ ப */

        /*   (  ) */
        int a = 7;
        int b;          /*  㬮砭 0 */

        /*  */
        f1(){....}
        f2(){....}

        /*  ()  */
        void main(){
                ...
        }
---------------------------------------------------------------------------

ਬ ணࠬ:

#include

int f1(int x, int y){
        return (x + y*2);
}

int f2(int x){
        int z;

        z = x+7;
        return 2*z;
}

void main(){
        /*  ६ */
        int a, b, c;

        /*  */
        a = 5; b = 6;

        c = f1(a, b+3);
        b = f1(1, 2);
        a = f2(c);

        printf("A  %d B  %d C  %d\n", a, b, c);
}

 ⠥:

A  60 B  5 C  23

         

        int i;

        for(i=0; i < 4; i++){
                if(i == 0)      func0();
                else if(i == 1) func1();
                else if(i == 2) func2();
                else if(i == 3) func3();
        }

  ਬ 横   .
,   ,    ஢:

        func0();
        func1();
        func2();
        func3();

    ⮣,   ࠧ 뢠
    ⢨,    饥  ࠬ, த func(i).
  ࠧ 㭪樨  ࠧ i.

筮, ᬮਬ ⠪ ਬ:

        int i;

        for(i=0; i < 10; i++){
                if(i==0)        func0();
                else if(i == 1) func1();
                else if(i == 2) func2();
                else            funcN(i);
        }

 funcN(i)   ᥡ ஫ "  ⠫ ".
,  ਬ  ⢥   ᠭ ⠪:

        int i;

        func0();
        func1();
        func2();
        for(i = 3; i < 10; i++)
                funcN(i);

,  横 ⥯ 稭   3.

 ⥯ - 砩,  ᬥ 横  ᫮  ࠢ:

        int i;

        for(i=0; i < 100; i++){
                if((i % 2) == 0) even();        /*  */
                else             odd();         /*  */
        }

  横 ஢ ⭮  i.
     03.c

/* 㣮쭨  祪 */

#include

/* putchar('c') - ⠥  ᨬ c */
/* ᨬ \n - ॢ ப              */
/* nstars - ᪮쪮 祪      */

/* 㭪 ᮢ  ப 㣮쭨 */
void drawOneLine(int nstars){
        int i;          /*  ⠥ 窨, 稪 */

        for(i=0; i < nstars; i++)  /* 㥬 nstars 祪   */
                putchar('*');
        putchar('\n');             /*  室  ᫥ ப */
}

void main(){
        /*   */
        int nline;      /*  ப */

        /*   () */
        for(nline=1; nline <= 25; nline++)
                drawOneLine(nline);
        /* ᪮쪮 祪? ⮫쪮 ,   ப */
}
     04.c

/* 㣮쭨  祪 */
/*   ਬ   横,    㭪樥 */

#include

void main(){
        /*   */
        int nline;      /*  ப */
        int i;          /*  ⠥ 窨, 稪 */

        /*   () */
        for(nline=1; nline <= 25; nline++){
                /* ᪮쪮 祪? ⮫쪮 ,   ப */
                for(i=0; i < nline; i++)
                        putchar('*');
                putchar('\n');
        }
}
     05.c

/* 㣮쭨  祪 */
/*  㣮쭨   ࠢ७ */

#include

/* nstars  - ᪮쪮 祪      */
/* nspaces - ᪮쪮 ஡  । 窠 */

void drawOneLine(int nspaces, int nstars){
        int i;          /*  ⠥ 窨, 稪 */
                        /*   -  ⠥ ஡   */

        for(i=0; i < nspaces; i++)
                putchar(' ');
        for(i=0; i < nstars; i++)
                putchar('*');
        putchar('\n');
}

/*
                        n ( ப)
     ...*               1
     ..***              2
     .*****             3
     *******            4

        ᥣ ப:                                    LINES
        ᫮ 祪  n- ப:                  n*2 - 1
        ᫮ ஡ ᯥ। (祭 窮):     LINES - n

          ᫠ 뢠  ⨭...

          㤥 ।  㭪 drawOneLine  窥 _맮_,
            ᠬ 㭪樨. 㭪  ⮣  ,
        ⮡   祣  -
         ࠬ  ६,     
         窨 맮.

         ⢥ ࠬ  窥 맮  । 
        ⮫쪮 祭 ६,   祭 ࠦ,
          .

*/
void main(){
        /*   */
        int LINES = 25; /* ᥣ ப.
                            ᠭ ६
                           ࠧ   樠樥
                         */
        int nline;      /*  ப */

        /*   () */
        for(nline=1; nline <= LINES; nline++)
                drawOneLine(LINES - nline,   /* ᫮ ஡  --> nspaces */
                            nline*2 - 1      /* ᫮ 祪 --> nstars */
                           );
}
     06.c

/* 㣮쭨  祪 */
/*  㣮쭨   ࠢ७ */

#include

void drawOneLine(int nspaces, int nstars){
        int i;          /*  ⠥ 窨, 稪 */
                        /*   -  ⠥ ஡   */

        for(i=0; i < nspaces; i++)
                putchar(' ');
        for(i=0; i < nstars; i++)
                putchar('*');
        putchar('\n');
}

void main(){
        /*   */
        int LINES = 25; /* ᥣ ப. */
        int nline;      /*  ப */

        /*  祫 ⢥   1.
            設  ࢮ ᫮ -  .
           ⮬ 横
                for(nline=1; nline <= LINES; nline++)
              
                for(nline=0; nline <  LINES; nline++)

            ⮦ 믮 25 ࠧ,  祭 ६-稪
                nline 㤥   樨  1 . ⮬ 
                  ࠬ஢  㭪樨 ᮢ.

                        n ( ப)
     ...*               0
     ..***              1
     .*****             2
     *******            3

        ᥣ ப:                                    LINES
        ᫮ 祪  n- ப:                  n*2 + 1
        ᫮ ஡ ᯥ। (祭 窮):     LINES - n - 1

        */

        /*   () */
        for(nline=0; nline < LINES; nline++)
                drawOneLine(LINES - nline - 1, nline*2 + 1);
}
     07.c

/*
         ६  ࠭  뢠

                char

        ( ᫮ character).

        㪢 ࠦ   窠 'a'  'b'   '+'.

        ਬ:
                char letter;

                letter = 'a';
                putchar(letter);
                letter = 'b';
                putchar(letter);
                letter = '\n';
                putchar(letter);

         '\n' 砥 " 㪢" -
        室   ப, new line.
         ᪮쪮 ⠪ ᯥ樠 㪢,   - .

         ࠧ ᤥ .
        ⮡ ࠧ ᠬ 㪢 \
        ᫥ ᯮ짮 '\\'

                putchar('\');   
                printf ("\");   訡.

        :   putchar('\\');  printf("\\");

          ⮬,  ᨬ \ 稭 ᫥⥫쭮   㪢,
        ࠦ  㪢,  뢠 ᯥ樠
        ⢨  ࠭   ਭ.
*/

/*
        ᫮   n, ᫨      n ࠢ 0,
          ᫨

                        (x % n) == 0

         ⭮, ⠪  ஢ ᫠  ⭮/⭮,
         x%2.

        ⪨   ᫠ x  n
         0 1 2 ... n-1.
         砥   2 ⮪
                0 ᮮ⢥ ⭮   x
                1 ᮮ⢥ ⭮ x

*/

/* :
        ᮢ 㣮쭨
         祪   ப
         ᨪ    ப
 *--------------------------------------------------------*

 襭: ᯮ㥬 ० ணࠬ,
   㭪 drawOneLine   㬥 - symbol -
  ᨬ ᮢ ப.

   ᭮ 横 ᯮ㥬 ᫮  
 ஢  ப  ⭮.

*/

#include

void drawOneLine(int nspaces, int nsymbols, char symbol){
        int i;          /* 稪 */

        for(i=0; i < nspaces; i++)
                putchar(' ');
        for(i=0; i < nsymbols; i++)
                putchar(symbol);
        putchar('\n');
}

/*  뭥ᥬ  ⮩ ६  㭪樨,
   ᤥ  "쭮",      㭪.
 */
int LINES = 25; /* ᥣ ப. */

void main(){
        /*   */
        int nline;      /*  ப */

        /*   () */
        for(nline=0; nline <  LINES; nline++){

                if((nline % 2) == 0)    /* ⭮ ? */
                        drawOneLine(LINES - nline - 1, nline*2 + 1, '+');
                else    drawOneLine(LINES - nline - 1, nline*2 + 1, '*');
        }
}
     08.c

/*   ᠬ,  ⥯ 㦭     ப.
 */

#include

/* -  ६
   ਭ   ᠬ 砫 䠩  ணࠬ.
 */

int LINES = 25; /* ᥣ ப. */

/*   㭪樨   㬥, 㪠⥫ -  
    ப.   drawLineNumber.
      㦤      drawOneLine() !
     砥 -    -  .

    if(x) .....;
      (⠪  ஥):
         ⢥ ᫮  ਭ 楫 ᫮ (⨯ int).
        ᫮ ⨭, ᫨ x != 0,
         , ᫨         x == 0.

   ன  㬥 - ᮡ⢥  ப.
*/
void drawOneLine(int nspaces,
                 int nsymbols,
                 char symbol,
                        /*     */
                 int drawLineNumber,
                 int linenum
){
        int i;          /* 稪 */

        if(drawLineNumber)
                printf("%d\t", linenum);  /*  ॢ ப */

        /*  ᠬ   ᫮    뢠 

              if(drawLineNumber != 0)

             몥     ᠬ.
        */

/*   ᭮   ᯥ樠 ᨬ \t - .
    ࠭ (  㬠) ᫮ 
     ਭ  8 権.
   ਬ୮ ⠪:
|       |       |       |       |       |       |       |       |       ...
    ⠡樨 뢠 室  ⥪饩 樨  砫 ᫥饩
   . ਬ
|       |       |       |       |       |       |       |       |       ...
                    ^ 

|       |       |       |       |       |       |       |       |       ...
                        ^   

*/
        for(i=0; i < nspaces; i++)
                putchar(' ');
        for(i=0; i < nsymbols; i++)
                putchar(symbol);
        putchar('\n');
}

void main(){
        /*   */
        int nline;      /*  ப */

        /*   () */
        for(nline=0; nline <  LINES; nline++){

            if((nline % 2) == 0)    /* ⭮ ? */
                    drawOneLine(LINES - nline - 1, nline*2 + 1, '+', 1, nline);
            else    drawOneLine(LINES - nline - 1, nline*2 + 1, '*', 9, nline);
        }

        /*  祬  1   9 ?
         *    ,    0.
         *  3, 333, 666, -13445, 
         *
         * :  㤥, ᫨   0 ?
         */
}
     09.c

/*   㤥  ⮣,
   ⮡  ப 㣮쭨 ⠫
    :
        *+*+*+*.....*+*

     㦥 ਤ ஢ 㭪 ᮢ ப.
*/

#include

int LINES = 25; /* ᥣ ப. */

void drawOneLine(int nspaces, int nsymbols){
        int i;

        for(i=0; i < nspaces; i++)
                putchar(' ');

        /*  横  㤥 ஢  ⭮ 
           ⠥ ᨬ.
         */
        for(i=0; i < nsymbols; i++){
                if((i % 2) == 0)
                        putchar('*');
                else    putchar('+');
        }
        putchar('\n');
}

void main(){
        int nline;      /*  ப */

        for(nline=0; nline <  LINES; nline++) {
                drawOneLine(LINES - nline - 1, nline*2 + 1);
        }
}
     10.c

/*  ᮢ :
        *
       ***
      *****
       ***
        *
*/

#include

int LINES = 10; /* ᥣ ப   ஬. */

void drawOneLine(int nspaces, int nsymbols){
        int i;

        for(i=0; i < nspaces; i++)
                putchar(' ');

        for(i=0; i < nsymbols; i++)
                putchar('+');
        putchar('\n');
}

void main(){
        int nline;      /*  ப */

        for(nline=0; nline <  LINES; nline++)
                drawOneLine(LINES - nline - 1, nline*2 + 1);

        /*  ᮢ 㣮쭨.
             㦥 ॢ 㣮쭨.
           襬 横  뢠 .
               ப 뢠  ⭮ 浪:
            LINES-2  0
         */

        for(nline=LINES-2; nline >= 0; nline--)
                drawOneLine(LINES - nline - 1, nline*2 + 1);
}
     11.c

/*  ⥯ 㥬 ஬, ᯮ ⥬᪨ . */

#include

void draw(int nspaces, int nstars, char symbol){
        int i;

        for(i=0; i < nspaces; i++)
                putchar(' ');
        for(i=0; i < nstars; i++)
                putchar(symbol);
        putchar('\n');
}

void main(){
        int LINES = 21;
        int MIDDLELINE = LINES/2 + 1;   /* । ஬ */
        int nline;

        for(nline=0; nline < MIDDLELINE; nline++)
                draw(MIDDLELINE - nline -1, nline*2+1, 'A');

        /*  ᫥饣 横 for()  樠樨
           砫쭮 祭 .
           砫쭮 nline ᫥  ।饣 横,
           ⠪,   ⠫ ᫥  砭,  
           ࠢ MIDDLELINE.
         */

        for( ; nline < LINES; nline++)
                draw(nline - MIDDLELINE + 1, (LINES - 1 - nline) * 2 + 1, 'V');
}
      * 12_ARRAYS.txt *

     

ᨢ -  ᪮쪮 ஭㬥஢ ६,
         ꥤ 騬 .
          ६      .

ᬮਬ   N 騪,
   - var.
  騪-祩  
        var[0]
        var[1]
        ...
        var[N-1]

㬥   .

          --------
         /  var  /
        /       /
        -------------------------------------------  ------------------
        |           |           |           |            |            |
        |           |           |           | ....   ... |            |
        |           |           |           |            |            |
        -------------------------------------------  ------------------
         / var[0] /   / var[1] /   / var[2] /             / var[N-1] /
         ---------    ---------    ---------              -----------

ᨢ  ⠪:

        int var[N];

 N -  ࠧ, ᫮ 祥.

 ᠭ    N ६ ⨯ int  
        var[0] ... var[N-1];

   饭  n-  ( 0 <= n < N)
ᯮ  騪

        var[n]

 n - 楫 祭 ( 祭 楫 ६,
 楫᫥ ࠦ), "  ᨢ".
  [] 뢠 " ᨢ".
 -     N 騪   㪠 楫 .
        var    - ᨢ (N 祥)
        n      - ࠦ (㫠), 뤠 楫 祭  ࢠ 0..N-1
        var[n] -    ⮢ ᨢ.   .
        n      -  騪 - 뢠   "ᮬ" ⮩ ६  ᨢ.

ਬ:

        int var[5];                                     /* 1 */

        var[0] = 2;                                     /* 2 */
        var[1] = 3 + var[0];                            /* 3 */
        var[2] = var[0] * var[1];                       /* 4 */
        var[3] = (var[0] + 4) * var[1];                 /* 5 */

        printf("var   %d\n", var[3]);

 室 ⮩ ணࠬ  ᨢ  ⠪ ࠧ:

          var[0]    var[1]     var[2]     var[3]    var[4]
          ------------------------------------------------
/* 1 */                         
/* 2 */   2                          
/* 3 */   2         5                     
/* 4 */   2         5          10              
/* 5 */   2         5          10         30        

 ,      祩 ᨢ  ࠧ.

ᨢ -  ६,    ࠧ묨 ,
த var0, var1, var2, ...
    :
var[0], var[1], var[2], ...

 -   .

 ᠬ   - 
        1) 롮   ᨢ
        2) ࠢ  ᢠ   ࠦ -   ࠧ묥,
             ⨥   ६ - 祭,   ࠭饣.
---------------------------------------------------------------------------

᫨  ६  뫮 ᥭ 祭,
  ᯮ㥬  ६,
     (, ।᪠㥬 祭).

        printf("var4  %d\n", var[4]);

⠥   㣮.

⮬ ६  ᥣ 樠஢
(  砫쭮 祭).

 ६ ⮬᪨ 樠 㫥,
᫨    .

 ६  樠 ⮬᪨,  ᮤঠ .
---------------------------------------------------------------------------

ᨢ  ᢠ 楫,   ⮣  㬥.

        int a[5];
        int b[5];

        a = b;  /* 訡 */

  ᢮ 祭 ࠧ ᥬ ⠬ (祩) ᨢ:

        a = 0;  /* 訡 */

  ⮣,   ,   訡.
 㫥  祥 ᫥ ᯮ짮 横:

        int i;

        for(i=0; i < 5; i++)    /*   i ᢮ a[i] = 0; */
                a[i] = 0;

---------------------------------------------------------------------------

   
=======================
᫥⢨ ⮣ ᨢ 室 ஢ ( 樠஢)
⭮,  横 ॡ  ( ) 祩 ᨢ.

        int i;

        for(i=0; i < 5; i++)
                a[i] = b[i];

  砥  横 㦨 ⠪  ᮬ  ᨢ.

          ᨢ   .

ਬ 樠樨:

        int index, array[5];

        for(index=0; index < 5; index++)
                array[index] = index * 2 + 1;



        int index, array[5];

        index = 0;
        while(index < 5){
                array[index] = index * 2 + 1;
                index++;
        }

        /*  ᨢ 㤥: { 1, 3, 5, 7, 9 } */


         ᨢ -
                 "騪/祩"  ᨢ.

         横 -
                 ७ 横, 稪.
                    .

筮 ᨢ  横 ᮢ ⠪:
 横    ᨢ;
   横 ᯮ  ॡ 
⮢ ᨢ:

        int a[N], i;

        for(i=0; i < N; i++)
                ...a[i]...
---------------------------------------------------------------------------

ਬ:

        int a[5];

        a[0] = 17;
        a[0] += 4;
        a[0]++;
---------------------------------------------------------------------------

ਬ: ᫠ .
 ⥬᪨ 㫠:

        f[1]   = 1
        f[2]   = 1
        f[n+2] = f[n+1] + f[n]

 ணࠬ:
---------------------------------------------------------------------------

#include       /* ᪠ ப */
#define N 20            /* ᪮쪮  ᥫ  */

void main(){
        int fibs[N], index;

        fibs[0] = 1;    /*  뢠  !!! */
        fibs[1] = 1;

        /*  ,    ᨢ   */

        for(index=2; index < N; index++)
                fibs[index] = fibs[index-1] + fibs[index-2];

        /* ᯥ⪠  ⭮ 浪 */
        for(index = N-1; index >= 0; index--)
                printf("%d- ᫮   %d\n",
                        index+1,                   fibs[index]);
}

       #define
  ⥪㠫  ᫮ N  ᫮ 20,
  砥   ⮬

        const int N = 20;

  ࠧ ᨢ       ६,
    , ।  #define - .

     

ப  ᨢ  - ⨯ char,
稢騥 ᯥᨬ \0

        char string[20];

        string[0] = '';
        string[1] = '';
        string[2] = '';
        string[3] = '';
        string[4] = '';
        string[5] = '';
        string[6] = '\0';

        printf("%s\n", string);

%s - ଠ   .
 㣨 ᨢ    ⠭
楫  ஬.

        char string[20];

        string[0] = '';
        string[1] = '';
        string[2] = '';
        string[3] = '';
        string[4] = '';
        string[5] = '';
        string[6] = '\n';       /* ॢ ப - ⮦ 㪢 */
        string[7] = '\0';

        printf("%s", string);

  

        printf(string);

 ᨢ     ப 㪢  ""

        char string[20] = "ਢ\n";

⠢訥 ᯮ짮묨 ᨬ ᨢ  string[8]  string[19]
ᮤঠ .

     " "?
=================================================
ப -   ᨢ 㪢.
 ࠧ ६ ᫮ 㪢  ப   ࠧ,
   ॢ蠫 ࠧ ᨢ (⮣  ᡮ ணࠬ).
, ᫥ - ࠭ ⥪  ப (᫮ ᯮ짮
ᨬ).   襭:
(1)      ⤥쭮 ६.  ᫥ ।  
        㭪樨 ࠡ⪨  ப (祬   ).

        char str[32];     /* ᨢ  ப */
        int  slen;        /*   slen 㪢  ⮬ ᨢ */
        ...
        func(str, &slen); /*  㬥  ।  ப */
        ...

         室 ࠡᯮᮡ,  ப ࠧ  
        ꥪ: ᠬ ᨢ  ६   . 㤮.

(2)     ࠭ ⥪    str[0],
         㪢 -  str[1] ... .
         ⥬,   str[0]  ࠭  ᫠  0  255,
         ᫨ ப  -  ⠪ 室 ਬ.

(3)      ࠭  ,   ᨬ-ਧ  ப.
         

        func(str);      /*  㬥 - ᠬ ᨢ */

        । ⮫쪮 ᠬ ᨢ,   ⥪   
         㦤 ᫥    㭪樨, த ⠪:

int strlen(char s[]){                   /* 㭪  ᨢ 㪢            */
        int counter = 0;                /* 稪  ६       */

        while(s[counter] != '\0')       /*   ⨫ ਧ  ⥪ */
                counter++;              /*  ᨬ                   */
        return counter;                 /* ᪮쪮 ᨬ, ⫨  '\0' */
}

          ࠭祭 .   室   ࠭
         몥 ,   ਭ樯  ᠬ 짮  㣨.
         ᠬ   몥  ⠪  㭪 strlen(s)
        (     ᠬ,  㦥 ᠫ  ).
---------------------------------------------------------------------------

  
=================================
ᨢ,   - 㭪権,  ந樠஢
⠭묨 砫묨 祭ﬨ:

int array[5]   = { 12, 23, 34, 45, 56 };

char string[7] = { '', '', '', '', '', '', '\0' };

᫨ ࠧ ᨢ 㪠 , 祬  ᫨ ⮢,
 ⠫   ﬨ ( int)  '\0'  char.

int array[5] = { 12, 23, 34 };

᫨  ᫨  ⮢, 祬  ࠧ ᨢ -
 㤥 訡.

int a[5] = { 177, 255, 133 };

 樨 ᨢ a[] :

 n           祭 ࠦ a[n] 
---------------------------------------------------------------------------

-1               । (訡: "  ࠭楩 ᨢ")
0               177
1               255
2               133
3               0
4               0
5                । (訡)
      * 13_FUNCS.txt *

   
============================

   ᠭ 㭪,  楫 祭.

        /*   func(). */
        /*  func -  .       㣮. */

        int func(int a, int b, int c){
                int x, y;

                ...
                x = a + 7;
                ...
                b = b + 4;
                ...

                return(_祭);
        }


        a, b, c    - 㬥 㭪樨 (ࠬ)
        x, y       -  ६

窠 맮 - 室  - 㣮
㭪樨, ਬ 㭪樨 main()

main(){

        int zz, var;
        ...
        var = 17;
        zz = func(33, 77, var + 3) + 44;
        ...
}

 믮 ணࠬ 室  ப

        zz = func(33, 77, var + 3) + 44;

1) ந室   func()

        (a)      㭪  㢨 .

        (b)      ६   a, b, c, x, y;

        (c)     ६-㬥⠬ ᢠ 砫 祭,
                   窨 맮.
                 窥 맮 ᫥ ᯨ᮪ (१ ) ࠦ ():

                        func(ࠦ1, ࠦ2, ࠦ3)

                ᫥ 祭  ࠦ ᮮ⢥⢥  ᢮
                1-, 2-  3- 㬥⠬ (ࠬࠬ)  । 㭪樨:

                        int func(a, b, c){      /* a =  1, b = 2, c = 3 */

                 ࠬ:

                        a = 33;

                ன ࠬ:

                        b = 77;

                ⨩ ࠬ:

                        c = var + 3;

                 , ,

                        c = 20;

                 ६ x  y ᮤঠ । 祭,
                   (   ।᪠  祭,
                  ᢮   ࠧ - 祭 ᠬ).

2) 믮  㭪樨,   ᫥, ᠭ  { ... }
    । 㭪樨. ਬ:

                        x = a + 7;

         ࠬ,   ६ -  ,
            .

                        b = b + 4;

         ⮬  ६  ⮩ 㭪樨  .
        ( ⮬  ࠧ ).

3) ந   㭪樨.

                ...
                return(_祭);
        }

        ਬ,   

                ...
                return(a + 2 * x);
        }

        ᬮਬ,   ⮬ ந室  窥 맮:

                zz = func(33, 77, var + 3) + 44;

        (1) ન func(.....)

                zz = XXXXXXX + 44;

        (2) 塞 祭 "_祭"   return,
             ६  ⮣ 祭.
              ᫥ ⠬ 稫 128.

        (3) ⠢塞  祭   ભ⮣ func(.....)
              砥

                zz = 128 + 44;

        (4)    ६  㬥 㭪樨:

                a       - 㡨
                b       - 㡨
                c       - 㡨
                x       - 㡨
                y       - 㡨

         ६ (  祭)    த.

        (5) 㭪,   㤨 .

        (6) த ᫥:

                zz = 128 + 44;

         

                zz = 172;       /*  ᢠ */

---------------------------------------------------------------------------

int func1(int x){
        printf("func1: x=%d\n", x);     /* 1 */
        x = 77;
        printf("func1: x=%d\n", x);     /* 2 */
        return x;
}

void main(){
        int var, y;

        var = 111;
        y = func1(var);                 /* @ */

        printf("main: var=%d\n", var);  /* 3 */
}

  砥  窥 @  ।  㭪 func1()
 ६ var, ࠢ 111.
 ,   맮 㭪樨 㤥 ᮧ ६ x
  㤥 ᢮ 砫쭮 祭 111

        x = 111;

⮬   printf() ⠥ 111.

⥬  塞 祭 ६ x  77.
 塞 ६ x,   ६ var !!!
ᯮ짮  ( )  ६ var  x,
  ६ var 뫨 -    ᠥ (  - ).

⮬ ன  printf() ⠥ 77.
 ६  var ⠫ 祭 111,
  ⢥न  ⨩  printf,
 ⠥ 111.

---------------------------------------------------------------------------

  
=============================

int func1(int x){                       /* f.1 */
        printf("func1: x=%d\n", x);     /* f.2 */
        x = 77;                         /* f.3 */
        printf("func1: x=%d\n", x);     /* f.4 */
        return x;                       /* f.5 */
}

void main(){
        int x, y;                       /* 1 */

        x = 111;                        /* 2 */
        y = func1(x);                   /* 3 */

        printf("main: x=%d y=%d\n", x, y);  /* 4 */
}

 ⥯   ६  main(),  㬥 㭪樨
func1()    ⥬  .  㤥?

㤥   ᠬ,   ।饬 ਬ.

  맮 㭪樨 func1() 㤥 ᮧ  ६
  x,   (०) ६   祭 
  ().

 뫮  筨  ६  㭪権,
   ।:

        main::x

           

        func1::x

(  㦥 樨  몠 ++,   ).

믮 ணࠬ  ࠬ:

|/* 1    */      ⢮ ६ main::x  main::y  楫 ᥫ;
|/* 2    */      main::x = 111;
|/* 3    */      뢠 func1(111);
|
+-------+
.       |/* f.1  */      ⢮ ६ func1::x  祭 111;
.       |/* f.2  */      ⠥ 111  ६ func1::x;
.       |
.       |/* f.3  */      func1::x = 77; (  main::x,  㣠 ६,
.       |                                  㭪樨 func1.
.       |                                ६ main::x  ᥩ   -
.       |                                 "᫮"  襩 쭮
.       |                                ६.
.       |                                ⮬     ).
.       |
.       |/* f.4  */      ⠥ 77  func1::x;
.       |/* f.5  */      頥 祭 func1::x ,   77.
.       |                ६ func1::x 㭨⮦.
.       |
.       |                  ᭮ 頥  㭪 main(),
.       |                  x 砥 ६ main::x

+-------+
|
|/* 3    */      y = 77;
|/* 4    */      ⠥ 祭 main::x  main::y,  
|                111  77.

 堭 ᮪    㭪樨 main()  func1()
ࠧ ணࠬ⠬,      ⮬, ⮡ 
 ६  㭪  .  ᮢ - 㦥 
㤥, 堭 뢠  ࠧ 䫨.
 ணࠬ  ᯮ짮  ࠢ襥  
  㭪樨 -    x,  i.

---------------------------------------------------------------------------

  ᠬ ந室  묨 ६묨,
   㬥⠬ 㭪樨.

int func1(int arg){     /* 쭠 ६-ࠬ func1::arg */
        int x;          /* 쭠 ६          func1::x   */

        x = arg;
        printf("func1: x=%d\n", x);
        x = 77;
        printf("func1: x=%d\n", x);
        return x;
}

void main(){
        int x, y;       /* ६ main::x  main::y */

        x = 111;
        y = func1(x);

        printf("main: x=%d y=%d\n", x, y);
}

   ᠬ 堭 ६ ᮪  x.
 , 㬥 㭪樨    ६
⫨ ⮫쪮 :
        㬥⠬ ⮬᪨ ᢠ
        砫 祭, ࠢ 祭 ᮮ⢥ ࠦ
         ᯨ᪥

                _㭪樨(..., ..., ....)
                            1 2 3

          맮 㭪樨.

 

 :

int f(int 1, int 2, int 3){
        int ६1, ६2;
        ...
        /* த */
}

:

        .... f(ࠦ1, ࠦ2, ࠦ3) ...

     (   맮):

        1 = ࠦ1;
        2 = ࠦ2;
        3 = ࠦ3;

        ६1 = ;
        ६2 = ;

        ...
        /* த */

---------------------------------------------------------------------------

 
=====================

,  ६,     ,
 騥  ६ 믮 ணࠬ
(  ⮫쪮  ६,  ⨢ 㭪,  ன  ᮧ).

 ६  㬥   室
 㭪樨.  ६ - .

int x = 12;             /* ::x -   ࠭ ᢮ ⠭ */
int globvar;            /* ::globvar                                  */

int f1(){
        int x;          /* f1::x */

        x = 77;
        printf("x=%d\n", x);            /* 4 */
        return x;
}

int f2(){
        printf("x=%d\n", x);            /* 5 */
        return 0;
}

void main(){
        int x, y;       /* main::x */

        x = 111;                         /* 1 */
        printf("x=%d\n", x);             /* 2 */
        printf("glob=%d\n", globvar);    /* 3 */

        y = f1();
        y = f2();
}

  ਬ  :
- -     .  ଠ쭠 .
- -  ᯮ  ६   "x".

 믮 ணࠬ?

/* 1 */   main::x = 111;
            x,   .
           x ० ᮤন 12.

/* 2 */   ⠥ 祭 ६ main::x,   111.
           㭪樨 main 쭠 ६ ::x
          ᫮ ᢮ ᮡ⢥ ६ x.
            砥     main  쭮
          ६ x,   ⮫쪮  몥 ++   ::x

           ६  globvar    .

/* 3 */   ⠥ ::globvar.  㦨,   祭 0.
           ⫨稥   ६,
           砫쭮 ᮤঠ ,
           ६ 砫쭮 ᮤঠ 祭 0.

           ࠬ, ભ.

/* 4 */    맮 f1()
          ६ f1::x
                ᫮ ᮡ 
                     main::x
                ⠪ 
                     ::x

            砥 ⠥ 77,
            ::x  main::x    ஬ x = 77.
           﫠 f1::x

/* 5 */    맮 f2()  ᭥.
            ᢮ ᮡ⢥ ६ x.
            ६ ⠥  -
                ::x     
                main::x   ?

          ⢥: ::x
                   12.

          ६  묨   ⮬,
               .

             ६.
          (⮬  訢 "祬?"  ।)

           , ᫨  

                funca(){
                        int vara;
                        ...
                        ...funcb();...  /* 맮 */
                        ...
                }

            㭪樨 funcb()       vara.

                funcb(){
                        int z;

                        z = vara + 1;   /* 訡,
                                           vara ⭠  funcb() */
                }

          ᫨,  ᢮ ।, funcb() 뢠 funcc(),
             funcc() ६ vara .

          ⠭  ᮧ.
           ࠢ 㦨  ⮩  楫 - ࠧ 㭪樨
            ᠭ ࠧ묨 ணࠬ⠬,  
          ᯮ짮        ६,
             祭.
          ⢠ , ᯮ짮  ࠧ 㭪, ᨬ
            㣠.    㭪樨   ⭮
           ६  ⥬     㭪樨.

          ୥  ࠣ    
           ᬮਬ 㭪 (a).     ᠭ 

        (a)  ६  㬥 뢠饩 㭪樨  묨.
                                             ~~~~~~~~~~
              㭪樨:

        (5)  ६  㬥 뢠饩 㭪樨 ᭮  묨.

            ६    㭪樨,
          ᪫ 砩,  쭠 ६ ᫮
           쭮 ६  㭪樨.

---------------------------------------------------------------------------


=========
뢠 㭪樨,     祭.
 㭪樨  void ("誠").
 㭪樨 뢠  .

        void func(){
                printf("ਢ⨪!\n");
                return;  /*   뢠 㭪 */
        }

 㭪樨 뢠 ࠤ " 䥪⮢",
ਬ  窨  ࠭    ( ⮫쪮)
६.

        int glob;

        void func(int a){
                glob += a;
        }

 return  易⥫,  ⮬᪨ 믮
। ᫥ ᪮ }

맮 ⠪ 㭪権    ᯮ짮
  ᢠ:

main(){
        int z;

        z = func(7);     /* 訡,    ᢠ ??? */
}

४ 맮 ⠪:

main(){
        func(7);
}

 맮  .

      ?

⮡ 뢠   ࠧ묨 㬥⠬!

        int res1, res2;
                ...

        res1 = func(12 * x * x + 177, 865,     'x');
        res2 = func(432 * y + x, 123 * y - 12, 'z');

,  ⨫,  ᯨ᮪ 䠪᪨ ࠬ஢
᫥ १ ;
 ࠦ ஢ ⮫쪮, ᪮쪮 ࠬ஢  㭪樨?

㭪 뢠  ,
  믮  ࠧ,
  ࠧ묨 室묨 묨 (㬥⠬).
 ᨬ    㤥 뤠 ࠧ १,
 믮     ⢨.

 ⮬   ⮨  ५:
  㡫㥬  ᮪ ணࠬ  ࠧ,
  "뢠" .

㭪 - ࠪ ,   ᫥⥫쭮 ⢨.
 ⨧ - 맮 㭪樨  㦥 ।묨 ࠬࠬ.
---------------------------------------------------------------------------

 return  室  ⮫쪮   㭪樨,
    ।.
 뢠  ४饭 ⥫ 㭪樨   祭
  맮.

        int f(int x){
                int y;

                y = x + 4;
                if(y > 10) return (x - 1);
                y *= 2;
                return (x + y);
        }

      . 

ᨢ 뢠 㭪, 뢠 ᠬ ᥡ.

        int factorial(int arg){
                if(arg == 1)
                        return 1;                               /* a */
                else
                        return arg * factorial(arg - 1);        /* b */
        }

 㭪  맮 factorial(n) ᫨ ந

        n * (n-1) * ... * 3 * 2 * 1

뢠 "䠪ਠ ᫠ n".
  㭪樨 ६ arg 㤥 ⢥ ( ᫥  㭨⮦)  .

  ६ factorial::arg      맮 㭪樨:

        factorial::arg[஢_맮]

    ஢  ६ 뢠  ।騥.
  factorial(4) 㤥

                +----------------------------------------+
     |          | factorial::arg[ 0__ࠧ ]   4     |
     |          | factorial::arg[ 1__ࠧ ]   3     |
     |          | factorial::arg[ 2__ࠧ ]   2     |
     |          | factorial::arg[ 3__ࠧ ]   1     |
     V  --------+                                        +---------

⥬    㭪権:

                +----------------------------------------+
     A          | /* b */ return 4 * 6 = 24              |
     |          | /* b */ return 3 * 2 = 6               |
     |          | /* b */ return 2 * 1 = 2               |
     |          | /* a */ return 1;                      |
     |  --------+                                        +---------

  뢠  (stack).

        --------+               +------------
                |               |                       ⮩ ⥪
                +---------------+

          ⥪ 祭 a
                        |
        --------+       |       +------------
                |       V       |
                +---------------+
                |       a       | <--- 設 ⥪
                +---------------+

          ⥪ 祭 b

        --------+               +------------
                |               |
                +---------------+
                |       b       | <--- 設 ⥪
                +---------------+
                |       a       |
                +---------------+

          ⥪ 祭 c

        --------+               +------------
                |               |
                +---------------+
                |       c       | <--- 設 ⥪
                +---------------+
                |       b       |
                +---------------+
                |       a       |
                +---------------+

        筮, 祭 "᭨  ⥪"  ⭮ 浪: c, b, a.

           ६  ⥪ 㯭  ⥭ (஢) 
        뢠 ⮫쪮 , 室饥   ⥪.

           襩 ४ᨢ 㭪樨 ६ factorial::arg
         ᥡ   ⥪ ( 騪-⥪   arg) -
           ,  ࠧ 祭  ࠧ .
        ६,    ᥡ  ⥪,
         ⮫쪮  (४ᨢ) 㭪.

        ⥪ -     ணࠬ஢ .
        ᫨   㦭 ணࠬ,   ஬஢
        ⥪   ᨢ:

        int stack[10];
        int in_stack = 0;       /* ᪮쪮 ⮢  ⥪ */

        /* ᥭ 祭  ⥪ */
        void push(int x){
                stack[in_stack] = x;
                in_stack++;
        }

        /*  祭  ⥪ */
        int pop(){
                if(in_stack == 0){
                        printf("⥪ , 訡.\n");
                        return (-1);
                }
                in_stack--;
                return stack[in_stack];
        }

          ,   㦤  (ਬ )
        祭 ⮢ ᨢ, 모  設 ⥪.
            ᯮ,    祭 
        饭  ⥪  祭.

        void main(){
                push(1);
                push(2);
                push(3);

                while(in_stack > 0){
                        printf("top=%d\n", pop());
                }
        }

       

㤥 ᬠਢ   㭪樨  饭  ᯥ樠 ⥪
讣 " ଠ樨", 饣  ⭮
    뢠 㭪樨.

 return  맢 㭪樨 ⠫  ⥪  ⠪ .

 ⢥ ਬ ᬮਬ ⠪ ணࠬ:

int x = 7;      /* 쭠 */
int v = 333;    /* 쭠 */

int factorial(int n){
        int w;  /*  ६, ⮫쪮  樮 楫 */

        w = n;

        if(n == 1)      return 1;                       /* #a */
        else            return n * factorial(n-1);      /* #b */
}
void func(){
        int x;          /* func::x */

        x = 777;        /* #c */
        printf("맢 㭪 func()\n");
}
void main(){
        int y = 12;     /* main::y */
        int z;

                                /* A */
        z = factorial(3);       /* B */
        printf("z=%d\n", z);

        func();                 /* C */
}
---------------------------------------------------------------------------

믮 ணࠬ 筥  맮 㭪樨 main().
 窥 /* A */

                                |                 |
                                V                       V

        --------+                       +--------
                |=======================|
                |       z =        |
                |       y = 12          |           +------+---------+
                |main()                 |           |x = 7 | v = 333 |
                +-----------------------+-----------+------+---------+-----
                                    

     ६,  室
a)  設 ( ⮫쪮) ⥪ 맮 㭪権.
b)  ᫮   ६.
  砥  ᬮਬ "ᢥ"  :

        main::z,  main::y,  ::x,  ::v

---------------------------------------------------------------------------

 窥 /* B */  뢠 factorial(3).

        --------+                       +--------
                |=======================|
                |       w =        |
                |       n = 3           |
                |factorial(3)           |
                |=======================|
                |                     +-|---> ⥪騩  z = factorial(3);
                |       z =        |
                |       y = 12          |           +------+---------+
                |main()                 |           |x = 7 | v = 333 |
                +-----------------------+-----------+------+---------+-----
                                    

  拉 :
        factorial(3)::w,  factorial(3)::n,  ::x,  ::v

⠫ :
        main::z,  main::y

ப "⥪騩  ..." 㪠뢠 ,  ண  
믮 㭪樨,   ୥  .
---------------------------------------------------------------------------

 믮 ணࠬ  㭪樨 factorial(3)   窨
/* #b */ 㤥 믮 return 3 * factorial(2).
 ⮣ 㤥 맢 㭪 factorial(2).

        --------+                       +--------
                |=======================|
                |       w =        |
                |       n = 2           |
                |factorial(2)           |
                |=======================|
                |                     +-|---> ⥪騩  return 3 * factorial(2);
                |       w = 3           |
                |       n = 3           |
                |factorial(3)           |
                |=======================|
                |                     +-|---> ⥪騩  z = factorial(3);
                |       z =        |
                |       y = 12          |           +------+---------+
                |main()                 |           |x = 7 | v = 333 |
                +-----------------------+-----------+------+---------+-----
                                    

---------------------------------------------------------------------------

 믮 ணࠬ  㭪樨 factorial(2)   窨
/* #b */ 㤥 믮 return 2 * factorial(1).
 ⮣ 㤥 맢 㭪 factorial(1).

        --------+                       +--------
                |=======================|
                |       w =        |
                |       n = 1           |
                |factorial(1)           |
                |=======================|
                |                     +-|---> ⥪騩  return 2 * factorial(1);
                |       w = 2           |
                |       n = 2           |
                |factorial(2)           |
                |=======================|
                |                     +-|---> ⥪騩  return 3 * factorial(2);
                |       w = 3           |
                |       n = 3           |
                |factorial(3)           |
                |=======================|
                |                     +-|---> ⥪騩  z = factorial(3);
                |       z =        |
                |       y = 12          |           +------+---------+
                |main()                 |           |x = 7 | v = 333 |
                +-----------------------+-----------+------+---------+-----
                                    

---------------------------------------------------------------------------

⥬  factorial(1) 믮 ணࠬ   窨 /* #a */
 㤥 ந return 1.

 return ન   ଠ樨  ⥪ 맮 㭪権,
  믮 "⥪饣 "  㭪樨,
⠢襩  設 ⥪ 맮.
,    樨 맢 㭪樨 factorial(m)   訫.
     ᤥ: ᫨ ࠦ  return,
 ᮡ⢥ 믮 ᠬ return. ᫥  த.

        --------+                       +--------
                |=======================|
                |                     +-|---> ⥪騩  return 1;
                |       w = 1           |
                |       n = 1           |
                |factorial(1)           |
                |=======================|
                |                     +-|---> ⥪騩  return 2 * factorial(1);
                |       w = 2           |
                |       n = 2           |
                |factorial(2)           |
                |=======================|
                |                     +-|---> ⥪騩  return 3 * factorial(2);
                |       w = 3           |
                |       n = 3           |
                |factorial(3)           |
                |=======================|
                |                     +-|---> ⥪騩  z = factorial(3);
                |       z =        |
                |       y = 12          |           +------+---------+
                |main()                 |           |x = 7 | v = 333 |
                +-----------------------+-----------+------+---------+-----
                                    

---------------------------------------------------------------------------

稭 ⠫ 㭪権  ⥪  믮 ஢ return;

        --------+                       +--------
                |=======================|
                |                     +-|---> ⥪騩  return 2 * 1;
                |       w = 2           |
                |       n = 2           |
                |factorial(2)           |
                |=======================|
                |                     +-|---> ⥪騩  return 3 * factorial(2);
                |       w = 3           |
                |       n = 3           |
                |factorial(3)           |
                |=======================|
                |                     +-|---> ⥪騩  z = factorial(3);
                |       z =        |
                |       y = 12          |           +------+---------+
                |main()                 |           |x = 7 | v = 333 |
                +-----------------------+-----------+------+---------+-----
                                    

        --------+                       +--------
                |=======================|
                |                     +-|---> ⥪騩  return 3 * 2;
                |       w = 3           |
                |       n = 3           |
                |factorial(3)           |
                |=======================|
                |                     +-|---> ⥪騩  z = factorial(3);
                |       z =        |
                |       y = 12          |           +------+---------+
                |main()                 |           |x = 7 | v = 333 |
                +-----------------------+-----------+------+---------+-----
                                    

        --------+                       +--------
                |=======================|
                |                     +-|---> ⥪騩  z = 6;
                |       z =        |
                |       y = 12          |           +------+---------+
                |main()                 |           |x = 7 | v = 333 |
                +-----------------------+-----------+------+---------+-----
                                    

        --------+                       +--------
                |=======================|
                |       z = 6           |
                |       y = 12          |           +------+---------+
                |main()                 |           |x = 7 | v = 333 |
                +-----------------------+-----------+------+---------+-----
                                    

---------------------------------------------------------------------------

,  窥 /* C */ 㤥 맢 㭪 func().
ᬮਬ  /* #c */  .

        --------+                       +--------
                |=======================|
                |       x = 777;        |
                |func();                |
                |=======================|
                |                     +-|---> ⥪騩  func();
                |       z = 6           |
                |       y = 12          |           +------+---------+
                |main()                 |           |x = 7 | v = 333 |
                +-----------------------+-----------+------+---------+-----
                                    

     -  ६ ?
:
                func::x = 777
                ::v     = 333

 .
                ::x                ᫮ 쭮 ६.
                main::y,  main::z  , ⠪  室
                                     設 ⥪ 맮 㭪権
---------------------------------------------------------------------------

 㭪樨  ⢥ ࠦ १ ४.
,   ਢ  譨 ᫥  ࠢ  ﬨ
(  横).  ਬ - ᫠ .

int fibonacci(int n){
        if(n==1 || n==2) return 1;

        /* else */

        return fibonacci(n-1) + fibonacci(n-2);
}
void main(){
        printf("20 ᫮  ࠢ %d\n", fibonacci(20));
}

᪮   ᨢ   ஬
१⮢,   ᨢ  ᠬ   
   ६  ⥪ 맮 㭪権.
  ᯮᮡ  -   ᫨誮  
⢨.    -  ⠥, ᪮쪮 ࠧ
뫠 맢 fibonacci(1) ?

int called = 0;

int fibonacci(int n){
        if(n==1){
                called++;
                return 1;

        } else  if(n==2)
                return 1;

        return fibonacci(n-1) + fibonacci(n-2);
}
void main(){
        printf("20 ᫮  ࠢ %d\n", fibonacci(20));
        printf("fibonacci(1) 뫠 맢 %d ࠧ\n", called);
}

 뫠 맢... 2584 ࠧ!
     14.c

/* 㥬   䨣 */
#include

const int LINES = 15;

void draw(int nspaces, int nstars, char symbol){
        int i;

        for(i=0; i < nspaces; i++)
                putchar(' ');
        for(i=0; i < nstars; i++)
                putchar(symbol);
}

void main(){
        int nline, nsym;
        char symbols[3];        /* ᨢ   㪢 */

        symbols[0] = '\\';
        symbols[1] = 'o';
        symbols[2] = '*';

        for(nline=0; nline < LINES; nline++){
                for(nsym = 0; nsym < 3; nsym++)
                        draw(nline, nline, symbols[nsym]);

                /* 室   ப 뭥ᥭ
                    㭪樨   横 */
                putchar('\n');
        }
}
     15.c

/* :
        ᮢ ⠡ 

                       誠   誠   
                  誠   誠        ...

     ᫥⥫쭮
        , , , 誠, 誠...
     ࠧ  ᯮ  6 ३  ப.
*/

#include       /* ᪠ ப */

/*   ६.
     砥 - ⠭.
 */

int TOMCATS     = 3;            /*    */
int CATS        = 2;            /*  誨 */
int ANIMALS_PER_LINE    = 6;    /*  ३   ப */
int LINES       = 25;           /* ᫮ 뢮 ப */

/*      ६ - 饥 ᫮ ३.
     ᫨ १ 㦥 , ⮬    ...
    ᫨ -  ⮫쪮  㭪樨.
    襬 砥 -  㭪樨 main().
*/
int ANIMALS;                    /* 饥 ᫮ ३ */

int nth_in_line = 0;            /*    ⥪饩 ப */
/*  ६    쭮  㭪樨, ⠪ 
 * ⮣  㭨⮦  室  㭪樨.   室,
 * ⮡  祭 ࠭﫮. ⮬ ६ - 쭠.
 */

/* 㭪,  ⠥ ᫮ ३   ப
     ॢ ப,  ॢ  
   ᫥  (⠡樥).
*/
void checkIfWeHaveToBreakLine(){
        nth_in_line++;  /* ⥪騩    ப ( ) */

        if(nth_in_line == ANIMALS_PER_LINE){
        /* ᫨ ப  쬨... */
                putchar('\n');     /*  ப */
                nth_in_line = 0;   /*   ப  ३ */
        } else {
                putchar('\t');     /*  ᫥  */
        }
}

void main(){
        int nanimal;    /*   */
        int i;          /* 稪     */

        ANIMALS = ANIMALS_PER_LINE * LINES;
        nanimal = 0;

        while(nanimal < ANIMALS){

                for(i=0; i < TOMCATS; i++){
                        /*  printf() 뢮  .
                            砥   窨
                           (   묨  putchar().
                         */
                        printf("");
                        nanimal++;      /*     */

                        /*  ஢ -    ३   ப ? */
                        checkIfWeHaveToBreakLine();
                }
                for(i=0; i < CATS; i++){
                        printf("誠");
                        nanimal++;      /*     */

                        /*  ஢ -    ३   ப ? */
                        checkIfWeHaveToBreakLine();
                }
        }
        /* putchar('\n'); */
}
     16.c

/*
          ,       .
        ࠭稬  ப.
*/

#include       /* ᪠ ப */

int TOMCATS     = 3;            /*    */
int CATS        = 2;            /*  誨 */
int ANIMALS_PER_LINE    = 6;    /*  ३   ப */
int LINES       = 5;            /* ᫮ 뢮 ப */
int ANIMALS;                    /* 饥 ᫮ ३ */

int nth_in_line = 0;            /*    ⥪饩 ப */

void checkIfWeHaveToBreakLine(){
        nth_in_line++;

        if(nth_in_line == ANIMALS_PER_LINE){
                putchar('\n');
                nth_in_line = 0;
        } else
                printf("\t\t");         /* @ */

        /*      {...}   */
}

void main(){
        int nanimal;
        int i;

        ANIMALS = ANIMALS_PER_LINE * LINES;
        nanimal = 0;

        while(nanimal < ANIMALS){

                for(i=0; i < TOMCATS; i++){
                /* ଠ %d 뢮 祭 ६ ⨯ int
                     ⥪⮢ ப.
                    ६    ᯨ᪥ ᫥ ଠ
                   (ᯨ᮪ -  ᫥ ६ १ ).
                   ६  ࠦ ().

                    뢮   ⠡樨 --
                     ⬥祭  㭪樨 checkIfWeHaveToBreakLine()
                    @.

                    ࠧ  -  ᨬ  뢮 
                        putchar('a');
                   ᪮쪮 ᨬ - 
                        printf("abcdef");

                    窨 -   㪢.
                    窨   -  ᪮쪨.
                */

                        printf("%d", nanimal);
                        nanimal++;

                        checkIfWeHaveToBreakLine();
                }
                for(i=0; i < CATS; i++){
                        printf("誠%d", nanimal);
                        nanimal++;

                        checkIfWeHaveToBreakLine();
                }
        }
}
     17.c

/* :  ୨  ᥫ  1  100.

    ଠ:
           ⨯  -  .
         ᫠, 騥 ஡  (᫥ 窨).
          㦥 , 楫 -    int.
                          㪢 -    char.
                          ⢨⥫쭮 ᫮ -  double.
        (  ᫮ float,   짮  ४).

    ᫥  ᯮ 樮  ஭.

                q = ७  x;

                q[0]   := x;
                q[n+1] := 1/2 * ( q[n] + x/q[n] );

        訡,    q[n]  
    ᨢ.   㦭 १  樨,
    㦥 ⮫쪮  ⢥. ⮬  㤥 
   筮 ,  饩  横, 祩 q.
*/

#include

/*    祢 ᫮ - const. 砥 ⠭.
    ⫨稥  ६, ⠪   .
    , ᫨ - ⮬ ஡  epsilon = ... ;
     㤥 訡.
 */
const double epsilon = 0.0000001;       /* 筮 ᫥ */

/* 㭪 ᫥  ᫠ */
double doubleabs(double x){
        if(x < 0) return -x;
        else      return x;
}

/* 㭪 ᫥ ⭮  */
double sqrt(double x){

        double sq = x;

        /*     ᪫  ப:
                double sq;
                sq = x;
           뢠  " ६  樠樥".
         */

        while(doubleabs(sq*sq - x) >= epsilon){
                sq = 0.5 * (sq + x/sq);
        }
        return sq;
}

void main() {
        int n;

        for(n=1; n <= 100; n++)
                printf("sqrt(%d)=%lf\n",
                             n,  sqrt((double) n)
                      );

}

/*
      printf()  ⠥  ࠦ.
                  
        ------          --------
        %d      --      n
        %lf     --      sqrt((double) n)

         ଠ %d  祭 ⨯ int.
         ଠ %c  祭 ⨯ char.
         ଠ %lf ( %g)  祭 ⨯ double.

     " 祭 ࠦ sqrt(xxx)" ?
    :
        - 맢 㭪 sqrt()  㬥⮬, ࠢ xxx;
        - ᫨ ;
        - 饭  祭   ଠ %lf,
             ⢨⥫쭮 ᫮.

   ,   頥 祭  ᢠ
    ६,   ᮡࠥ  ࠭.

   筮 ⠪ ,    x = 12 + 34;
   12  34  ࠭    ६,
    

        printf("%d\n", 12);

   ⠥  12,   ६.

   筮 ⠪ ,   

        double z;

        z = sqrt(12) + sqrt(23);

    祭, ᫥  㭪樥,  ࠭
    ᢮ ᮡ⢥ ६ (⠪ ६  ᠬ
      ,  ணࠬ  
   㦭  㯭).
   

        z = sqrt( sqrt(81));

        (७    81 -->  3)

   ,  砥  (double) n   ?
   㭪 sqrt() ॡ 㬥 ⨯ double.
     ।  楫 㬥

        int n;

     ⢨⥫ ᫠ ।⠢  
   設 -,
   ⮬ ᫠

        12      12.0  ࠭   -.

   設 㬥 ८ࠧ뢠 楫 ᫠  ⢨⥫
    ,  ⮫쪮 ᪠   ⮬.
    (double) x
   뢠 "ਢ ⨯  double".

   ⨬,   ८ࠧ ⨯
   믮 ⮬᪨.

   , ਬ,  ᫮ int  double
   int ⮬᪨ ਢ  double,  १
    ⨯ double.

        int    var1;
        double var2, var3;

        var1 = 2;
        var2 = 2.0;
        var3 = var1 + var2;

    砥  ᠬ 

        var3 = (double) var1 + var2;

   var3 ⠭ ࠢ 4.0

    ⮣,  ਬ ⨯ char -  ⮦    ࢠ
   0...255.  㪢    0  255.

*/
      * 18_POINTERS.txt *


=========
void f(int x){
        x = 7;
}

main(){
        int y = 17;
        f(y);
        printf("y=%d\n", y);       /* ⠥: y=17 */
}

 㬥 x ।  祭 y,
⮬ x=7;   祭 .
   ᤥ, ⮡ 뢠 㭪
  祭 ६?

ᨬ  ᯮᮡ:

        -  y  쭮
          (  ६ - 宩 ⨫),

        - y=f(y);
          (  ᫨    ६?
          return,  ,     祭).

ᯮ    : .
---------------------------------------------------------------------------

ਬ (@)

void f(int *ptr){       /* #2 */
        *ptr = 7;       /* #3 */
}

main (){
        int y=17;

        f(&y);          /* #1 */
        printf("y=%d\n", y);       /* ⠥: y=7 */
}

 , 諨  ⫨  室 ⥪?
---------------------------------------------------------------------------

    樨:

        &y              "㪠⥫  ६ y" 
                        " ६ y"

        *ptr            砥 "ࠧ묥 㪠⥫ ptr"
                        (஡ - )

        int *ptr;       砥  ६ ptr,
                          ᮤঠ  ᥡ
                        㪠⥫  ६,
                        ࠭ int-᫮.

 砫 ।,  ⠪ 㪠⥫.

        int var1, var2, z;      /* 楫᫥ ६ */
        int *pointer;           /* 㪠⥫  楫᫥ ६ */

        var1    = 12;
        var2    = 43;
        pointer = &var1;

 㤥 ࠦ 㪠⥫   ;
 訩 ਥ   ࠪ᪮ ணࠬ஢.
        ________
       /pointer/
     _/_______/_
     | 祭|        ६, ࠭ 㪠⥫
     |     |        ( 㣮 ६)
     |         |
     |  &var1  |
     |         |
     |_______|_|
             |
             |&var1     - ᠬ 㪠⥫  var1 -
             |            "५, 㪠뢠  ६ var1".
             V             砥 &var1
        ________
       / var1  /
     _/_______/_
     | 祭|
     |     |
     |    12   |
     |_________|

 ࠧ,  -  "५, 㪠뢠   騪-६".
砫 ⮩ ५  ( ᢮ ।) ࠭  - ६.

 ⮬, ᫨ ५ 㪠뢠  ६ ⨯ int,
 ⨯ ६, ࠭饩 砫 ५,  int *

᫨ ⨯ char,  ⨯ - char *

 (㪠⥫ )   ⮫쪮  ६   ᨢ,
   ࠦ.

        int x;
        int arr[5];

             &x          ५  騪 "x"
                    & arr[3]    ५  騪 "arr[3]"

           &(2+2)         "騪",
                                  㪠뢠 ५,
                                   騪 .

      

⥫ ᪮쪮 ࠧ筮  ᥡ   
  ᢠ.
   , ਬ塞 ⮫쪮  㪠⥫:

        *pointer

---------------------------------------------------------------------------

  ᢠ   㫠
===================================
*pointer        砥
                " 祭 ६ (饥  騪),
                  㪠뢠 㪠⥫,
                ࠭騩  ६ pointer".

 襬 ਬ -  ᫮ 12.

  *pointer 砥 "ன  ५   㪠뢠  ".

        printf("%d\n", *pointer);

⠥ 12;

        z = *pointer;        /* ࠢ業 z = 12;        */
        z = *pointer + 66;   /* ࠢ業 z = 12 + 66;   */

⠢ ⥯ 㪠⥫ 㪠뢠   ६
( , "᢮ 㪠⥫  㣮 ६")

        pointer = &var2;

        ________
       /pointer/
     _/_______/_
     |         |
     |  &var2  |
     |         |
     |_______|_|
             |
             |&var2
             |
             V
        ________
       / var2  /
     _/_______/_
     |         |
     |   43    |
     |         |
     |_________|

᫥ ⮣   z = *pointer;
砥      z = 43;

---------------------------------------------------------------------------

 ࠧ, 

        z = *pointer;

            砥

        z = *(&var2);

            砥

        z = var2;

  *  &  .

       ᢠ...

        *pointer = 123;

砥        " 祭 ࠢ  (.. 123)
                  ६ (騪),   㪠뢠 㪠⥫,
                 ࠭騩  ६ pointer".

ன  ५   祭  㪠뢠 ६.

  砥 *pointer 砥
  㪠뢠 ६,
       㪠뢠 ६.

        ________
       /pointer/
     _/_______/_
     |         |
     |  &var2  |
     |         |
     |_______|_|
             |
             | 㤠 123
             |
             V
        ________
       / var2  /
     _/_______/_
     |         |
     |   123   |
     |         |
     |_________|

        pointer  = &var2;
        *pointer = 123;

                砥

        *(&var2) = 123;

                砥

        var2 = 123;

  ᭮ *  &    㣠.

---------------------------------------------------------------------------

 ਬ:

        *pointer = *pointer + 66;

                

        *pointer += 66;

---------------------------------------------------------------------------

୥  ਬ  㭪樥 (@).   ࠡ⠥?

 ப /* #1 */
         뢠 㭪 f(), ।  
          ६ y (" ६ y").

 ப /* #2 */
        ⢮ 쭠 ६   ptr,
          ⢥ 砫쭮 祭
        砥 祭 ࢮ 㬥 㭪樨  窥 맮 -
            y.

 ப /* #3 */
         
                *ptr = 7;

         ᫥ ᬠਢ 

                *(&y) = 7;          筥 *(&main::y)=7;

          

                y = 7;              筥 main::y=7;

          ⥫.

 ⮬ ⬥⨬,  ᠬ  "y" ⮩ ६
 㭪樨 f()   !

---------------------------------------------------------------------------

:  祭  ६.

void main(){
        int x, y;
        int temporary;  /* ᯮ⥫쭠 ६ */

        x=1; y=2;

        temporary=x; x=y; y=temporary;
        printf("x=%d y=%d\n", x, y);    /* ⠥ x=2 y=1 */
}
---------------------------------------------------------------------------

    ᯮ짮 ᮢ  㪠⥫:

void swap(int *a, int *b){
        int tmp;

        tmp = *a; *a = *b; *b = tmp;
}

void main(){
        int x, y;

        x = 1; y = 2;
        swap(&x, &y);
        printf("x=%d y=%d\n", x, y);
}
---------------------------------------------------------------------------

 ਬ:

        int x;
        int *ptr1, *ptr2;

        ptr1 = &x; ptr2 = &x;
        *ptr1 = 77;
        printf("%d\n", *ptr2);          /* ⠥ 77 */

    ६  㪠뢠 ᪮쪮 㪠⥫.
---------------------------------------------------------------------------

 ਬ:
        int x;
        int *ptr1;              /*  樠஢ */

        x = *ptr1;

 ptr1  㪠⥫   , ⠬  .
⥫ 㪠뢠 " 㤠" (楬  ).
॥ ᥣ ந ᡮ  ࠡ ணࠬ.

ࠫ:  樠 ६, 㪠⥫  ⮬ ᫥.

     

  ࠡ⠥   ᨢ ᯥ樠 ࠧ.
 ᨢ "a" 

        int a[5];

  ᠬ  㪠⥫   㫥 .

     ६ (騪)
 

        a[0]    a[1]    ...     a[4].

 ⮬ ᠬ  a   ᯮ짮  ணࠬ 砥 &a[0]

        a
        |
        |
        |
        V
       a[0]    a[1]    a[2]    a[3]    a[4]
     _________________________________________
     |       |       |       |       |       |
     |       |       |       |       |       |
     |       |       |       |       |       |
     -----------------------------------------

⮬

        int a[5];

        /* ।   ᠬ ᨢ,      砫 */

        void f(int *a){         /*  f(int a[]),   ࠢ業  */
                printf("%d\n", a[1]);
                a[2] = 7;
        }

        main (){
                a[1] = 777;
                f(a);           /* 㬥 - ᨢ */
                printf("%d\n", a[2]);
        }

맮 f(a); ᤥ   .
 ⮬ ਬ    ࠢ:

_1:
         ।  㭪  ᨢ
         㬥 㭪樨    ᨢ (୮ 㤥),
         㪠⥫   0- .

_2:
        ⥫  砫 ᨢ
         ஢  ᠬ ᨢ.
          ,  *pointer,
        ਬ  㪠⥫: pointer[n].

஥ ࠢ   ᮡ  ᫥⢨.

        int a[5];       /* ᨢ */
        int *ptr;       /* 㪠⥫쭠 ६ */

        ptr = a;        /* , 砥 ptr = &a[0]; */



        ptr[0] = 3;     /* 砥 a[0] = 3;   */
        ptr[1] = 5;     /* 砥 a[1] = 5;   */

 ⮣. 쬥 ⥯

        ptr = &a[2];

       a[0]    a[1]    a[2]    a[3]    a[4]
     _________________________________________
     |       |       |       |       |       |
 a:  |       |       |       |       |       |
     |       |       |       |       |       |
     ----------------------------------------------
                     |       |       |       | ...
 ptr:                |       |       |       |
                     -----------------------------
        -2      -1     ptr[0]  ptr[1]  ptr[2]

   "ਫ"  ᨢ a[] ᨢ ptr[].

 ஬

        ptr[0]      a[2]
        ptr[1]      a[3]
        ptr[2]      a[4]
        ptr[3]          室  殬 ᨢ a[], 

 ⮣, ⨬ ⥫ !

        ptr[-1]     a[1]
        ptr[-2]     a[0]
        ptr[-3]         室 । 砫 ᨢ a[], 

⠪: ஢   ᨢ  㪠⥫.

,   ᨢ a[]
        *a 砥   ᠬ,   a[0].

 ⭮ ᫥⢨  宦 ᨢ  㪠⥫.
     19.c

/* :  㭪 ஢ 浪 ᨬ
    ᨢ char.
        A B C D ---> D C B A
    襭  ᯮ짮 ४.
 */

/*  ਢ ४ᨢ  ४ᨢ 襭 ( ਠ) */
#include

/* 砫 - ᪮쪮 㦥 㭪権. */

/*    .
    㦥 﫮, ப ⥪ -  ᨢ char,
     ண 饭 ᨬ '\0'.
    ᨬ \0  ⠥.
 */
int strlen(char s[]){                   /* 㭪  ᨢ 㪢            */
        int counter = 0;                /* 稪  ६       */

        while(s[counter] != '\0')       /*   ⨫ ਧ  ⥪ */
                counter++;              /*  ᨬ                   */
        return counter;                 /* ᪮쪮 ᨬ, ⫨  '\0' */
}

/*   .
   ⠥   ᨢ  ᨬ   putchar(c).
    ⮫쪮 砥  ᨢ, ࠢ '\0' - ⠭.
   ,   稨 饣 ᨬ   
   ।  㭪 ࠧ ᨢ,   ᥭ.

      㭪 ॢ ப.
*/
int putstr(char s[]){
        int i = 0;      /*  */

        while(s[i] != '\0'){
                putchar(s[i]);
                i++;
        }
        putchar('\n');
        return i;
}

/*     .
    ⮣  㦭 ᯮ⥫쭠 㭪:
   ᤢ ⮢ ᨢ  1 .

        室 ᨢ: A B C D E F
                         <----------
        :       B C D E F F
                                   -
        ᫥  㤢.

        n - ࠧ ᨢ.
        㭪 ࠡ⠥ ⠪:

        室 ᨢ: A B C D E F  n=6
        ᫥ i=1        B B C D E F
        ᫥ i=2        B C C D E F
        ᫥ i=3        B C D D E F
        ᫥ i=4        B C D E E F
        ᫥ i=5        B C D E F F
        i=6 ==> ⠭.

*/
void shiftLeft(char s[], int n){
        int i;

        for(i=1; i < n; i++)
                s[i-1] = s[i];
}

/* 㭪 ஢.
    ⠪:
        - ᫨  ᨢ   ࠢ 1,  ஢ 祣,
           ᨢ ⮨  1  0 ⮢.
        - ᫨  ᨢ > 1, 
          a)  㫥  ᨢ.
                A B C D E F
                |
                |
                V
               tmp

          b)  ᨢ 
                B C D E F F

          c)  ᫥  ᨢ  ᯠᥭ 㫥 .
                         tmp
                          |
                          V
                B C D E F A

          d) ஢ 砫 ᨢ  n-1.
               {B C D E F}A

             :
                F E D C B A

               ॡ.

        s[] - ᨢ,
        n   -  .
*/
void reverse(char s[], int n){
        char tmp;

        if(n <= 1)              /* 祣 ஢ */
                return;

        tmp = s[0];             /* ᯠ */
        shiftLeft(s, n);        /* ᤢ */
        s[n-1] = tmp;           /* ६ */

        reverse(s, n-1);        /* ஢ 砫 */
}

/*   ४ᨢ.   横.
    砫 ᨢ,   ஢,
   뭥ᥭ  ६ length.
*/
void reverse1(char s[], int n){
        char tmp;
        int length;

        for(length=n; length > 1; --length){
                tmp = s[0];
                shiftLeft(s, length);
                s[length-1] = tmp;
        }
}

char testString[] = "abcdefghijklmnopqrstuvwxyz";

/* ᫨   ࠧ ᨢ,  㤥 ᫥ ஬ ⮬᪨.
    㤥 ࠢ  㪢  "..."   祩  
   ᨬ '\0'  .
     砥  27.
*/

void main(){
        int len;

        len = strlen(testString);
        /* ᫨  ப: 26 ('\0'    ⠥) */

        printf("ப  : \"%s\",   %d\n",
                                    testString,    len);
        /*     :
                - ப (ᨢ char) ᫥   ଠ %s
                - ⮡  "..."  ᨬ "
                   ࠧ   \"

            ⮡  putchar  ᨬ '   putchar('\'');
         */

        /* ࢠ  */
        reverse(testString, len);
        putstr("஢ ப:");
        putstr(testString);

        /*   - 頥  室 ﭨ */
        reverse1(testString, len);
        putstr("஢  室 ﭨ ப:");
        putstr(testString);
}
     19_1.c

/*   ⮩ ਠ 襭:
      ⠬.

        A B C D E F G H I J
        J B C D E F G H I A
        |                 |     
        J B C D E F G H I A
        J I C D E F G H B A
          |             |       ⮬ 
        J I C D E F G H B A
        J I H D E F G C B A
            |         |         ⮬ 
          ---->     <-----

        J I H D E F G C B A
        J I H G E F D C B A
              |     |
        J I H G E F D C B A
                | |
        J I H G F E D C B A

                ⮯.
*/

#include

/*  祭  ६ ⨯ char */
void swap(char *s1, char *s2){
        char c;

        c = *s1; *s1 = *s2; *s2 = c;
}

void reverse(char s[], int n){
        int first, last;

        first = 0;              /*  ࢮ  ᨢ */
        last = n-1;             /*  ᫥  ᨢ */

        while(first < last){    /*  first  last */
                swap(&s[first], &s[last]);
                first++;        /* ᤢ ࠢ */
                last--;         /* ᤢ   */
        }
}

char testString[] = "abcdefghijklmnopqrstuvwxyz.";

void main(){
        int len;

        len = strlen(testString);       /*  ⠪ ⠭⭠ 㭪 */
        reverse(testString, len);
        printf("஢ ப: %s\n", testString);
}
     19_2.c

/*   ਠ 襭:
   ନ஢ ⢥  ⥫쭮 ᨢ,
    ⮬ ᪮஢   ० .
*/

#include

char testString[] = "abcdefghijklmnopqrstuvwxyz.";

/*  sizeof(ᨢ)/sizeof(ᨢ[0])
   뤠 ࠧ ᨢ,  ᫨     .
     ਬ ( ᥣ)   ᨢ
    ࠧ஬, ࠢ ࠧ 㦥  ᨢ.
 */

char tempString[ sizeof(testString) / sizeof(testString[0]) ];

void reverse(char s[], int n){
        int i;

        /* 뢥, १  tempString[] */
        for(i=0; i < n; i++)
                tempString[n-1-i] = s[i];

        tempString[n] = '\0';   /* ਧ  ப */

        /* ᪮஢  ஥  */
        for(i=0; i < n; i++)
                s[i] = tempString[i];

        s[n] = '\0';            /* ਧ  ப */
}

void main(){
        int len;

        len = strlen(testString);       /*  ⠪ ⠭⭠ 㭪 */
        reverse(testString, len);
        printf("஢ ப: %s\n", testString);
}
     19_3.c

/*  ஢ ᨢ 楫 ᥫ */

#include

int arr[]  = {1, 5, 10, 15, 20, 25, 30};
int arrLen = sizeof(arr) / sizeof(arr[0]);   /* ࠧ ᨢ */

/* ᯥ⪠ ᨢ  ப */
void printit(int row[], int n){
        int i;

        for(i=0; i < n; i++){
                printf("%d", row[i]);

                if(i == n-1) putchar('\n');
                else         putchar(' ');
        }
}
/*  㯠. ⫠筠 㭪 */
void printShift(int n){
        n = arrLen - n;
        while(n > 0){
                printf("   ");
                n--;
        }
}
/*  ᨢ */
void shiftleft(int row[], int n){
        int i;

        for(i=1; i < n; i++)
                row[i-1] = row[i];
}
/* ஢ */
void reverse(int  row[], int n){
        int pocket;

        printShift(n);                          /* ஢ */
        printf("CALLED reverse(row, %d)\n", n); /* ஢ */

        if(n <= 1){
                printShift(n);                  /* ஢ */
                printf("return from reverse(row, %d);\n", n); /* ஢ */
                return;
        }

        pocket = row[0];
        shiftleft(row, n);
        row[n-1] = pocket;

        printShift(n);                          /* ஢ */
        printit(arr, arrLen);                   /* ஢ */

        reverse(row, n-1);

        printShift(n);                          /* ஢ */
        printf("all done; return from reverse(row, %d);\n", n); /* ஢ */
}
void main(){
        reverse(arr, arrLen);
        printit(arr, arrLen);
}

     20.c

/* :  㭪  ᯥ⪨ ᨢ 楫 ᥫ
     ⠡  columns ⮫殢.
    ⮬ 冷 ⮢   ⠪:

   0    4    8
   1    5    9
   2    6    10
   3    7
*/

/*   ᨢ n ⮢.
   ᫨ n < columns,   砥 ⠪  (n=2, columns=4)

        0       1              

   ⮬

        if(n < columns) columns = n;

   , אַ㣮쭠 ⠡  columns ⮫栬  lines ப
    ᮤঠ ᨬ columns*lines ⮢. ⮬:

        columns*lines >= n

   ᫨ ᫮ ப.
    㦭 쭮 楫 ᫮ ப, ⠪ 

        lines >= n/columns

    ᫮   㫥

        lines = (n + (columns - 1)) / columns;

     楫᫥.

     ⮫쪮 뢥      ᨢ
    ᨬ   ப (y)  ⮫ (x).

   index(x, y) = (x * lines + y);
                 祬 ᫨ index >= n,  祣  뢮
*/

#include

int array[100];

void printArray(int a[], int n, int columns){
        int lines;      /* ᫮ ப */

        int x, y;       /*  ,  ப -   */
        int index;      /*    ᨢ */

        if(n < columns) columns = n;
        lines = (n + (columns-1)) / columns;

        /* ᯮ㥬  横:  ப,   -  ⮫栬 */
        for(y=0; y < lines; y++){
                for(x=0; x < columns; x++){
                        index = x * lines + y;
                        if(index >= n)  /*   殬 ᨢ */
                                break;  /* ࢠ ப */

                        /* break 뢮 ⮫쪮
                            ७ 横 ( ⮫栬) */

                        /* ᤥ   ᫥  */
                        if(x != 0) putchar('\t');

                        printf("%02d|%d", index, a[index]);
                        /* ଠ %02d ⠢  楫 ᫮
                            ᯮ짮  , 祬 ᫨
                           ᫮ ⮨   ,  ᯥ।
                           ਯ뢠 .
                         */
                }
                putchar('\n');  /* ३  ᫥饩 ப */
        }
}
void main(){
        int i, cols;

        /* 樠 祭 ⮢ ᨢ */
        for(i=0; i < 100; i++)
                array[i] = i + 1;

        for(cols=4; cols <= 13; cols++){
                printf("\t\t* * *   %d  * * *\n", cols);
                printArray(array, 77, cols);
                putchar('\n');
        }
}
     20_1.c

#include

main(){
        int x, y;
        int COLUMNS = 11;
        int LINES = 10;

        int value;

        /* 横  ப */
        for(y=0; y < LINES; y++){

                /* 横  ⮫栬 */
                for(x=0; x < COLUMNS; x++){

                        /*   */
                        value = LINES * x + y;

                        /* ᫨   㫥 ⮫,  ३
                            ᫥ 
                         */

                        if(x > 0) putchar('\t');

                        /* ...     祭 */
                        printf("%d", value);

                }
                putchar('\n');  /*  ப */
        }
}
     20_2.c

/*
        elem(x, y) = LINES * x + y;

                ⮣

        elem(0, y+1) - elem(COLUMNS-1, y) = 1 + LINES - COLUMNS*LINES;
        elem(x+1, y) - elem(x, y)         = LINES;
*/

#include

int A = 150;            /* ⢮ ⮢      */
int COLUMNS = 7;        /* ⢮ ⮫殢       */
int LINES;              /* ⢮ ப          */
int value;              /* 祭  ⥪饩 ⪥ */

int OFFSET_NEXT_COLUMN;
int OFFSET_NEXT_LINE;

/* 㥬 ப ⠡ */
void line(){
        int col;        /*   */

        for(col=0; col < COLUMNS; col++){
                if(value >= A)       /* 騩  */
                        printf("* ");
                else    printf("%03d ", value);

                /* 祭  室  ᥤ  */
                value += OFFSET_NEXT_COLUMN;    /* 1 */
        }
        /* ३  ᫥饩 ப */
        putchar('\n');

        /* 祭  室    ப  砫 ᫥饩.
           ⨬,   value 㦥 ਡ OFFSET_NEXT_COLUMN  窨 1,
           ⮬  室  砫 ᫥饩 ப  㬬 ਡ
           OFFSET_NEXT_COLUMN + OFFSET_NEXT_LINE ࠢ
                1 - LINES*COLUMNS + LINES,
            ᮮ⢥ 㫥.
         */
        value += OFFSET_NEXT_LINE;              /* 2 */
}

int main(){
        int nline;  /*  ப */

        LINES = (A + (COLUMNS - 1)) / COLUMNS;

        OFFSET_NEXT_COLUMN = LINES;
        OFFSET_NEXT_LINE = 1 - LINES*COLUMNS;

        for(nline=0; nline < LINES; nline++)
                line();

        /*  0  main() 砥 "ணࠬ 襭 ᯥ譮" */
        return 0;
}
     21.c

/*   */

/*
        㬥 ᨢ ।⠢ ᮡ 㬥
        אַ㣮 ⠡  㬥஢ ६.

          ⠪:

                int array[LINES][COLUMNS];

          ⠪:

                    array[y][x]

                 0 <= y <= LINES - 1
                    0 <= x <= COLUMNS - 1

        +-------------+-------------+-------------+------>  x
        | array[0][0] | array[0][1] | array[0][2] | ...
        +-------------+-------------+-------------+
        | array[1][0] | array[1][1] | array[1][2] | ...
        +-------------+-------------+-------------+
        | array[2][0] | array[2][1] | array[2][2] | ...
        +-------------+-------------+-------------+
        | ...           ...           ...
        V
        y

,   ⠤  ,
 ४   㬥 ᨢ  
   ।    㭪樨  㬥.
*/

/* ਢ ਬ,   㬥 ᨢ 㪢,
        䨣,
    ⠥  ᨢ.

     ਢ  १奬  ᮢ ,
   ᭥      ⨬. म.
*/

#define LINES   31      /* ᫮ ப    */
#define COLUMNS 79      /* ᫮ ⮫殢 */

char field[LINES][COLUMNS];

/*   ணࠬ ᨢ   ࠬ஬,
    ࠡ⠥     쭮 ६.
   㭪 ᮢ אַ ,  १奬.
 */
void line(int x1, int y1, int x2, int y2, char sym){
        int dx, dy, i1, i2, i, kx, ky;
        int d;      /* "⪫" */
        int x, y;
        int flag;

        dy = y2 - y1;
        dx = x2 - x1;
        if (dx == 0 && dy == 0){
                field[y1][x1] = sym;    /* ⢥ 窠 */
                return;
        }
        kx = 1; /* 蠣  x */
        ky = 1; /* 蠣  y */

        /* 롮 ⠪⮢  */
        if( dx < 0 ){ dx = -dx; kx = -1; } /* Y */
        else if(dx == 0)        kx = 0;    /* X */

        if(dy < 0) { dy = -dy; ky = -1; }

        if(dx < dy){ flag = 0; d = dx; dx = dy; dy = d; }
        else         flag = 1;

        i1 = dy + dy; d = i1 - dx; i2 = d - dx;
        x = x1; y = y1;

        for(i=0; i < dx; i++){
                field[y][x] = sym;      /* ᮢ  */

                if(flag) x += kx; /* 蠣  ⠪.    */
                else     y += ky;

                if( d < 0 ) /* ਧ⠫ 蠣      */
                         d += i1;
                else{       /*  蠣        */
                         d += i2;
                         if(flag) y += ky; /*   */
                         else     x += kx;
                }
        }
        field[y][x] = sym; /* ᫥ 窠  */
}

int main(){
        int x, y;

        /*   ஡ */
        for(y=0; y < LINES; y++)
                for(x=0; x < COLUMNS; x++)
                        field[y][x] = ' ';

        /* ᮢ ⨭ */
        line(0,0,               0,         LINES-1, '*');
        line(0,0,               COLUMNS-1, 0,       '*');
        line(COLUMNS-1, 0,      COLUMNS-1, LINES-1, '*');
        line(0, LINES-1,        COLUMNS-1, LINES-1, '*');

        line(0,0,               COLUMNS-1, LINES-1, '\\');
        line(COLUMNS-1,0,       0,LINES-1,          '/');

        /* ᯥ ᨢ */
        for(y=0; y < LINES; y++){
                for(x=0; x < COLUMNS; x++)
                        putchar(field[y][x]);
                putchar('\n');
        }
        return 0;
}
