	   ᮡ ணࠬ஢  
	  

	⭮ ,   ࠫ     ⮣  .  
諮    ।⠢    ணࠬ஢	  ,
 筮  ஡㦤 襩 ⥫쭮.  -
  ⮢ 㣫㡨   ⮭	  ⠩  ண-
ࠬ஢  ,  祬   ࠥ  . 

			   ⥫
			    

	  設⢮ ६, ᬮ७ ,   ᭮-
 ᮤঠ , .. ⥪ ଠ  ࠡ  襩
ணࠬ.        ᯮ	,
祬 ᮡ⢥  祭.     ⮣	  ᯮ
㪠⥫. 
	   ᫨      ᫠  ।⠢    
""  "",    室    
⪨ ᠭ, ஥  ਢ . ⠪, 	-
 ᮤন  ᢮   (  뢠  Ram  -  random
access memory -  ந쭮 㯠)  ணࠬ  
ᮢ㯭 .  ᠬ  ஢  襣  -
 ⮨  , 砩 ஭ 奬  -
 "" (  祭)    祭,
筮 㥬  "0"  "1". ᥬ   㯯
  . 訬 㯯    	ࠢ,  ᢠ
: 筮   ⠢ ᫮,   ⠢
 ᫮; ⭠  ⠢ ࠣ.
	     	襣	    ᮡ-
⢥ 㭨 , ⠪ ,      㫨-
.   ⫨稥  設⢠ ,	᫥⥫  
 ᫥⥫ : ᫨      N,
 ।騩    N-1,  ᫥騩 - N+1.
	  ⥫ -  ६, ᮤঠ 	-
 ,    祭. 祬   㦭?  -,  
 ᯮ짮 㪠⥫  ᯮ ࠧ  -
  ࠧ  .  ,  ᮤঠ-
  㪠⥫,   㫨஢  (ᮧ,  -
, ) ଠ  ࠧ	祩.    
, ਬ, 易 ᪮쪮 ᨬ      
  㪠⥫.
	  -, ᯮ짮 㪠⥫   ᮧ-
  ६     믮  ணࠬ.  
 襩 ணࠬ 訢 ஥ ⢮  -
 ( ),  ,       
㪠⥫.  ਥ ⥭  ᪮  ।;
ᯮ ,  ணࠬ  ᯮᠡ   
쥬 ,  ᨬ  ⮣   (  )  -
 㯭 襬 .
	  -,   ᯮ짮 㪠⥫   -
㯠  ࠧ ⠬  , ⠪   ᨢ,
ப  . ⥫,  魮, 㪠뢠   
 襣  ( ᯮ ᬥ饭 ⭮⥫쭮 -
砫쭮   㪠 楫 ᥣ ), 	஬
ࠧ饭    .  㪠⥫, 	-
   ன ᫥⥫쭮 ⮢,   
।⠢, ਬ, ᨢ  .
	   , ᮬ, 㡥  㤮⢥ 㪠⥫.
    ᯮ짮  ?  砫       -
. ᬮਬ ᫥ ணࠬ:  

	void Main()
	{
		int IVar,*IPtr;
		IPtr = &IVar;
		IVar = 421;
		PrintF("饭 IVar: %p\n",&IVar);
		PrintF("ন IVar: %d\n", IVar);
		PrintF("ন IPtr: %p\n", IPtr);
		PrintF("㥬 祭: %d\n",*IPtr);
	}  

	      ६: IVar  IPtr.	ࢠ,
IVar -  楫 ६, .. ᮤঠ 祭 ⨯ int.
, IPtr -  㪠⥫  楫 ६, ᫥⥫쭮
 ᮤন  祭 ⨯ int.  ⠪ ᪠,  
६ IPtr -  㪠⥫, ⠪    ।    ᠭ
⮨ 窠 ("*").  몥   窠 뢠 -
 ஬.
	   ᭮,  ணࠬ  ᫥饥: 

	       ६ IVar ᢠᢠ IPtr 

	      楫 祭 421 ᢠ  IVar  
 ("&"),   뫮  ,   
,  ஬ ࠧ饭 祭 ६ IVar.

	    믮  ணࠬ.
	    ப 㪠뢠   ᮤন  IVar.
 ।⠢ , ᮤঠ騩  IPtr.  , 
 ६ IVar, ..   ,    ணࠬ
訫 ᮧ ६  䨪஬ IVar.    ᫥
ப ⠥ ,  ࠭  ⮬  -    -
 ,  㦥 ᢮ ६ IVar.
	  ⨬,   쥬  饭  	㭪樨  PrintF
ᯮ ࠦ IPtr,  ᮤন  ண    
IVar.  ᫥ 饭  	PrintF	ᯮ  ࠦ
*IPtr, ஥   , ࠭騥    ⮬
.
	  ᬮਬ ⥯  ਠ ।饩 ண-
ࠬ: 

	  void Main()
	  {
		    int IVar,*IPtr;
		    IPtr = &IVar;
		    *IPtr = 421;
		    PrintF("饭 IVar: %p\n",&IVar);
		    PrintF("ন IVar: %d\n", IVar);
		    PrintF("ন IPtr: %p\n", IPtr);
		    PrintF("㥬 祭: %d\n",*IPtr);
	  }  

	   ⮩ ணࠬ ⠪  ६ IVar	ᢠ-
 IPtr,   ᢠ ᫠ 421 ६ IVar,
 祭 ᢠ  㪠⥫ *IPtr.  १?
筮 ⠪ ,    ।饩 ணࠬ.  祬?	⮬,
 ࠦ *IPtr  IVar       祩    -
⮬  ⮬ 砥    祭 421  
   祩 .	

		  ᪮ ।
		  

	    ࠧ  ணࠬ:  

	  void Main()
	  {
		    int *IPtr;
		    IPtr = Alloc(2);
		    *IPtr = 421;
		    PrintF("ন IPtr: %p\n", IPtr);
		    PrintF("㥬 祭: %d\n",*IPtr);
	  }  

	        ᠭ -
६ IVar, ஥	६  䨣஢    ।
ਬ.   ⮩ ६ IPtr ᢠ -
祭 (⮦  ன 祩 ), 頥  -
ன 㭪樥,  뢠 Alloc. ⥬  ⮬ 
ᢠ 祭 421  ६ *IPtr ,      
।饬 ਬ, ਭ 祭 421.
	   ,  ᫨  ⥯ 믮 ண-
ࠬ,    祭 IPtr, 祬 ࠭,   祭
*IPtr ⠭ ࠢ 421.
	  ६ ⥯,     

	  IPtr = Alloc(2); 

	  㭪 Alloc(Num) १ࢨ  Num  ᫥⥫
⮢ 㯭 (᢮)   ,  ⥬  -
頥 砫  ࠧ饭      ⮩  ᫥-
⥫쭮 ⮢. 祬  2   㬥⮬	㭪樨
Alloc? ⮬,   ࠭ ६ ⨯ int  BDS C -
室  2  (16 ).
	  , 祭   㭪樨 Alloc,  -
  IPtr.  ࠧ,  祭 ᪨ ᮧ
楫 ६  ன  		    
䨪 *IPtr.
	       ᫥騬 ࠧ:  "-
     ⮪  ६ -
 int, ⥬ ᢮ 砫  ⮣ ⪠  ६-
 IPtr, 饩 㪠⥫  ६ ⨯ int".
	  室   ? . 祬?  ⮬,    
⮣    ࠭⨨,  IPtr 㪠뢠  ᢮ -
⮪ . IPtr 㤥 ᮤঠ ஥ 祭, ஥ 
㤥 ᯮ짮  ⢥ ,     㤥  -
⭮,  ᯮ  㦥  ࠧ    㣨  -
. ࠢ ᯮ짮 㪠⥫ ⮥: 㪠⥫ ᥣ
    ᢮ ᯮ짮  ணࠬ.
	  묨 ᫮,  ᢠ 楫	祭  *IPtr
 ।⥫쭮 ᢮   IPtr.	

		     ⥫  㭪樨
		     

	   諮  ᭨,   ࠬ  -
権.  ⥯   ⭠  稭  ᯮ짮
㪠⥫  ⢥ ଠ ࠬ஢  㭪樨,  祭
   .
	  ᬮਬ, ਬ, ᫥ 㭪:  

	  void Swap(A,B)
	  int *A,*B;
	  {
		    int Temp;
		    Temp = *A; *A = *B; *B =Temp;
	  }  

	   㭪 Swap ()   ଠ -
ࠬ A  B,  㪠⥫   		⨯  int.  
砥,  㭪 Swap ࠡ⠥  ᠬ 楫 ६
(    祭ﬨ). ⮬  ࠡ⠭ , 
 । 㭪樨  ६ 饭  .
	   ।⠢ ணࠬ, 뢠 Swap:  

	  void Main()
	  {
		   int I,J;
		   I = 421;
		   J = 53;
		   PrintF(" 饭: I=%d,J=%d\n",I,J);
		   Swap(&I,&J);
		   PrintF("᫥ 饭: I=%d,J=%d\n",I,J);
	  }  

	   ,   ணࠬ	⢨⥫쭮  
祭 I  祭 J (⠢  ⠬).  
ணࠬ   ,    楤  Swap	  ⥫
ணࠬ:  

	  void Main()
	  {
		   int I,J;
		   int *A,*B,Temp;
		   I = 421;
		   J = 53;
		   PrintF(" ࠡ⪨: I=%d,J=%d\n",I,J);
		   A = &I;
		   B = &J;
		   Temp = *A; *A = *B; *B =Temp;
		   PrintF("᫥ ࠡ⪨: I=%d,J=%d\n",I,J);
	  }  

	   ணࠬ, 筮, ਢ  ⮬   १-
,   ।, ᪮  ⫨砥  .    -
 㭪樨, Swap(&I,&J) 祭  䠪᪨  ࠬ஢
(&I,&J) ᢠ  ଠ ࠬࠬ (A  B), -
뢠 ।⢥ ࠬ 㭪樨 Swap.  

		      ᭠ 䬥⨪
		       

	   ࠧ  室 㯨, ᫨	  -
 ⠪ ஢ ணࠬ ⠪, ⮡ IPtr 㪠뢠  
 ६ ⨯ int  ?   ।⠢  
  襭:  

	  void Main()
	  {
	  #define NumInts 3
		    int *List,I;
		    List=Alloc(NumInts * 2);
		    *List = 421;
		    *(List+1) = 53;
		    *(List+2) = 1806;
		    PrintF("᮪ ᮢ :");
		    for(I=0;I<NumInts;I++)
			      PrintF("%4p ",(List+I));
		    PrintF("\n᮪ 祭 :");
		    for(I=0;I<NumInts;I++)
			      PrintF("%4p ",*(List+I));
		    PrintF("\n");
	  }  

	   㭪樨 Alloc  ணࠬ ᯮ 㭪
Alloc c  ࠬࠬ:  뢠,  ᪮쪨 -
⮢ 㤥 ந室 १ࢨ஢ , ன -  -
稭      .  ᫥  饭  	㭪樨
Alloc, List 㪠뢠  ⮪  ࠧ஬ 6 (3*2) ,
  ࠭  ६ ⨯ int.
	   ஡ ᬮਬ  ᫥騥	  .
    - *List = 421.  砥:	"-
 421  ६ ⨯ int, ᯮ   ,  -
饬  ६ List".
	  騩: *(List+1) = 53 - ᮡ    -
.   ,   ஢  ⠪:  "-
 53  ६ ⨯ int, ᯮ  ⮬  
, ࠭饣  List". ᫨  ⠪,       
। ।饩 int-६ (   2  -
). , ⢥, ᯮ  祭.
	  ,     ᤥ ⠪ 訡. 
"",  List -  㪠⥫  ⨯ int,  ⮬  -
ࠦ List+1 ।⠢ ᮡ    ,  ।
ࠦ List+(1*sizeof(int)), ,  ⮬,  祭  53  
ᯮ 祭 421 (..  ⮣ 祭	㤥  뤥
㣠 祩 ).
	  筮, (List+1)=1806  ।⠢    
List+2  1806 ,  ࠣ   ।  -
祭.  饬, Ptr+I ।⠢   ,  ।塞
ࠦ Ptr+I*2. ,   ࠧ    
,   ,    祭 ࠭ ⤥쭮. 

			    ᨢ
			    

	  設⢮ 몮 ᮪ ஢,   - -
 । ᨢ, ..  ஢    
। ⨯. ᯮ ᨢ,   ९ -
 ணࠬ ᫥騬 ࠧ:  

	  void Main()
	  {
	  #define NumInts 3
		    int List[NumInts],I;
		    List[0] = 421;
		    List[1] = 53;
		    List[2] = 1806;
		    PrintF("᮪ ᮢ:");
		    for(I=0;I<NumInts;I++)
			      PrintF("%p ",&List[I]);
		    PrintF("\n᮪ 祭:");
		    for(I=0;I<NumInts;I++)
			      PrintF("%4u ",List[I]);
		    PrintF("\n");
	  }  

	  ࠦ int List[NumInts]  List  ᨢ
६ ⨯ int, c 쥬 , 뤥塞    -
 ६.
	  K ࢮ ६ ᨢ       
List[0], ன -   List[1]  쥩 -   List[2].
	   饬 砥 ᠭ  ᨢ    ᫥-
騩 :  

	  type Name[Size]
	  (⨯  [ࠧ])  

	   Type - ⨯  ⮢ ᨢ (  -
⨬  몥), Name -  ᨢ.
	    ᨢ -  Name[0], ᫥  -
 - Name[Size-1]. 

		      ᨢ  㪠⥫
		      

	  , ୮, 㦥 﫨,   ।
  ᨢ  㪠⥫ﬨ. ⮬, ᫨  믮
⮫쪮  ᬮ७ ணࠬ, 祭 १  㤥
 㦥 .
	  砫  㣮,   ⢥ ࠧ稥.
 ᠬ ,  ᨢ  ᯮ짮  㪠⥫; -
 ⮣,   । 㪠⥫  ᨢ. ᬮਬ
᫥騥  ⮦⢠: 

	  (List + I) == &(List[I])
	  *(List + I) == List[I] 

	     ࠦ ᫥ ⭮	ࠦ-
 ࠢ;    ᯮ짮     㣮,  
ਭ  , ᠭ  List    㪠⥫,    
ᨢ.
	  ⢥ ࠧ稥  ᠭ List,   㪠-
⥫   ᨢ ⮨	  ࠧ饭  ᠬ  ᨢ.
᫨  ᠫ List  ᨢ,  ணࠬ ⮬᪨ -
 ॡ㥬 쥬 . ᫨ 	  ᠫ  ६
List  㪠⥫,   ᠬ 易⥫쭮  뤥  -
  ᨢ, ᯮ  ⮣ 㭪 Alloc 	室
  㭪,   ᢮ ⮩ ६  	-
ண ᥣ ,  㦥  । ࠭.
  

  㭪,   ᢮ ⮩ ६