Вы находитесь на странице: 1из 104

ð£ì‹ 4

C‚è™ b˜‚°‹ ¸†ðƒèÀ‹


C-ªñ£N Góô£‚躋

4.1 C‚è™ b˜‚°‹ ¸†ðƒèœ


(Problem Solving Techniques)
 ªêŒ»‹ èEŠðE,  ðò¡ð´ˆ¶‹ èEŠªð£P ªñ£N
¬ò„ ê£ó£î¶ Ý°‹. èEŠªð£P¬ò»‹ ê£ó£î¶ Ý°‹. èEŠ
ªð£P¬ò»‹ ªñ£N¬ò»‹ «î˜‰ªî´Šð¶ ªð¼‹ð£½‹, °PŠH†ì
G¬ô¬ñJ™ ÜõŸP¡ ªð£¼ˆîº¬ì¬ñ¬ò„ ꣘‰î‹. å¼
Gó¬ô à¼õ£‚°‹«ð£¶, îI› ܙô¶ ݃Aô‹ «ð£¡ø ÞòŸ¬è
ªñ£NJ™î£¡ C‰F‚A«ø£‹. è¬ìC «ïóˆF™î£¡, õ®õ£‚般î
(design) àò˜G¬ô ªñ£NJ™ å¼ Góô£è ⿶A«ø£‹.

èEŠªð£P ªñ£NèO™, 嚪õ£¼ ßÁ‹, 裟¹œO, ܬóŠ


¹œOèœ à†ðìˆ ¶™Lòñ£è â¿îŠðì «õ‡´‹. è†ì¬÷ õK
è¬÷ ⿶‹«ð£¶ å¼õ˜ I°‰î èõùˆ¶ì¡ Þ¼‚è«õ‡´‹.
ÞòŸ¬è ªñ£NèO™, ªê£™ªî£ì˜èœ (sentences) I辋 c÷ñ£è
Þ¼‚èô£‹. Cô «õ¬÷èO™ ܬõ ªîOõŸø Þ¼‚èô£‹.
ܬùˆ¶ ÞòŸ¬è ªñ£NèÀ‚°«ñ ޚMò™¹ à‡´. âù«õ
C‚è™è¬÷ âšMî‚ °öŠðºI¡Pˆ ªîOõ£èŠ ¹K‰¶ªè£œ÷,
æ˜ Þ¬ìG¬ô ªñ£NJ™ ( Intermediary Language) ⿶A«ø£‹. Þ¬î
⿶õ¶‹ ¹K‰¶ ªè£œõ¶‹ âO¶. âšMî‚ °öŠðº‹ âö£¶.
ވî¬èò Þ¬ìG¬ô ªñ£N ÞòŸ¬è ªñ£NèÀ‚°‹ èEŠªð£P
ªñ£NèÀ‚°‹ Þ¬ìŠð†ì ªñ£Nò£°‹. ܈î¬èò Þ¬ìG¬ô
ªñ£Nèœ Þ󇮬ù  ð®‚è Þ¼‚A«ø£‹. ܬõ, IèŠ ªð¼
ñ÷M™ ðò¡ð´ˆîŠð´A¡ø 𣌾Šðì‹ (Flow Chart) ñŸÁ‹ «ð£L‚
°Pº¬ø (Pseudo Code) ÝAò¬õ Ý°‹.
ºîL™  𣌾Šð숬î ⴈ¶‚ ªè£œ«õ£‹. èEŠ¹
G¬ôŠð£¬îèO¡ ð£Œ¾èœ ðìñ£è à¼õA‚èŠð´õ Þ¶ ð£Œ
¾Šðì‹ âùŠ ªðò˜ªðŸø¶. æ˜ â´ˆ¶‚裆´ì¡ ªî£ìƒ°«õ£‹.
Þó‡´ â‡èO¡ Æ´ˆ ªî£¬è¬ò»‹, Þ󇮙 ªðKò
â‡¬í»‹ 致H®‚è «õ‡´‹. ފðE¬ò G¬ø«õŸP º®‚è,
ºîL™ Þó‡´ â‡è¬÷ àœkì£èŠ ªðŸÁ ÜõŸ¬ø îQˆîQ
200
ÞìƒèO™ îQˆîQŠ ªðò˜èO™ Þ¼ˆF¬õ‚è «õ‡´‹. Hø°
ÜõŸP¡ Æ´ˆ ªî£¬è¬ò‚ èEˆ¶ˆ F¬óJ™ è£†ì «õ‡
´‹. Ü´ˆ¶ Þó‡´ â‡èO™ ªðKò ⇠è‡ìPòŠð†´ˆ F¬ó
JìŠðì «õ‡´‹. ÞîŸè£ù 𣌾Šðì‹ ðì‹ 4.1-™ îóŠð†´œ
÷¶. 𣌾Š ðìˆF™ 嚪õ£¼ õ®õº‹ å¼ °PŠH†ì ªð£¼
¬÷‚ °P‚A¡øù. ܬõ ðì‹ 4.2-™ îóŠð†´œ÷ù.

ªî£ì‚è‹

A,A,BBäŠ
äŠð®

C=A+B

Cä Cä
܄C´

ޙ¬ô ݋
Bä Bä
܄C´
ä A > B? Aä Aä
܄C´
ä

º®¾
𣌾Šðì‹ 4.1

201
ªî£ì‚è‹, º®¾
àœk´, ªõOf´

ªêò™ð£´ b˜ñ£ùŠ ªð†®

膴Šð£´ ªê™½‹ F¬ê ެ특 º¬ù

𣌾Šðì‹ 4.2
«ñ«ô °PŠH†ì 𣌾ŠðìˆF™,
C=A+B

â¡Á â¿îŠð†´œ÷„ CøŠð£ù ªð£¼œ à‡´.  õö‚è


ñ£ù G蘊𣆴‚ (equal to) °P¬òŠ (=) ðò¡ð´ˆF»œ÷ «ð£F
½‹, å¼ G蘊𣆮™ (equation) àœ÷ ªð£¼O™ ܶ ðò¡ð´ˆîŠ
ðìM™¬ô. à‡¬ñJ™ Þ‰î‚ ÃŸP¡ (statement) ªð£¼œ, “õôŠ
ð‚èˆF™ Þ싪ðŸÁœ÷ A, B ÝAòõŸP¡ ފ«ð£¬îò ñFŠ¹
è¬÷‚ Æ®, Æ´ˆ ªî£¬è¬ò ÞìŠð‚躜÷ C- ¡ ¹Fò ñFŠ
ð£è, Þ¼ˆF¬õ” â¡ð‹. ⴈ¶‚裆ì£è, މî M÷‚èˆF¡
ð®,
A=A+1

â¡ð¶‹ ãŸèˆ î ßÁ. A- ¡ ñFŠH™ 塬ø‚ Æ®,


܊¹Fò ñFŠ¹ e‡´‹ A- J«ô«ò Þ¼ˆF¬õ‚èŠð´Aø¶. Üî£
õ¶, A- ¡ ñFŠ¹ å¡Á ÆìŠð´Aø¶.
A=A+B

â¡Á‹ â¿îô£‹ â¡ð¬î G¬ùM™ ªè£œè. Ýù£™,


A+B=A
202
â¡Á â¿îº®ò£¶. ÞìŠð‚èˆF™, õôŠð‚èˆF¡ M¬ì¬ò Þ¼ˆF
¬õ‚è å«óªò£¼ ªðò˜ ñ†´«ñ Þ¼‚è «õ‡´‹.
èEŠªð£P Íô‹ ªêŒò º®Aø ܬùˆ¶‚ èEŠ¹è¬÷»‹
𣌾Šðìñ£è õ¬ó‰¶ è£†ì º®»‹. C‚è™ CPî£è Þ¼ŠH¡
𣌾Šð캋 CPî£è Þ¼‚°‹. ªðKò C‚è™èÀ‚è£ù 𣌾Š
ðì‹ âŠð® Þ¼‚°‹ âù â‡EŠ 𣼃èœ. ï¬ìº¬ø õ£›‚
¬èJ¡ C‚è™èœ ⊫𣶋 IèŠ ªðKò¬õ. Ýù£™ õ°Šð¬ø‚
èí‚°èœ CPò¬õ«ò. è£óí‹, õ󋹂°†ð†ì «ï󈶂°œ Cô
°PŠH†ì 輈¶¼‚è¬÷ (Concepts) èŸÁˆ î¼õîŸè£è ܬõ
à¼õ£‚èŠð´A¡øù.
ªðKò C‚è™èÀ‚° 𣌾Š ðì‹ ªðKî£è Þ¼‚°‹. Ýù£™
 ðò¡ð´ˆ¶‹ î£O¡ Ü÷¾ CPò¶. âù«õ, å¼ ð£Œ¾Š
ðì‹ õ¬óòŠ ðô î£œèœ «î¬õŠðìô£‹. Ýù£™ å¼ î£OL
¼‰¶ Ü´ˆî î£À‚°„ ªê™õ¶ âŠð®? ‘Þ¬íŠH蜒 (Connec-
tors) â¡Á ܬö‚èŠð´‹ CPò õ†ìƒèœ Íô‹ ބC‚è¬ôˆ
b˜‚èô£‹. މî õ†ìˆF™ æ˜ â¿ˆ¬î‚ °PŠHì «õ‡´‹. å«ó
⿈¬î‚ ªè£‡ì ܬùˆ¶ õ†ìƒèÀ‹ ܬõ âƒA¼‰î£½‹
å«ó ¹œO¬ò‚ °P‚A¡øù. ܬõ å«ó ð‚èˆF™ Þ¼‚èô£‹
ܙô¶ ªõš«õø£ù ð‚èƒèO™ Þì‹ ªðŸP¼‚èô£‹. 𣌾Š
ðì‹ 4.3-™ æ˜ â´ˆ¶‚裆´ 裇è:

B A

A
B

B
𣌾Šðì‹ 4.3

203
𣌾ŠðìƒèO¡ ñèœ
𣌾Šðìƒèœ ¶™Lòñ£ù¬õ. ïñ¶ â‡íƒè¬÷ Iè„ êK
ò£è à¼õèŠð´ˆ¶ð¬õ. CPò 𣌾Šðìƒè¬÷ âOî£èŠ ¹K‰¶
ªè£œ÷ º®»‹. ï¬ìº¬ø õ£›M¡ C‚è™èÀ‚è£ù 𣌾Š
ðìƒèœ ðô ð‚èƒèƒè¬÷ ⴈ¶‚ ªè£œÀ‹, âù«õ ÜõŸ¬øŠ
¹K‰¶ªè£œõ¶ I辋 è®ù‹ â¡ð¶ å¼ °¬ø𣴠ݰ‹.
âù«õ, ܈î¬èò G¬ô¬ñèO™ âõ¼‹ 𣌾Šðìƒè¬÷Š ðò¡
ð´ˆî ñ£†ì£˜èœ.
W«ö 裵‹ è킰èÀ‚è£ù CPò 𣌾Šðìƒè¬÷ ⴈ
¶‚ ªè£œÀƒèœ. ܬõ, è킰èÀ‚è£ù b˜¬õ õöƒ°A¡ø
ùõ£ âùŠ 𣼃èœ. ÜõŸ¬ø ñùŠð£ì‹ ªêŒò«õ‡ì£‹. ÜõŸ
¬øŠ ¹K‰¶ªè£œ÷ ºò½ƒèœ. å¼ Gó¬ô ⿶õ º¡ð£è
 âšõ÷¾ C‰F‚è «õ‡®»œ÷¶ â¡ð¬î‚ èõùˆF™ ªè£œ
Àƒèœ.
å¼ ªð†®J¡ c÷‹, Üèô‹, àòó‹ ÝAòõŸ¬ø‚ ªè£‡´
Üî¡ ªè£œ÷÷¾ èí‚AìŠð´õ¬î 𣌾Šðì‹ 4.4-™ 裇è.

ªî£ì‚è‹

c÷‹, Üèô‹,
c÷‹, Üèô‹,àòó‹
àòó‹
ÞõŸ¬øŠ
ÞõŸ¬øŠð®ð®

ªè£œ÷÷¾=c÷‹*Üèô‹*àòó‹

ªè£œ÷÷¬õ
C

º®¾
𣌾Šðì‹ 4.4
204
𣌾Šðì‹ 4.5, 0L¼‰¶ 3 õ¬óJô£ù â‡è¬÷Š 𮈶,
ÜõŸ¬ø ⿈F™ â¿F‚ 裆´Aø¶.

ªî£ì‚è‹

NäŠ
NäŠ ð®

Ý
݋
²N ޙ¬ô
âù N = 0?
⿶
⿶ ⿶

Ý
݋ ޙ¬ô
å¡Á
âù NN =
= 1?
⿶
⿶ 1?

Þó‡
Þó‡´ Ý
݋ ޙ¬ô
´
âù NN =
= 2?
âù
⿶ 2?

Í¡Á
Í¡ Ý Þ™¬ô
no
݋
Á
âù NN= 3?
=
âù
⿶ 3?

º®¾

𣌾Šðì‹ 4.5
205
𣌾Šðì‹ 4.6, ªè£´‚èŠð†ì Í¡Á â‡èO™ CPò â‡
¬í‚ è‡ìP‰¶ ªê£™Aø¶.

ªî£ì‚è‹

a, b, c äŠ ð®

ޙ¬ô Ý
݋
aa<<b?
b?

ޙ¬ô ޙ¬ô
b b< <c? a a<<c?
? ?

Ý
݋ ݋
Ý

bä ܄C´
bä cc ä
ä ܄C´ a ä ܄C´

º®¾

𣌾Šðì‹ 4.6

206
𣌾Šðì‹ 4.7, Þ¼ð® G蘊𣆬ì (Quadratic equation) b˜Šð
îŸè£ù å¼ õNº¬ø¬ò õöƒ°Aø¶.

ªî£ì‚è‹

a,
a, b,
b, cc äŠ
äŠ ð®

݋
Ý Þ™¬ô
Þ¼ð®„
êñ¡ð£´
aa ==0? d=b2-4ac
ޙ¬ô âù
⿶

ޙ¬ ݋
݋
ޙ¬ô
d d< <0?
ޙ¬ô 0?

d d= =0? Þñ£TùK
Þñ£TùK
ޙ¬ô 0? ݋
݋ M¬ìèœ
M¬ìèœ
âù ⿶
âù ⿶

e=Öd
r1=(-
b+e)/2a r = -b/a
º®¾

Þ¼
Þ¼ «õÁ
«õÁ Þ¼
Þ¼ êñ
êñ
M¬ìèœ, r1,
M¬ìèœ r1 r2 M¬ìèœ,
M¬ìèœ r,r r

º®¾ º®¾

𣌾Š ðì‹ 4.7


207
ªî£ì‚è‹

n=1,n=1,
sum=0

ޙ¬ô ݋
n<=100?
n<=100
?
Sumää
Sum
ªõOJ´
ªõOJ´ aa äŠ
äŠ ð®

Sum=sum+
Sum=sum+a
º®¾
a
𣌾Šðì‹ 4.8

208
𣌾Šðì‹ 4.9, ªè£´‚èŠð†ì å¼ º¿â‡ (Integer), ð°
â‡í£ (prime number) ܙô¶ ðè£ â‡í£ â¡ð¬îˆ b˜ñ£Q‚
Aø¶.

ªî£ì‚è‹

nn äŠ
äŠ ð®

i=2

ޙ¬ô ݋
i<n? i=i+1

ޙ¬ô
õ°ðì£ Ý‹
õ°ðì£ nä i
â‡
⇠âù õ°‚°ñ£
⿶
âù
õ°ð´‹
õ°ð´‹
â‡
⇠âù
º®¾
end ⿶
âù

º®¾

𣌾Šðì‹ 4.9

209
𣌾Šðì‹ 4.10, 1+2+3+............+ n â¡ðî¡ Ã†´ˆ ªî£¬è êK
ò£è 1000 ܙô¶ Ü„ ꟫ø ôîô£è õ¼ñ£Á, e„CÁ º¿
â‡¬í‚ (smallest integer) è‡ìP‰¶ ªê£™Aø¶.

ªî£ì‚è‹

i=1, i=1,
sum=1

ޙ¬ô ݋
sum<10
sum<100?
0?

sum, i=i+1
i=i+1
sum, ii ä
ä
sum=sum+i
ªõOJ´ sum=sum+
ªõOJ´

º®¾

𣌾Šðì‹ 4.10

4.1.1 Ü®Šð¬ìò£ù Gð‰î¬ù ñŸÁ‹ 膴Šð£†´‚


è†ì¬ñŠ¹èœ(Fundamental Conditional and Control Structures)
èEŠªð£PŠ «ð£L‚ °Pº¬øJ™ (Computer pseudo code) åš
ªõ£¼ ð®G¬ô (step) ¬ò»‹  èEŠªð£P‚° ÜP¾Áˆî «õ‡
´‹. â¡ù ªêŒòŠ «ð£A«ø£‹ â¡ð¬îŠðŸP ïñ‚°ˆ ªîOõ£ù
¹Kî™ Þ¼‰î£™ ñ†´«ñ ï‹ñ£™ èEŠªð£PŠ «ð£L‚ °P
º¬ø¬ò â¿î º®»‹.  ªê£™õ¬î  ªê£™Aøð®«ò
èEŠªð£P ªêŒ»‹. ܶ î£ù£è«õ â¬î»‹ ªêŒò£¶. èEŠ
ªð£P¬òŠ ðóñ£˜ˆî °¼M¡ ä‰î£õ¶ Cwò¡ â¡ÁÃì„ ªê£™
ôô£‹. ã¡ âù MòŠð¬ìAl˜è÷£?
210
ðóñ£˜ˆî °¼M¡ Cwò˜è¬÷Š ðŸPò ðô è¬îèÀœ å¼
è¬î¬òŠ 𣘊«ð£‹. ðóñ£˜ˆî °¼¾‚° ° Cwò˜èœ à‡´.
ñ†®, ñ¬ìò¡, Íì¡, º†ì£œ â¡ð¶ Üõ˜èO¡ ªðò˜èœ.
މî ° ªðò˜èÀ‹ ‘ÜPML’ â¡Â‹ å«ó ªð£¼¬÷«ò
à혈¶A¡øù. Þõ˜èœ õ¼‹ îƒèœ °¼¾‚è£è å¼ õò
î£ù °F¬ó¬ò õ£ƒAù˜. °¼¬õ‚ °F¬óJ™ à†è£ó¬õˆ¶‚
ªè£‡´ õ¼‹ ï쉶 õ‰îù˜. °¼M¡ î¬ôŠð£¬è å¼
ñó‚A¬÷J™ «ñ£F‚ W«ö M¿‰¶M†ì¶. CP¶ «ïó‹ èNˆ¶
°¼ î¡ î¬ôŠð£¬è ⃫è â¡Á «è†ì£˜. W«ö M¿‰¶M†ì
î£è Cwò˜èœ ÃPù˜. 㡠ܬî ⴂèM™¬ô â¡Á «è†ì
«ð£¶, ‘Üšõ£Á cƒèœ ªê£™ôM™¬ô«ò’ â¡Á ðFLÁˆîù˜.
àì«ù °¼, ÞQ«ñ™ ⶠW«ö M¿‰î£½‹ ܬî ⴈ¶ àì¡
ªè£‡´ õó«õ‡´‹ â¡Á è†ì¬÷J†ì£˜.
å¼ Cwò¡ H¡«ù£‚A ï쉶 ªê¡Á î¬ôŠð£¬è¬ò ⴈ¶
õ‰î£¡. î¬ôŠð£¬è G¬øò °F¬óJ¡ ê£í‹ Þ¼Šð¬îŠ 𣘈¶‚
°¼¾‚°‚ «è£ð‹ õ‰î¶. î¬ôŠð£¬è«ò£´ ê£íˆ¬î»‹ âîŸè£è
ⴈ¶ õ‰b˜èœ â¡Á °¼ «è†è, “cƒèœî£«ù, W«ö ⶠM¿‰
‹ ⴈ¶õó„ ªê£¡m˜èœ. â¬î ⴊð¶, â¬î M´Šð¶
â¡ð¶ âƒèÀ‚° âŠð®ˆ ªîK»‹? âù«õ, âõŸ¬øªò™ô£‹
â´‚è «õ‡´‹ âù å¼ ð†®ò™ ªè£´ˆ¶M´ƒèœ. âƒèÀ‚°
âšMî‚ °öŠðº‹ Þ¼‚裶” â¡Á ðF™ ÃPù˜. °¼ å¼
c‡ì ð†®ò¬ô‚ ªè£´ˆî£˜. Üõ˜è÷¶ ðòí‹ ªî£ì˜‰î¶.
CP¶ «ïó‹ èNˆ¶, õòî£ù Ü‰î‚ °F¬ó î´ñ£P‚ W«ö
M¿‰î¶. °¼¾‹ Üõ¼¬ìò ªð£¼†èÀ‹ W«ö M¿‰¶ CîPù.
àì«ù, å¼ Cwò¡ ð†®òLL¼‰î ªð£¼†è¬÷ õ£C‚èˆ ªî£ìƒ
Aù£¡. î¬ôŠð£¬è, «õ†®, ¶‡´ âù 嚪õ£¡ø£è ⴈ¶„
«êèKˆîù˜. °¼ ªõÁ‹ Þ´Š¹ˆ ¶E«ò£´ Aì‰î£˜. ùˆ
ɂA‚ °F¬óJ¡«ñ™ A숶‹ð® Cwò˜èOì‹ «è†´‚ ªè£‡
죘. “ð†®òL™ cƒèœ Þ싪ðøM™¬ô °¼«õ” â¡Á àìù®
ò£èŠ ðF™ õ‰î¶. Üõó¶ «õ‡´«è£¬÷ Üõ˜èœ 裶 ªè£´ˆ¶‚
«è†èˆ îò£ó£J™¬ô. ð†®ò¬ôˆ F¼ˆF ܬñ‚°‹ð®»‹ ð†
®òL™ î¡Â¬ìò ªðò¬ó»‹ «ê˜ˆ¶‚ ªè£œÀ‹ð®»‹ °¼
«è†´‚ ªè£‡ì£˜. Üî¡Hø°, ð†®ò¬ô e‡´‹ êK𣘂°‹ð®
ݬíJ†ì£˜. ފ«ð£¶, Cwò˜èœ °¼¬õˆ ɂAM†ìù˜.
èEŠªð£PŠ «ð£L‚ °Pº¬ø»‹ Þ‰îŠ ð†®ò™ «ð£¡ø¶î£¡.
211
èEŠªð£P, ðóñ£˜ˆî °¼M¡ Cwò˜èO™ å¼õ¬óŠ «ð£¡ø¶.
Þ󇴂°‹ ÜFè «õÁ𣮙¬ô. èEŠªð£P‚°ˆ ªîOõ£è,
M÷‚èñ£è ݬíè¬÷ õöƒè «õ‡´‹. ܚõ£Á M÷‚èñ£ù
º¬øJ™ C‰F‚è  ðJŸCªðø «õ‡´‹.
ªñ£ˆîˆF™ 𣘈, Í¡«ø Í¡Á ¸†ðƒè«÷ e‡´‹
e‡´‹ Þ싪ðÁA¡øù. Þ‰î ¸†ðƒè¬÷Š ðò¡ð´ˆFˆî£¡
冴ªñ£ˆî‚ èEŠðE»‹ G¬ø«õŸøŠð´Aø¶. ÞõŸ¬ø‚ èŸ
Á‚ªè£œ÷ «õ‡´‹ â¡ð¶, eùõ˜ c„ê™ èŸÁ‚ªè£œ÷ «õ‡
®ò¶ âšõ÷¾ è†ì£ò«ñ£ ܚõ÷¾ è†ì£òñ£°‹.
õK¬êº¬øŠð´ˆî™  (Sequencing)
ªð£¶õ£è‚ èí‚W´èœ å¡ø¡H¡ å¡ø£è õK¬ê º¬øJ™
ªêŒòŠð´A¡øù. Ü®Šð¬ìò£ù 膴Šð£†´‚ è†ì¬ñŠ¹èÀœ
õK¬êº¬ø»‹ å¡ø£°‹.
4.1.1.1 A¬÷HKˆî™ (Branching)
Þ¼õN‚ A¬÷HKˆî™ (Two-way branching)
å¼ Mù£¬õ‚ «èÀƒèœ. ‘Ý‹’ ܙô¶ ‘Þ™¬ô’ â¡Â‹
M¬ì¬òŠ ªðÁƒèœ. M¬ì‚«èŸð, Þó‡´ ð£¬îèÀœ å¡P™
A¬÷HKˆ¶ ÜŠ¹ƒèœ. Þ¶ å¼ ê£Œê¶óŠ ªð†® Íô‹ M÷‚
A‚ 裆ìŠð´Aø¶. ðô 𣌾ŠðìƒèO™ ވî¬èò ªð†®¬òŠ
𣘈F¼Šd˜èœ. å«ó 𣌾ŠðìˆF™ ðô ÞìƒèO™ 𣘈F
¼Šd˜èœ. A¬÷HKˆî™ â¡ð¶‹ Ü®Šð¬ìò£ù 膴Šð£†´‚
è†ì¬ñŠ¹èÀœ å¡ø£°‹.
ⴈ¶‚裆´:
If A > B Then Print A, Otherwise Print B

â¡ø è†ì¬÷ ܬñŠ¹ “If......Then.......Else” è†ì¬ñŠ¹ Ý°‹. å¼


ð£¬îJ™ ªêò™ ⶾ‹ ޙ¬ô âQ™, “ If..... Then” è†ì ¬ñŠ¬ðŠ
ðò¡ð´ˆîô£‹. ޚõ¬ñŠH™ ðF™ ‘Þ™¬ô’ âQ™, ⶾ‹ ªêŒ
ò£ñ«ô«ò, ªêò™ð£´ Ü´ˆî ßÁ‚°„ ªê™ô «õ‡´‹.
ⴈ¶‚裆´:
If you find anyone there, then say hello

ðôõN‚ A¬÷HKˆî™ (Multi-way Branching)


Cô Mù£‚èÀ‚°, ݋ ܙô¶ ޙ¬ô â¡Aø ðF™ ñ†´‹
212
Þ¼‚è º®ò£¶. ⴈ¶‚裆ì£è, “Þ‰îŠ ¬ðòQ¡ õò¶ â¡ù?”
â¡ø «èœM‚° âˆî¬ù«ò£ â‡èO™ å¼ â‡ ðFô£è Þ¼‚°‹.
ðFL¡ Ü®Šð¬ìJ™, ªõš«õÁ ð£¬îèO™ ªê¡Á ªõš«õÁ
èEŠd´è¬÷„ ªêŒò «õ‡®J¼‚èô£‹. Þ¶ ðôõN‚ A¬÷
HKˆî™ âùŠð´Aø¶. Þî¬ù‚ W«ö»œ÷ 𣌾ŠðìˆF™ àœ÷
õ£Á M÷‚A‚ 裆ìô£‹.

ªî£ì‚è‹

i=1, i=1,
sum=1

=0 =3
sum<100?
sum<10
0?
=1 =2

²N âù å¡Á Þó‡´ Í¡Á


⿶ âù ⿶ âù ⿶ âù ⿶

º®¾

𣌾Šðì‹ 4.11

213
ⴈ¶‚裆´:
If n is 0 then print ‘Zero’
1 then print ‘One’
2 then print ‘Two’
3 then print ‘Three’

4.1.2 𡺬ø„ ªêò™ (Iteration)


G„êJˆî 𡺬ø„ ªêò™ (Definite Iteration)
Í¡ø£õ¶ Ü®Šð¬ìò£ù ¸†ð‹ ‘𡺬ø„ ªêò™’ Ý°‹.
Üî£õ¶, °PŠH†ì ªêò™ð£´è¬÷ e‡´‹ e‡´‹ ªêŒî™.
Ýù£½‹, Ü«î îó¾èœ e¶ Ü«î ªêò™ð£´è¬÷ˆ F¼‹ð„
ªêŒòŠ «ð£õF™¬ô. ܚõ£Á ªêŒõ¶ «ïóˆ¬î ií®Šð‹.
ⴈ¶‚裆ì£è, ËÁ â‡è¬÷Š ªðÁî™, ÝJó‹ õ£®‚¬èò£
÷˜èÀ‚°ˆ îó«õ‡®ò õ†®¬ò‚ è‡ìPî™. މî Þó‡´ â´ˆ
¶‚裆´èO½‹, å«ó ðE¬ò âˆî¬ù º¬ø F¼‹ð„ ªêŒò
«õ‡´‹ â¡ð¬î ÜP‰F¼‚A«ø£‹. âù«õ Þî¬ù ‘G„ê
Jˆî 𡺬ø„ ªêò™’ â¡A«ø£‹. މî õNº¬øJ™, °PŠ
H†ì ªêò™ð£´ âˆî¬ù º¬ø ªêŒòŠð´Aø¶ â¡ð¬î â‡E‚
ªè£‡«ì õó«õ‡´‹. ޚõ£Á ⇵õŠ ðò¡ð´‹ ñ£P
²†´ ñ£P (Index veriable) ܙô¶ 膴Šð£†´ ñ£P (Control Variable)
â¡Á ܬö‚èŠð´Aø¶.
² † ´ ñ £ P ¬ ò Š ð ò ¡ ð ´ ˆ ¶ õ F ™ ï £ ¡ ° Ü ® Š ð ¬ ì Š ð®
G¬ôèœ àœ÷ù:
1) ²†´ ñ£PJ™ ªî£ì‚èˆF™ å¼ ªî£ì‚è ñFŠ¬ð Þ¼ˆî
«õ‡´‹.
2) ²†´ ñ£PJ¡ ފ«ð£¬îò ñFŠ¹ (v) Üî¡ ÞÁF ñFŠ¹
ì¡ åŠHìŠð†´, ÞQ«ñ½‹ F¼‹ð„ ªêŒò«õ‡´ñ£ â¡ð¬îˆ
b˜ñ£Q‚è «õ‡´‹.
3) M¬ì ‘Ý‹’ âQ™,
u «î¬õò£ù ªêò™ð£´è¬÷ 强¬ø G¬ø«õŸø¾‹.

u ²†´ ñ£PJ¡ ñFŠ¬ð å¡Á Æ쾋.


u Þó‡ì£õ¶ ð®G¬ô‚°„ ªê¡Á, êK𣘈î¬ô e‡´‹
ªêŒè.
214
4) M¬ì ‘Þ™¬ô’âQ™,
u F¼‹ð„ ªêŒî™ º®‰¶ «ð£ù¶.
u õK¬êò¬ñŠH™ Ü´ˆî è†ì¬÷‚°„ ªê™ô¾‹.
𣌾Šðì‹ 4.12 G„êJˆî 𡺬ø„ ªêò¬ô M÷‚°Aø¶.
ðìˆF™, F¬êM‚èŠð†ì «è£´è÷£™ Ýù å¼ ñì‚A¡ (Loop)
Íô‹ 𡺬ø„ ªêò™ 裆ìŠð†´œ÷¶.

i=1

ޙ¬ô ݋
i<=1000 «î¬õò£ù
«î¬õò£ù
i<=1000? ªêò™
? ªêò™

Ü´ˆî õK i=i+1

𣌾Šðì‹ 4.12

Cô śG¬ôèO™, âˆî¬ùº¬ø F¼‹ð„ ªêŒò«õ‡´‹


â¡ð¬î ªî£ì‚èˆF™ èE‚è º®ò£ñ™ «ð£èô£‹. ⴈ¶‚裆
ì£è, 1+2+3+..... +n â¡ðî¡ Ã†´ˆ ªî£¬è ˬø ↴‹ õ¬èJ™,
e„CÁ n- ¡ ñFŠ¬ð‚ è£í «õ‡´‹. 嚫õ£˜ â‡í£è‚ Æì
«õ‡´‹. ܚõ£Á Æ´‹«ð£¶ ˬø ↮M†ìî£ â¡ð¬î„
«ê£F‚è«õ‡´‹. ˬø ↮ò¶‹ GÁˆFMì «õ‡´‹. â‡è¬÷‚
Æ´‹ ªêò¬ô âˆî¬ùº¬ø ªêŒ«õ£‹ â¡ð¬î º¡Ã†®«ò
æ˜ â‡E‚¬èò£è„ ªê£™ô º®ò£¶. ވî¬ù º¬ø âù â‡
E‚ ªè£‡®¼Šð¶ ðò¡îó£¶. ‘ˬø ↮M†ì â¡Aø Gð‰
î¬ù¬òˆî£¡ ðK«ê£F‚è «õ‡´‹. ވî¬èò 𡺬ø„ ªêò™,
‘G„êòˆFì£ ð¡º¬ø„ ªêò™’ (Indefenite Iteration) âùŠð´Aø¶.
õK¬êº¬øŠð´ˆî™ (Sequencing), A¬÷HKˆî™ (Branching),
𡺬ø„ ªêò™ (Interation) ÝAòõŸ¬øŠ ðò¡ð´ˆF ܬùˆ¶‚
èEŠd´è¬÷»‹ ªêŒ¶ º®‚è º®»‹.
215
4.1.3 «ð£L‚ °Pº¬ø (Pseudo Code)
å¼ °PŠH†ì ðE¬ò G¬ø«õŸÁõîŸè£ù ªêò™º¬ø¬ò
𣌾Šðì‹ Íôñ£è õ¬ó‰¶ 裆´õŠ ðFô£è, «ð£L‚ °P
º¬ø Íôñ£è¾‹ â¿F‚ 裆ìô£‹. ‘«ð£L‚ °Pº¬ø’ â¡ð¶,
݃Aô ªñ£Nˆ ªî£ì¼‚°‹ àJ˜G¬ô‚ èEŠªð£P ªñ£N‚
è†ì¬÷èÀ‚°‹ Þ¬ìŠð†ì¶. ݃AôˆF™ ªî£ì˜èœ c÷ñ£è
Þ¼‚°‹; ¶™Lòñ£è Þ¼‚裶. èEŠªð£P ªñ£NèO™ è†ì¬÷ˆ
ªî£ìó¬ñŠ¹ èø£ó£èŠ H¡ðŸøŠðì «õ‡´‹. «ð£L‚ °Pº¬ø
J™ މî Þó‡´ àÁˆî™èÀ‹ A¬ìò£¶.
Iè„ Cô ªî£ì˜õ¬èè«÷ ÞF™ àœ÷ù. ܬõ»‹ Iè„
CPò¬õ. Ýù£½‹, â‰îªõ£¼ ªêò™º¬ø¬ò»‹ õ¬óòÁ‚°‹
Fø¡ ªè£‡ì¬õ. ïñ‚° ñŸÁªñ£¼ ïòñ£ù ªî£ìó¬ñŠ¹ õê
F»‹ àœ÷¶. å«ó ªî£ìK™ ðô ÃÁè¬÷ å¡Á «ê˜‚è, õö‚è
ñ£ù ܬ승‚°Pè¬÷ õö‚èñ£ù ªð£¼O™ ðò¡ð´ˆî º®
»‹. õKè¬÷ àœîœ÷™ (Indentation) Íôñ£è¾‹, å¡Á‚° «ñŸ
ð†ì ßÁè¬÷ å¡Á«ê˜‚è º®»‹. «ð£L‚ °Pº¬øJ™ â¿
îŠð´‹ Mõóƒè¬÷ âOî£èŠ ¹K‰¶ªè£œ÷ º®»‹.
𣌾ŠðìˆF™  𣘈î A¬÷HKˆî™, F¼‹ð„ ªêŒî™
«ð£¡ø 膴Šð£†´‚ è†ì¬ñŠ¹è¬÷ «ð£L‚ °Pº¬øJ™ ޚ
õ£Á â¿îô£‹:
* If.... then............else.............
* If....... then..............
* For.............. to........do.....
* While.............do.........
ÞõŸÁ‚è£ù Cô ⴈ¶‚裆´‚ °Pº¬øèœ:

• If a > b then print a else print b


• If a < 10 then b = c + d
• For i = 1 to 20 do
n=n+i
• While sum < 100 do
sum = sum + i
i=i+1
216
ⴈ¶‚裆®¡, àœîœ÷Šð†ì Þó‡´ õKèÀ‹
While......do
å¡ø£è„ «ê˜‚èŠð†´, å«ó ªêò™ð£†´‚ è†ì¬÷ò£è‚ è¼îŠ
ðì«õ‡´‹ â¡ð¬î‚ èõùˆF™ ªè£œè. «ñŸè‡ì ⴈ¶‚
裆´èÀ‚è£ù 𣌾Šðìƒè¬÷‚ W«ö 裇è:

ޙ¬ô
no ݋
yes
a > b? ޙ¬ô
no ݋
yes
a<10?
b- ä a- ä
Print b Print a b=c+d
܄C´ ܄C´

i=1

ޙ¬ô
no ݋
yes
sum< 1000?
ޙ¬ô
no ݋
yes
i<=20? n=n+i
sum = sum+i
i=i+1
i=i+1

𣌾Šðì‹ 4.13

ܬùˆ¶‚ 膴Šð£†´‚ è†ì¬ñŠ¹èÀ‹, å«óªò£¼ ¸¬ö¾


º¬ù, å«óªò£¼ ªõO«òÁ º¬ù¬ò«ò ªè£‡´œ÷ù â¡ð¬î
«ï£‚°è. Üî£õ¶ ނè†ì¬÷ ܬñŠ¹èO™ °PŠHìŠð†´œ÷
ªêò™ð£´è¬÷ G¬ø«õŸP º®ˆîH¡, 膴Šð£´ Ü´ˆ¶œ÷
ßÁ‚° ñ£ŸøŠð†´ M´‹. Üî£õ¶, èEŠªð£P õK¬êº¬øJ™
Ü´ˆ¶ Þ싪ðŸÁœ÷ è†ì¬÷¬ò G¬ø«õŸøˆ ªî£ìƒ°‹. Þ¶
 ނè†ì¬÷ ܬñŠ¹èO¡ å¼ CøŠ¹‚ Ãø£°‹. ¹Kî¬ô»‹,
H¬öè¬÷‚ è‡ìP‰¶ c‚°î¬ô»‹ Þ¶ âOA M´Aø¶.
º‰¬îò ð°FJ™  b˜ˆ¶¬õˆî C‚è™èÀ‚è£ù «ð£L‚
°Pº¬øèœ W«ö ªè£´‚èŠð†´œ÷ù. 𣌾Šðìƒè¬÷»‹,
«ð£L‚ °Pº¬øè¬÷»‹ åŠH†´, ܬõJ󇴋 åˆF¼Šð¬î
àÁF ªêŒ¶ ªè£œè.
217
u ªè£œ÷÷¾ è‡ìPî™
start
read length, breadth and height.
volume = length x breadth x height
print volume
end

«ñŸè‡ì ⴈ¶‚裆®™, õK¬êº¬ø‚ ßÁèœ ñ†´«ñ


ðò¡ð´ˆîŠð†´œ÷ù.
u â‡è¬÷ ⿈ ⿶î™
start
read n
if n is
0 then write ‘zero’
1 then write ‘one’
2 then write ‘two’
3 then write ‘three’
end

u Í¡Á â‡èO™ CPò â‡¬í‚ è‡ìPî™

start
read a, b, c
if a < b then
(if a < c then
print a
else
print c
)
else
(if b < c then
print b
else
print c )
end

218
u Þ¼ð® Gè˜Šð£†¬ìˆ b˜ˆî™
start
read a, b, c
if a = 0 then
(
write ‘this is not a quadratic equation’
exit
)
else
find d = b2 - 4ac
if d < 0 then
write ‘imaginary roots’
else
if d = 0 then
r = -b/a
write ‘ equal roots’
write r, r
else
r1 = (-b + d)/ 2a
r2 = (-b - d)/2a
write ‘unequal roots’
write r1, r2
end

u 100 õ¬óJô£ù â‡èO¡ Æ´ˆ ªî£¬è è£í™


start
sum = 0
n=1
while n <= 100 then do
read a
sum = sum + a
n= n+1
print sum
end

u ðè£ â‡è¬÷‚ è£í™


start
read n
for i = 1 to n-1 do
if i divides n then
(write ‘not a prime’
exit program
)
write ‘prime number’
end

219
u Æ´ˆ ªî£¬è ÝJóˆ¬î ↴‹ õ¬ó
start
i=1
sum = 1
while sum < 1000 do
i=i+1
sum = sum + i
print i and sum
end

àƒèœ èõùˆ¶‚°„ Cô °PŠ¹èœ


u å¼ If... then....else ßÁ‚°œ Þ¡ªù£¼ If.... then..... else ßÁ
îóŠð†´œ÷¶. Þî¬ùˆ ªîOõ£è à혈¶‹ ªð£¼†´ àœîœO
â¿îŠð†´œ÷¶.
uå¼ ÃŸÁ‚°œ«÷«ò Þ싪ðÁ‹ Þ¡ªù£¼ ßÁˆî£¡
«ñ½‹ àœîœO â¿îŠð†´œ÷¶. ñŸøð® õK¬êº¬ø ܬñŠ
H½œ÷ ßÁèœ å«ó Ü÷õ£è àœîœ÷Šð†´ â¿îŠð†´œ÷ù.
u èEîˆF™ ܬ승‚ °Pè¬÷Š ðò¡ð´ˆ¶õ¶ «ð£¡«ø,
ރ«è»‹ å¡Á «ê˜‚è ܬ승‚ °Pè¬÷Š ðò¡ð´ˆF àœ
«÷£‹.
u «ð£L‚ °Pº¬øJ™ â¿îŠð†´œ÷ ªêò™º¬øèœ, å¼
èEŠªð£P Gó¬ôŠ ªðK¶‹ åˆF¼Šð, ÞõŸ¬ø àò˜G¬ô
ªñ£N‚ èEŠªð£P Gó™è÷£è ñ£ŸP ܬñŠð¶ I辋 âOî£
°‹.
4.1.4 êK𣘊¹ (Walkthrough)
å¼ Gó™ ⿶õF™ ºî™ð®, b˜¾‚è£ù õNº¬ø¬ò Mõ
K‚°‹ å¼ ð£Œ¾Šðì‹ Ü™ô¶ «ð£L‚ °Pº¬ø¬ò à¼õ£‚°
î™ Ý°‹. C‚轂è£ù å¼ b˜M¬ù õ®õ¬ñŠðF™ Þ¶
ªî£ì‚è G¬ô Ý°‹. 𣌾Šðì‹ Ü™ô¶ «ð£L‚ °Pº¬ø¬ò
Ü®Š ð¬ìò£è ¬õˆ¶, å¼ °PŠH†ì ªñ£NJ¡ è†ì¬÷ ܬñŠ¹
MFèÀ‚° à†ð†´ Gó™ â¿îŠð´Aø¶. å¼ Gó¬ô ⿶õ
º¡ð£è, C‚è™ b˜¾‚è£ù õNº¬ø êKò£ùî£ â¡ð¬îŠ ðK
«ê£F‚è «õ‡´‹. âù«õ,  à¼õ£‚Aò 𣌾Šð캋, «ð£L‚
°Pº¬ø»‹ êKò£ùð® ܬñ‰¶œ÷ùõ£ â¡ð¬îŠ ðK«ê£F‚è
«õ‡´‹. ðK«ê£î¬ù‚° º¡ð£è, b˜¾ªïP (Algorithm) â¡ø£™
220
â¡ù â¡Á 𣘊«ð£‹. Üî¡Hø°, 𣌾Šðì‹ Ü™ô¶ «ð£L‚
°Pº¬ø¬òŠ ðK«ê£F‚è å¼ õNº¬ø¬ò‚ 裇«ð£‹.
‘b˜¾ªïP’ â¡ð¶, W›‚裵‹ ð‡¹è¬÷‚ ªè£‡ì å¼ ªêò™
º¬ø Ý°‹:
uõó‹¹Á (finite) â‡E‚¬èJô£ù ð®G¬ôèœ (steps) Þ¼‚è
«õ‡´‹.
u 嚪õ£¼ ð®G¬ô»‹, âšMî‚ °öŠðºI¡P ªêò™ð
´ˆ¶‹ G¬ôJ™ Þ¼‚è «õ‡´‹.
u 嚪õ£¼ ð®G¬ô»‹, õ󋹂°†ð†ì G¬ùõèŠ ð°F¬òŠ
ðò¡ð´ˆF, õ󋹂°†ð†ì «ï󈶂°œ ªêò™ð´ˆ¶‹ G¬ôJ™
Þ¼‚è «õ‡´‹.
u º¿¬ñò£ù Gó½‹, õ󋹂°†ð†ì «ï󈶂°œ Þòƒ
°‹ð® Þ¼‚è «õ‡´‹.
å¼ b˜¾ªïP‚è£ù 𣌾Šðì‹ Ü™ô¶ «ð£L‚ °Pº¬ø
ªè£´‚èŠð†´œ÷î£è ¬õˆ¶‚ ªè£œ«õ£‹. Þî¬ù Ü®Šð¬ì
ò£è‚ ªè£‡´ å¼ èEŠªð£P âšõ£Á ªêò™ð´‹ â¡ð¬îŠ
ðK«ê£F‚°‹ õNº¬ø¬ò, åˆF¬è ܙô¶ êK𣘊¹ âùô£‹.
݃AôˆF™ walkthrough â¡ø¬ö‚èŠð´Aø¶. ⴈ¶‚裆ì£è, å¼
𣌾Šð숬î ⴈ¶‚ ªè£œ«õ£‹. àƒè¬÷ å¼ èEŠªð£P
ò£è à¼õAˆ¶‚ ªè£œÀƒèœ. ªî£ìƒ° (Start) âù‚ °PŠH†
´œ÷ ªð†®JL¼‰¶ ªî£ìƒè «õ‡´‹. މî ÞìˆFL¼‰¶,
܋¹‚°Pè÷£™ °P‚èŠð†ì ð£¬îJ™ cƒèœ ðòE‚è «õ‡
´‹. å¼ ªêšõèŠ ªð†®‚°œ ¸¬ö‰î£™, «î¬õò£ù èEŠd´
è¬÷„ ªêŒò«õ‡´‹.
ܶ æ˜ àœk†´Š ªð†® âQ™, °PŠH†ì ñ£PèÀ‚°Kò
ñFŠ¹è¬÷ ⴈ¶‚ ªè£œ÷«õ‡´‹. 嚪õ£¼ º¬ø»‹ ªõš
«õÁ ªî£°F ñFŠ¹è¬÷ ⴈ¶‚ ªè£œ÷«õ‡´‹. ܊ªð£¿¶
 ªõš«õÁ ð£¬î õN«ò ðòEˆ¶Š ðK«ê£F‚è º®»‹. CPò
Gó™èÀ‚°, ªî£ì‚èˆFL¼‰¶ º®¾õ¬ó Þ¼‚A¡ø ܬùˆ¶Š
ð£¬îèO½‹ ðòEŠð¶ è®ùñ£ù ðEò¡Á. å¼ õNº¬ø êK
ò£ùî£ â¡ð¬î àÁFŠð´ˆ¶õF™ Þ¶ å¼ ð®G¬ôò£°‹.
ܶ å¼ ªõOf†´Š ªð†® âQ™, ñ£PèO¡ ð£¬îò
ñFŠ¹è¬÷ ªõOJì «õ‡´‹.
221
4.1.5 å¼ Gó¬ô à¼õ£‚°î™
å¼ CPò Gó¬ô ⿶õ¶ âO¶. âù«õ, å¼ CPò Gó½‚
è£ù «ð£L‚ °Pº¬ø ܙô¶ 𣌾Šðìˆ¬î ºîL™ õ¬ó
«õ£‹. Üî¡ Ü®Šð¬ìJ™ Gó¬ô ⿶õ¶ âO¶. Ýù£½‹,
ï¬ìº¬ø õ£›‚¬èJ™  裵‹ I芪ðKò C‚è™èÀ‚°
މî õNº¬ø àîõ£¶. Ü, º¬øŠð®ò£ù æ˜ Üµ°º¬ø
IèIèˆ «î¬õò£°‹.
å¼ GóL™ ãó£÷ñ£ù Mõóƒè¬÷ˆ îó «õ‡®J¼‚°‹.
Ýù£™, IèŠ ªðKò ºòŸCJ™ ÞøƒA, Iè ¸µ‚èñ£ù
Mõóƒè¬÷Š ðŸPªò™ô£‹ C‰F‚èˆ ªî£ìƒAù£™, à‡¬ñò£ù
ðEJ™ èõù‹ ªê½ˆî º®ò£ñ™ «ð£ŒM´‹. ފð®Šð†ì ś
G¬ôJ™ å¼õ˜, Iè º‚Aòñ£ù ðEè¬÷ ñ†´‹ Üõ«ó 𣘈¶‚
ªè£œ÷«õ‡´‹. CÁCÁ ð°Fè¬÷ Üõ¼‚°‚ W› ðE ¹Kðõ˜
èOì‹ M†´Mì «õ‡´‹.
å¼ ªðKò ðE¬ò„ ªêŒ¶ º®Šð ޶ êKò£ù
º¬øò£°‹. åŸÁ¬ñJ¡ õL¬ñ¬ò ï£ñP«õ£‹. Þ¬î M÷‚
°‹ ðô è¬îè¬÷Š ð®ˆF¼‚A«ø£‹. ⴈ¶‚裆ì£è, CPò °„C
è¬÷ å¡ø£è‚ 膮¬õˆî£™ à¬ì‚è º®ò£¶. Ýù£™, ÜõŸ¬øˆ
îQˆîQ«ò HKˆªî´ˆî£™ Iè âOî£è ºPˆ¶Mì º®»‹. ޚ
õ£Á HKˆ¶¬õˆ¶ ªõŸPªè£œÀ‹ ܵ°º¬ø ðô ÞìƒèO™
ðò¡ð´ˆîŠð´Aø¶. å¼ ªðKò Gó¬ô ⿶õ Þ«î õN
º¬ø I辋 ðò¡îó‚ î‚è‹.
å¼ Gó¬ô à¼õ£‚°õ º¡ð£è, Ü‰î„ C‚è¬ô„ CPò
C‚è™è÷£èŠ HKˆ¶‚ ªè£œ÷«õ‡´‹. ܈î¬èò CPò C‚è™
èÀ‚°‚ è‡ìPòŠð´‹ M¬ìè¬÷ å¡Á«ê˜ˆ¶, ªðKò C‚è
½‚° M¬ì裵‹ õNº¬ø¬ò  ÜP‰¶ ¬õˆF¼‚è «õ‡
´‹. å¼ Gó¬ô à¼õ£‚°õF™ Þ¶ å¼ ð®G¬ô Ý°‹. å¼
𣌾Šðì‹ Ü™ô¶ «ð£L‚ °Pº¬ø õ¬óò º®Aø Ü÷¾‚°„
CP‹ õ¬ó, ªðKò C‚è¬ô e‡´‹ e‡´‹ à¬ìˆ¶Š HKˆ¶‚
ªè£‡«ì õó«õ‡´‹.
ïñ‚° 㟪èù«õ ðö‚èñ£ù «ð£L‚ °Pº¬ø¬òŠ ðò¡
ð´ˆF«ò, ꣘¹ Gó™è¬÷ 弃A¬í‚°‹ î¼‚è º¬ø¬ò»‹
â¿FMì º®»‹. 𣌾ŠðìƒèO¡ Íôñ£è¾‹ Þî¬ù„ ê£F‚è
º®»‹. âù«õ, ðô «ð£L‚ °Pº¬øè¬÷»‹ 𣌾Š ðìƒ
è¬÷»‹ ðò¡ð´ˆF, º¿ GóL¡ õNº¬ø ¸†ðˆ¬î»‹ â¿F
222
Mì º®»‹. Üî¡Hø°, ÞõŸ¬ø‚ èEŠªð£P Góô£è ñ£ŸÁõ¶
I辋 âOò ðEò£AM´‹.
å¼ Gó¬ô à¼õ£‚°õF™ Þ¶«ð£¡ø ܵ°º¬ø ‘«ñL
¼‰¶ W› ܵ°º¬ø’ (Top Down Approach) âùŠð´Aø¶. 嚪õ£¼
ð®G¬ôJ½‹, å«óªò£¼ CÁðEJ™ ñ†´«ñ èõù‹ ªê½ˆ¶
A«ø£‹. CPò C‚è™èO¡ M¬ìè¬÷ 弃A¬íˆ¶ˆ b˜M¬ù
ܬìõ¶ âŠð® â¡ð¬î‚ è‡ìPA«ø£‹. èEŠªð£P Gó™
è¬÷Š ªð£Áˆîõ¬ó, މî õNº¬ø¬ò ºîL™ ðò¡ð´ˆ¶‹
«ð£¶, ªêò™º¬øèÀ‚«è (procedures) º‚Aòˆ¶õ‹ î¼A«ø£‹,
Üî£õ¶, âŠð®„ ªêò™ð´ˆ¶õ¶ â¡Aø õNº¬øèÀ‚«è º‚
Aòˆ¶õ‹ î¼A«ø£‹, îó¾èÀ‚° (data) ܙô. Þ¶«õ ‘è†ì¬ñŠ¹
Góô£‚è‹’ âùŠð´Aø¶. å¼ C‚è¬ô„ CPò C‚è™è÷£è à¬ì‚
°‹«ð£¶, ªêò™º¬ø«ò£´ îó¾èÀ‹ èí‚A™ ⴈ¶‚ ªè£œ÷Š
ð´ñ£J¡, Üî¬ù ‘ªð£¼œ«ï£‚° ܵ° º¬ø’ (Object Oriented
Approach) â¡A«ø£‹. Gó™è¬÷ à¼õ£‚°õ Þ¶«õ I辋
㟹¬ìò ܵ°º¬ø âù‚ è‡ìPòŠð†´œ÷¶. ªð£¼œ«ï£‚°
ܵ°º¬øJ¡ Ü®Šð¬ìJ™ à¼õ£‚èŠð´‹ Gó™è¬÷ ⿶
õ, C++ ñŸÁ‹ ü£õ£ «ð£¡ø èEŠªð£P ªñ£Nèœ àî¾A¡
øù. މî ܵ°º¬øðŸP  MKõ£èŠ ð®‚èŠ «ð£õ¶ ޙ¬ô.
«ñL¼‰¶ W› ܵ°º¬øJ¡ ðò¡ð£†¬ì æ˜ â´ˆ¶‚
裆®¡ Íô‹ M÷‚è Þ¼‚A«ø£‹. â‰îªõ£¼ Gó¬ô ⿶õ
‹ Þ«î õNº¬ø¬òŠ H¡ðŸÁƒèœ.
C‚è™:ËÁ â‡è¬÷ ãÁºè õK¬êJ™ 弃è-
¬ñ‚è å¼ Gó™ ⿶è.
õNº¬ø:
® ËÁ â‡è¬÷Š ªðŸÁ a1, a2,....... ÝAòõŸP™ Þ¼ˆ¶è.
® ÜõŸÁœ e„CÁ â‡¬í‚ è‡ìPè.
® މî â‡¬í ºî™ â‡µì¡ Þìñ£Ÿø‹ ªêŒè.
® Þ«î«ð£ô, Þó‡ì£‹ â‡, Í¡ø£‹ â‡EL¼‰¶
ªî£ìƒA 98 º¬ø (ã¡ â¡Á ªê£™ô º®»ñ£?) «ñŸ
è‡ì Þó‡´ ð®G¬ôè¬÷ F¼‹ðˆ F¼‹ð„ ªêŒò¾‹.
® ËÁ â‡è¬÷»‹ F¬óJ™ 裆쾋

223
«ñŸè‡ì ð®G¬ôè¬÷ º¬øŠð®ò£ù «ð£L‚ °Pº¬ø‚
è†ì¬÷è÷£è â¿FŠ 𣘊«ð£‹.
Read 100 numbers and put them in an array, as a(1), a(2) etc.

Do for i = 1 to 99

Find the smallest of a(i) to a(100)


Let the smallest number be at the jth position
Interchange a(i) and a(j)

Output a(1), a(2) ... a(100)

W«ö»œ÷ CPò ðEè¬÷ ï‹ñ£™ ªêŒ¶ º®‚è º®»ªñQ™,


冴ªñ£ˆî„ C‚轂°‹ âOî£èˆ b˜¾ 致Mì º®»‹.
u ËÁ â‡è¬÷ àœkì£èŠ ªðÁ, ªõOJ´î½‹
u ªè£´‚èŠð†ì ⇠ªî£°FJ™ e„CÁ â‡í‚ è‡ìPî™
u Þó‡´ â‡è¬÷ Þì‹ ñ£ŸÁî™
Þ‰îŠ ðEè¬÷ âšõ£Á ªêŒ¶º®‚èŠ «ð£A«ø£‹ â¡Aø
Mõóƒè¬÷Š ðŸP ފ«ð£¶  èõ¬ôŠðì «ð£õF™¬ô. Ü´ˆî
è†ì„ ªêòô£‚èˆF™ Þ¬î‚ èõQŠ«ð£‹. ފ«ð£¶ Þó‡ì£‹
ð®G¬ôJ™, «ñŸè‡ì CÁðEèœ åšªõ£¡ø£è ⴈ¶‚ ªè£‡´
b˜¾è£í ºò™«õ£‹.
ËÁ â‡è¬÷Š ð®ˆî™:
For Count = 1 to 100 do
Read a(count)

Þ«î õNº¬ø¬ò ËÁ â‡è¬÷ ªõOJ쾋 ðò¡ð´ˆîô£‹.


a(1) ºî™ a(100) õ¬óJô£ù ËÁ â‡èO™ e„CÁ ⇬í‚
è‡ìPî™:
Let i = 1
Let position = 1
Let min = a(i)

For n = i+1 to 100 do


If a(n) < min then
min = a(n)
position = n

Let j=position
224
a(i) ñŸÁ‹ a(i) Þ󇮡 ñFŠ¹è¬÷»‹ Þì‹ ñ£ŸÁî™:
Let temp = a(i)
a(i) = a(j)
a(j) = temp
ރ«è, ޚõ£Á â¿Fù£™ H¬öò£AŠ «ð£°‹.
a(i) = a(j)
a(j) = a(i)
è£óí‹, ºî™ è†ì¬÷ G¬ø«õŸøŠð†ì¾ì«ù a(i)- ¡ ð¬öò
ñFŠ¹ Þö‚èŠð´Aø¶.
4.2 C-ªñ£N Góô£‚è‹ - æ˜ ÜPºè‹
Góô£‚舶‚° I辋 ðóõô£èŠ ðò¡ð´ˆîŠð´‹ ªê™õ£‚
°Š ªðŸø Góô£‚è ªñ£N C-ªñ£Nò£°‹. ºŠð¶ ݇´èÀ‚°‹
º¡ù£™ ã¯&¯ ªð™ ݌¾‚ ÃìˆF™ ªì¡Qv â‹.K†C, C-
ªñ£N¬ò à¼õ£‚Aù£˜. ªî£ì‚èˆF™, ÎQ‚v Þò‚è º¬ø¬ñ
«ò£´ ެ퉶 ðò¡ð´ˆ¶õèù õ®õ¬ñ‚èŠð†ì «ð£F
½‹, C-ªñ£N å¼ ªð£¶Šðò¡ ªñ£Nò£èˆ Fè›Aø¶. C-ªñ£N,
ªêò™Fø¡ I‚è¶; ªïA›¾ˆ ñ ªè£‡ì¶; ªðò˜¾ˆFø¡
(Portability) ªðŸø¶. å¼õ¬è‚ èEŠªð£PJ™ Þò‚°õîŸè£è â¿îŠ
ð†ì ªñ¡ªð£¼¬÷, âšMî ñ£Ÿøº‹ Þ¡P«ò£ ܙô¶ CPî÷¾
ñ£Ÿøˆ¶ì«ù£ «õÁõ¬è‚ èEŠªð£PJ™ GÁM Þò‚è º®»‹.
Þˆî° ð‡¬ð«ò ‘ªðò˜¾ˆ Fø¡’ â¡A«ø£‹. C-ªñ£N ð™«õÁ
ð†ì ªêòŸ°Pè¬÷»‹ (Operators) è†ì¬÷è¬÷»‹ (Commands)
ªè£‡´œ÷¶. Þò‚è º¬ø¬ñèœ (Operating Systems), Gó™ ªðò˜ŠH
èœ (Compilers), à¬ó„ ªêòLèœ (Text Processors), îó¾ˆî÷ «ñô£‡
º¬ø¬ñèœ (Database Management Systems) «ð£¡ø ðô Mîñ£ù
º¬ø¬ñ ªñ¡ªð£¼œè¬÷ C-ªñ£NJ™ à¼õ£‚è º®»‹. ܶ
ñ†´I¡P ðò¡ð£†´ ªñ¡ªð£¼œè¬÷ (Application Software) à¼
õ£‚°õ‹ C-ªñ£N I辋 ãŸø¶.
C-ªñ£Nò£ù¶ W›‚裵‹ Ü®Šð¬ì õ¬è àÁŠ¹è÷£™
Ýù¶:
® ñ£PLèœ (Constants)
® °PŠªðò˜èœ (Identifiers)
® GÁˆîŸ°Pèœ (Punctuation)
® CøŠ¹„ ªê£Ÿèœ (Keywords)
225
މî àÁŠ¹èœ ܬùˆ¬î»‹ «ê˜ˆ¶ ªñ£ˆîñ£è M™¬ôèœ
(tokens) â¡A«ø£‹. Gó™ªðò˜ŠHò£ù¶ «ñ½‹ CPò àÁŠ¹
è÷£è‚ Ãø£‚è º®ò£î, Íô GóL¡ à¬óŠð°F«ò M™¬ô
âùŠð´Aø¶.
number = number + 1;

â¡Â‹ ߬ø ⴈ¶‚ ªè£œÀƒèœ. ÞF½œ÷ M™¬ôèœ õ¼


ñ£Á:
number - °PŠªðò˜ (ñ£P)
= - ªêòŸ°P
+ - ªêòŸ°P
1 - ñ£PL
; - GÁˆîŸ°P
Ýè, «ñŸè‡ì ßÁ, °PŠªðò˜, ñ£PL, ªêòŸ°P «ð£¡ø
M™¬ôèO¡ ªî£°Šð£°‹. C-ªñ£N Góô£‚èˆF™ if, while, for «ð£¡ø
ªê£Ÿè¬÷„ CøŠ¹„ ªê£Ÿèœ â¡A«ø£‹. ÜõŸ¬ø‚ °PŠH†ì
ðò¡ð£´èÀ‚° ñ†´«ñ ðò¡ð´ˆF‚ ªè£œ÷º®»‹. Þ‰îŠ ð£ìˆ
F™ H¡ù£™ õ¼‹ ð°FJ™ CøŠ¹„ ªê£Ÿè¬÷Š ðŸPŠ ð®Š
«ð£‹.
4.2.1 ñ£PLèœ (Constants)
ñ£PL â¡ð¶ â‡õ¬èò£è Þ¼‚èô£‹. ܙô¶ â‡õ¬è
ܙô£îî£è¾‹ Þ¼‚躮»‹. æ˜ â‡í£è«õ£, æ˜ â¿ˆî£
è«õ£, æ˜ â¿ˆ¶„ êóñ£è«õ£ Þ¼‚èô£‹. ñ£PL¬ò å¼ GóL™
îó¾ ñFŠð£èŠ ðò¡ð´ˆF‚ªè£œ÷ º®»‹. ñ£PL â¡Aø ªðò
¼‚«èŸð, å¼ º¬ø õ¬óòÁ‚èŠð†ì ñFŠ¬ð ñ£ŸPò¬ñ‚è
º®ò£¶. ñ£PL â¡ð¶ ñ£Ÿø º®ò£î¶. â‡õ¬èˆ îó¾ ªð¼‹
𣽋 â‡è÷£™ Ýù¶. ðF¡ñŠ ¹œO (decimal point) Þ싪ðø
ô£‹. â‡õ¬è ܙô£î îó¾ â¡ð¶ â‡èœ, ⿈¶èœ, Þì
ªõOèœ, º¬ø¬ñ ãŸA¡ø «õªø‰î CøŠ¹‚ °Pè¬÷»‹ ªè£‡
®¼‚èô£‹. «õÁ õ¬èJ™ ªê£™õªîQ™ ⿈ªî‡ (alphanu-
meric) °Pf´è¬÷‚ ªè£‡®¼‚°‹. ޚõ¬èˆ îó¬õ ñFŠ¹¼
(literal) âù¾‹ Ãøô£‹. ñ£PLèœ å¼ îóMùˆ¬î»‹, å¼ ñFŠ¬ð
»‹ à혈F GŸA¡øù. â‡õ¬è ñ£PL Íõ¬èŠð´‹:
226
® ººâ‡ ñ£PL (Integer Constant)
® Iî¬õŠ ¹œO ñ£PL (Floating - point constant)
® °P»¼ ñ£PL (Character constant)
C-ªñ£NJ¡ Ü®Šð¬ìˆ îóMùƒèœ ðŸP ފð£ìˆF¡ HŸ
ð°FJ™ 𮊫ð£‹.
4.2.1.1 º¿â‡ ñ£PL (Interger Constant)
º¿â‡ ñ£PL å¼ ðF¡ñ ⇠(Ü®ªò‡ 10) Ý°‹.
ªî£¬è ñFŠ¬ð‚ °P‚°‹ º¿ ⇠ݰ‹. 0 ºî™ 9 õ¬óJ
ô£ù Þô‚èƒè÷£™ Ýù¶. å¼ º¿â‡ ñ£PL 0x ܙô¶ 0X
âùˆ ªî£ìƒAù£™ ܶ å¼ ðFùÁñ (Ü®ªò‡ 16) ñ£PL
Ý°‹. 0 âùˆ ªî£ìƒAù£™ â‡ñ (Ü®ªò‡ 8) ñ£PL Ý°‹.
ޚõ£ªø™ô£‹ ޙ¬ôªòQ™ ðF¡ñ ⇠⡫ø ªè£œ÷Š
ð´‹.
23, 36, 48 ÝAò¬õ ðF¡ñ (decimal) ñ£PLèœ
0 x1C, 0XAB, 0x23 ÝAò¬õ ðFùÁñ (hexadecimal) ñ£PLèœ
071,023, 035 ÝAò¬õ â‡ñ (octal) ñ£PLèœ
º¿â‡ ñ£PLè¬÷Š ªð£Áˆîõ¬ó èNˆî™ °P»ì¡ ޙ¬ô
ªòQ™ «ï˜ñ⇠(Positive) Ýè«õ ªè£œ÷Šð´‹. -18 â¡ð¶‹
ãŸèˆî° º¿â‡ ñ£PL«ò. 2,345 â¡Â‹ ñ£PL, 㟹¬ìò¶
Ü¡Á. è£óí‹ Þ‰î â‡E™ CøŠ¹‚ °P (裟¹œO) Þì‹ ªðŸ
Áœ÷¶.
4.2.1.2 Iî¬õŠ ¹œO ñ£PL (Floating Point Constant)
Iî¬õŠ ¹œO ñ£PL â¡ð¶ å¼ °PJ†ì ªñŒ ⇠(signed
Ý°‹. ޚõ¬è â‡, º¿â‡ ð°F, ðF¡ñŠ ¹œO
real number)
èœ, H¡ùŠ ð°F, Ü´‚ªè‡ ð°F ÝAòõŸ¬ø‚ ªè£‡®¼‚
°‹. å¼ Iî¬õŠ ¹œO ñ£PL¬ò‚ °PŠH´‹«ð£¶, ðF¡ñŠ
¹œO‚° º‰¬îò Þô‚èƒèœ (º¿â‡ ð°F) ܙô¶ ðF¡ñŠ
¹œO‚° Ü´ˆF¼‚°‹ Þô‚èƒèœ (H¡ùŠð°F) ޙô£ñ™ Þ¼‚
èô£‹. Ýù£™ Þ󇴫ñ ޙô£ñ™ Þ¼‚è º®ò£¶. Ü´‚ªè‡
ð°F «ê˜‚èŠð´ñ£J¡ ðF¡ñŠ ¹œO¬ò M†´Mìô£‹. Ü´‚
ªè‡ ð°F, ðF¡ñ ⇠ܬñŠH™ 10-Þ¡ Ü´‚°è¬÷‚ ªè£‡
®¼‚°‹.
227
ⴈ¶‚裆´:
58.64 â¡ð¶ å¼ Iî¬õŠ ¹œO ªñŒªò‡ ñ£PL Ý°‹.
Þî¬ù Ü´‚ªè‡ º¬øJ™ ޚõ£ªø™ô£‹ â¿îô£‹:
5.864E1 => 5.864 X 101 => 58.64
5864E-2 => 5864 X 10-2 => 58.64
0.5864e2 => 0.5864 X 102 => 58.64

E ܙô¶ e â¡Â‹ ⿈¶èœ, Iî¬õŠ ¹œO ñ£PL Ü´‚


ªè‡ (exponent) õ®M™ àœ÷¬î à혈¶Aø¶.
4.2.1.3 °P»¼ ñ£PL (Character Constant)
‘°P»¼’ (Character) â¡ð¶ ÜèóõK¬ê ⿈¶èœ, â‡èœ,
èEŠªð£P º¬ø¬ñ ¬èò£À‹ Hø CøŠ¹‚ °Pf´èœ ÝAò
õŸ¬ø àœ÷ì‚Aò‹. «ñŸè‡ì °P»¼‚èO¡ ªî£°F¬ò
èEŠªð£P º¬ø¬ñJ¡ °P»¼ˆ ªî£°F (Character Set) â¡A«ø£‹.
ވªî£°FJ½œ÷ å¼ °P»¼¬õ 埬ø «ñŸ«è£œ°PèÀ‚°œ
ܬñˆî£™ ܶ å¼ °P»¼ ñ£PL¬ò‚ °P‚°‹. C-ªñ£NJ™
ðò¡ð´ˆîŠð´‹ °P»¼‚è¬÷ Í¡Á HK¾èO™ õ¬èŠð´ˆîô£‹.
® ⿈¶ õ¬è‚ °P»¼‚èœ: a,b,c,.........., z, A,B,C,...........,Z
® â‡õ¬è‚ °P»¼‚èœ: 0 ºî™ 9 õ¬ó
® CøŠ¹‚ °P»¼‚èœ: +,-, * / % # = , .’ ” ( ) [ ] ; : ?
ⴈ¶‚裆´:
‘1’, ‘a’, ‘+’, ‘-’ ÝAò¬õ 㟹¬ìò °P»¼ ñ£PLèœ Ý°‹.
å¼ °P»¼ ñ£PL¬ò‚ °PŠHì Þó‡´ åŸ¬ø «ñŸ«è£œ
°Pè¬÷Š ðò¡ð´ˆ¶A«ø£‹. ܊ð®ªòQ™, 埬ø «ñŸ«è£œ
°P¬ò âŠð® å¼ °P»¼ ñ£PLò£è‚ °PŠH´õ¶? 埬ø
«ñŸ«è£œ °P¬ò Þó‡´ åŸ¬ø «ñŸ«è£œ °PèÀ‚°œ ܬñˆ¶
’’’ âù ⿶õ¶ ãŸÁ‚ ªè£œ÷Šð죶.
埬ø «ñŸ«è£œ °P¬ò å¼ °P»¼ ñ£PLò£è‚ °PŠHì
M´ð´ õK¬ê¬òŠ (escape sequence) ðò¡ð´ˆîô£‹. H¡ê£Œ¾
«è£†¬ì Ü´ˆ¶ æ˜ â¿ˆ¶ «ê˜‰î °P»¼„ «ê˜ñ£ùƒè¬÷
‘M´ð´ õK¬ê蜒 â¡A«ø£‹.
’ \’’ â¡ð¶ 㟹¬ìò 埬ø «ñŸ«è£œ °P»¼ ñ£PL.

228
Ü«î«ð£ô, M´ð´ õK¬ê¬òŠ ðò¡ð´ˆF, Cô ܄CìMò
ô£î °P»¼‚è¬÷‚ °PŠHìô£‹.
ⴈ¶‚裆´èœ:
‘\a’ ñE (Beep)
‘\b’ H¡QìªõO (Back Space)
‘\f’ ð®õ„ ªê½ˆ¶¬è (Form Feed)
‘\r’ ªê½ˆF F¼Šð™ (Carriage Return)
‘\n’ ¹Fò õK (New Line)
‘\0’ Þ¡ñ‚ °P»¼ (null character)
H¡ê£Œ¾‚ «è£†¬ì«ò å¼ °P»¼ ñ£PLò£è‚ °PŠHì,
Þó‡´ H¡ê£Œ¾‚ «è£´è¬÷Š (‘\\’) ðò¡ð´ˆî «õ‡´‹.
4.2.1.4 êó G¬ô»¼ (String literal)
êó G¬ô»¼ ܙô¶ êó ñ£PL â¡ð¶, º¬ø¬ñJ¡ °P»¼ˆ
ªî£°FJ½œ÷ °P»¼‚èO¡ êóˆ¬î Þó†¬ì «ñŸ«è£œ
°PèÀ‚°œ î¼õ‹. º¡Qò™ð£è (by default), Þ¡ñ‚ °P»¼
(‘\0’) êó G¬ô»¼M¡ ÞÁF‚ °P»¼õ£è„ «ê˜ˆ¶‚ ªè£œ÷Šð´‹.
å¼ êó ñ£PLJ¡ ð°Fò£è Þó†¬ì «ñŸ«è£œ °P»‹ Þ싪ðø
«õ‡´ªñQ™ M´ð´ M¬ê¬òŠ (‘\”’) ðò¡ð´ˆî «õ‡´‹.
â¡ð¶ 㟹¬ìò êó G¬ô»¼. Þ‰î„ êó G¬ô»¼M™
“hello”
àœ÷ ⿈¶èO¡ êKò£ù â‡E‚¬è, ÞÁFJ™ àœ÷ Þ¡ñ‚
°P»¼¬õ»‹ «ê˜ˆ¶ 6 Ý°‹. Þ¡ñ‚ °P»¼ è‡E™ ¹ôŠ
ð죶. G¬ùõèˆF™ Þ‰î„ êóˆ¬î Þ¼ˆF¬õ‚è ÝÁ ¬ð†´èœ
«î¬õ. â¡ø£½‹ ބêóˆF¡ c÷‹ (length) â¡ð¶ 5 ⿈¶è«÷
Ý°‹.
4.2.2. °PŠªðò˜èœ (Identifiers)
å¼ GóL™ àœ÷ ñ£Pèœ (Variables), ªêò™ÃÁèœ (functions),
îóMùƒèœ (data types), C†¬ìèœ (labels) ÝAòõŸ¬ø‚ °P‚°‹
ªðò˜èœ °PŠªðò˜èœ âùŠð´A¡øù. å¼ ñ£PJ¡ ªðò˜ ⿈¶
èœ, â‡è¬÷‚ ªè£‡®¼‚èô£‹. Hø °P»¼‚èœ Þ싪ðø‚
Ã죶. ñ£PJ¡ ªðòK™ Ü®‚WÁ (underscore) ñ†´‹ Þì‹ ªðøô£‹.
°¬ø‰î Ü÷¾ æªó¿ˆ¶. ÜFè Ü÷õ£è 32 ⿈¶èœ Þ싪ðø
ô£‹. ºî™ ⿈¶, Üèó õK¬ê ⿈î£èˆî£¡ (alphabet) Þ¼‚è
«õ‡´‹. â‡èœ Þ싪ðø‚ Ã죶. 㟹¬ìò ñ£PŠ ªðò˜èœ:
229
x
length
x_value
y_value
a123

C-ªñ£NJ¡ CøŠ¹„ ªê£Ÿè¬÷ (è†ì¬÷„ ªê£Ÿèœ) °PŠ


ªðò˜è÷£èŠ ðò¡ð´ˆî‚ Ã죶. W›‚裵‹ ªðò˜èœ ñ£PJ¡
ªðò˜è÷£è ãŸè Þòô£î¬õ. ÜîŸè£ù è£óí‹ îóŠð†´œ÷¶.
123 - ºî™ °P»¼ â‡í£°‹.
1abc - ºî™ °P»¼ â‡í£°‹.
x value - ªðòK™ ÞìªõO (space) àœ÷¶.
x &y - ãŸèMòô£î CøŠ¹‚ °P»¼ (&) Þì‹
ªðŸÁœ÷¶.
for - C-ªñ£NJ¡ CøŠ¹„ ªê£™
4.2.3 Ü®Šð¬ìˆ îóMùƒèœ (Fundamental Data Types)
Góô£‚èˆF™ ÜFèñ£èŠ «ðêŠð´‹ ªê£ŸèÀœ ‘îó¾’ â¡ð
¶‹ å¡Á. èEŠªð£P‚° àœkì£èˆ îóŠð´‹ ªêòô£‚è‹ ªðø£î
îèõ«ô, ‘îó¾’ âù õ¬óòÁ‚èŠð´Aø¶. C-ªñ£NJ™ ‘îó¾’
â¡ð¶ ð™«õÁ Þùñ£è õ¬èŠð´ˆîŠð†´œ÷¶. â‡õ¬èˆ îó¾
èœ int, float, char âù Í¡Á Þùƒè÷£èŠ HK‚èŠð†´œ÷ù. Þ¬õ
Ü®Šð¬ìˆ îóMùƒèœ ܙô¶ ºîQ¬ôˆ îóMùƒèœ â¡Á
ܬö‚èŠð´A¡øù. C-ªñ£NJ™ Þ¬õ º¡ õ¬óòÁ‚èŠð†-
ì¬õ (pre-defined). ÞõŸ¬ø C-Gó™ªðò˜ŠH (C-Compiler) ܬìò£÷‹
致ªè£œÀ‹; ÞõŸP¡ ñFŠ¹è¬÷„ ªêò™ð£´èO™ ðò¡
ð´ˆF‚ ªè£œÀ‹. âù«õ ވîóMùƒè¬÷ Íôˆ îóMùƒèœ
(primitive data types) â¡Á‹ ܬöŠð¶‡´.

«ñŸè‡ì îóMùƒèO™ ñ£Pè¬÷ ÜPM‚°‹ º¬ø:


int x;
float f;
char ch;

ÞõŸÁœ int â¡ð¶ º¿â‡¬í»‹ (Interger), float â¡ð¶ ªñŒ


(real)â‡¬í»‹, char â¡ð¶ 埬ø‚ °P»¼¬õ»‹ °P‚A¡øù.
230
ⴈ¶‚裆´:
1 º¿ ⇠(int)
1.0 ªñŒªò‡ (float)
‘1’ °P»¼ ñ£PL (char constant)
“1” êó G¬ô»¼ (string literal)
C-ªñ£NJ™ ‘êó‹’ (string) âùˆ îQò£ù îóMù‹ ޙ¬ô.
âQ‹ êó G¬ô»¼¾ì¡ ªî£ì˜¹¬ìò îóMù‹ char * (°P»¼„
²†´- character pointer) Ý°‹. Þ¬îŠ ðŸPò M÷‚è‹, ފð£ìˆF™
‘ÜE蜒 (Arrays) ðŸPò ð°FJ™ îóŠð†´œ÷¶.
int ñFŠ¬ð G¬ùõèˆF™ Þ¼ˆF¬õ‚è 2 ¬ð†´èœ «î¬õ.
float ñFŠ¹‚° 4 ¬ð†´èÀ‹, char ñFŠ¹‚° 1 ¬ð†´‹ «î¬õ.

4.2.3.1 î¼M‚èŠð†ì îóMùƒèœ (Derived Data Types)


long, double, unsigned ñŸÁ‹ ÜEèœ(Arrays), ²†´èœ(Pointers) ÝA
ò¬õ Íôˆ îóMùƒèOL¼‰¶ î¼M‚èŠð†ì îóMùƒèœ Ý°‹.
long â¡ð¶ int L¼‰¶‹, double â¡ð¶ float- L¼‰¶‹ î¼M‚èŠð†
ì¬õ. long int ñ£P¬ò ÜPM‚°‹ º¬ø:
long int i ;

ܙô¶
long i;
longÞù ñFŠ¬ð G¬ùõèˆF™ Þ¼ˆî, 4 ¬ð†´èœ «î¬õ.
ªñŒªò‡è¬÷ (real ) I辋 ¶™Lòñ£è‚ ¬èò£÷ «õ‡´ªñQ™
double Þùˆ¬îŠ ðò¡ð´ˆî «õ‡´‹. Þ¶ G¬ùõèˆF™ 8 ¬ð†´
è¬÷ ⴈ¶‚ªè£œÀ‹.
unsigned int â¡ð¶ int Þùˆ¬îŠ «ð£ô«õ 2 ¬ð†´è¬÷«ò
ⴈ¶‚ ªè£œÀ‹. Ýù£™ ÜF½œ÷ ܬùˆ¶ H†´èÀ‹ ñFŠ
H¬ù Þ¼ˆîŠ ðò¡ð´ˆF‚ ªè£œ÷Šð´‹. Ýù£™ ê£î£óí int
ñFŠH™, àò˜ñFŠ¹ H† (Þì¶ æó H†) «ï˜ñ (positive) ܙô¶
âF˜ñ (negative) ⇠â¡ð¬î‚ °P‚°‹ °P (sign) H† Ý°‹. int- ¡
ñFŠ¹ - 32768 ºî™ +32767 õ¬ó. unsigned int- ¡ ñFŠ¹ 0 ºî™
65535 õ¬ó. Þ¶«ð£ô«õ unsigned long, unsigned char ÝAò îó
MùƒèÀ‹ àœ÷ù.

231
4.2.3.2. ²†´ ñ£Pèœ (Pointer Variables)
C-ªñ£NJ¡ ñ£Pè¬÷ ê£î£óí ñ£Pèœ (ordinary variables), ²†´
ñ£Pèœ (pointer variables) âù õ¬èŠð´ˆîô£‹. ê£î£óí ñ£P ܶ
ªî£ì˜¹¬ìò ÞùˆF¡ ñFŠ¹è¬÷ ⴈ¶‚ªè£œÀ‹.
ⴈ¶‚裆´:
int x;
ރ«è, x â¡ð¶, int ÞùˆF™ å¼ ê£î£óí ñ£P; º¿ ⇬í
Üî¡ ñFŠð£è ãŸÁ‚ªè£œÀ‹.
x = 10;
²†´ ñ£P ÜPM‚èŠð´‹ º¬ø:
int *y ;
«ñŸè‡ì ÜPMŠH™ y â¡ð¶ ²†´ ñ£P. Þî¡ Þù‹ -
º¿â‡ ²†´ (int *).
²†´ ñ£P ⊫𣶋 å¼ ºèõK¬ò«ò ñFŠð£è 㟰‹.
ªð£¶õ£è, 嚪õ£¼ ñ£P»‹, ܶ ꣘‰î Þùˆ¶‚° ãŸð, G¬ù
õèˆF™ Þì‹H®ˆ¶‚ ªè£œAø¶. ºî¡¬ñ G¬ùõèˆF½œ÷ åš
«õ£˜ Þ¼ŠH숬 Üî¡ ºèõK Íô‹ Üµè º®»‹.
«ñŸè‡ì ⴈ¶‚裆®™ x â¡ð¶ ê£î£óí ñ£P, y â¡ð¶
²†´ ñ£P. x â¡ð¶ å¼ ê£î£óí º¿â‡, y â¡ð¶ å¼ º¿ â‡
µ‚è£ù ²†´. âù«õ, x Þ¡ ºèõK¬ò y -™ Þ¼ˆî º®»‹.
y = &x;
²†´è¬÷Š ªð£Áˆîõ¬ó Þó‡«ì Þó‡´ ªêòŸ°Pè«÷
àœ÷ù. å¡Á ºèõK ²†´ (address of -&) ªêòŸ°P. ñŸªø£¡Á
àœ«ï£‚° (indirection-*) ªêòŸ°P. Þ󇴫ñ å¼ñ„ ªêòŸ°Pèœ
(unary operators). å«óªò£¼ ñ£PJ¡ e¶ ñ†´«ñ ªêò™ð´ð¬õ.
å¼ñ„ ªêòŸ°Pèœ ðŸP Ü´ˆî ð°FJ™ 𮊫ð£‹.
x å¼ º¿â‡ â¡ð, G¬ùõèˆF™ Þó‡´ ¬ð†´è¬÷
ⴈ¶‚ ªè£œÀ‹. Üî¡ ºèõKè¬÷ W«ö àœ÷õ£Á ðìñ£è
à¼õA‚èô£‹: 948 949

X
232
x-¡ ºèõK 948 â¡ð¬îŠ ðìˆF™ 裇è. ºî¡¬ñ G¬ù
õèˆF™ 嚪õ£¼ ¬ð†¬ì»‹ Üî¡ ºèõK Íô‹ Üµè º®
»‹. G¬ùõèˆF™ å¼ ñ£P Þ¼‚°‹ ÞìˆF¡ ºèõK¬ò ÜPò
ºèõK ²†´ (address of - &) ªêòŸ°P¬òŠ ðò¡ð´ˆî «õ‡´‹.
y = &x;
â¡ø ßP™, x- ¡ ºèõK y â¡Â‹ ²†´ ñ£PJ™ ðF¾ ªêŒòŠ
ð†´œ÷¶. y ²†´ ñ£P â¡ð, ܶ ºèõK ñFŠ¬ð ñ†´«ñ
㟰‹ â¡ðîP«õ£‹. “y, x- ä„ ²†´Aø¶” âù„ ªê£™ôô£‹. Þî¬ù
ޚõ£Á à¼õA‚èô£‹:
948 949

Y X
x-¡ ñFŠ¹ 10 â¡è. x- ¡ ñFŠ¬ð y â¡Â‹ ²†´ ñ£PJ¡
Íôñ£èŠ (ãªùQ™, y, x - ä„ ²†´Aø¶ ܙôõ£?) ªðø º®»‹.
Ü, “àœ«ï£‚°” (indirection - *) ªêòŸ°P¬òŠ ðò¡ð´ˆî «õ‡
´‹. Üî£õ¶, *y â¡ð¶, y- ݙ ²†ìŠð´‹ ºèõKJ™ Þ¼ˆF
¬õ‚èŠð†´œ÷ ñFŠ¬ðŠ ªðŸÁˆî¼‹. âù«õ, x- ¡ ñFŠ¹ 10,
²†´ñ£P y, x -ä„ ²†´Aø¶ âQ™, * y - ¡ ñFŠ¹ 10 Ý°‹.
«ñŸè‡ì ⴈ¶‚裆®™ cƒèœ G¬ùM™ ªè£œ÷ «õ‡®
ò¬õ:
y, x â¡ø ñ£PJ¡ ºèõK¬ò‚ ªè£‡´œ÷¶ (&x)
*y, x â¡ø ñ£PJ¡ ñFŠ¬ð‚ ªè£‡´œ÷¶ (x)
ºèõK ²†´ (address of - &), àœ«ï£‚° (indirection -*) ªêòŸ°P
èœ Þ󇴫ñ å¼ñ„ ªêòŸ°Pèœ â¡ð¬î G¬ùM™ ªè£œè.
4.2.4 ªêòŸ°Pèœ (Operators)
C-ªñ£N õ÷ñ£ù ªêòŸ°Pè¬÷‚ ªè£‡´œ÷¶. ªêòŸ°P
èœ ªêò™è¬÷ G蛈¶A¡øù. “G¬ø«õŸøŠðì «õ‡®ò å¼
ªêò™ð£†¬ì (operaton) °P‚A¡ø å¼ °Pf´ (symbol)” âù ªêòŸ
°P¬ò (operator) õ¬óòÁ‚èô£‹. ⡪ù¡ù ðEè¬÷„ ªêŒò
«õ‡´‹, ÜõŸ¬ø â‰î õK¬êJ™ ªêŒò«õ‡´‹ â¡ð¬î„
233
ªêòŸ°Pèœ èEŠªð£P‚° à혈¶A¡øù. ªêò™ð£´èœ G¬ø
«õŸøŠð´A¡ø õK¬êº¬ø ‘º¡ÂK¬ñ õK¬ê’ (order of prece-
dence) â¡Á ܬö‚èŠð´A¡øù. ð®ñó¹ (hierarchy) â¡Á‹ ܬö‚
èŠð´‹. ªêò™ð£´èœ G¬ø«õŸøŠð´‹ F¬êºè‹ (ÞìI¼‰¶
õô‹ ܙô¶ õôI¼‰¶ Þì‹`) ªî£ì˜¹Áˆî‹ (associatirity), âùŠ
ð´Aø¶. C-ªñ£NJ™ Íõ¬è„ ªêòŸ°Pèœ àœ÷ù:
® å¼ñ„ ªêòŸ°Pèœ (Unary operators)
® Þ¼ñ„ ªêòŸ°Pèœ (Binary operators)
® º‹ñ„ ªêòŸ°P (Ternary operators)
4.2.4.1 å¼ñ„ ªêòŸ°Pèœ (Unary operators)
å¼ñ„ ªêòŸ°Pèœ º¡ÂK¬ñ õK¬êJ™ ºî™G¬ôJ™
àœ÷ù. Þ¬õ å«óªò£¼ ªêò«ôŸH¬ò‚ (operand) ªè£‡´œ÷ù.
èEŠH´‹ F¬êºè‹ (associativity) õôI¼‰¶ Þìñ£°‹. å¼ñ„
ªêòŸ°PèO¡ ð†®ò¬ô»‹ ÜõŸP¡ ðEè¬÷»‹ ܆ìõ¬í
4.1-™ 裇è:
܆ìõ¬í 4.1 å¼ñ„ ªêòŸ°Pèœ

°Pf´ ªêò™ð£†®¡ õ¬è F¬êºè‹


++ I°Š¹ (increment)
-- °¬øŠ¹ (decrement) õôI¼‰¶ Þì‹
* àœ«ï£‚è™(indirection)
& ºèõK²†ì™ (address of)
! âF˜ñ¬ø (logical NOT)

I°Š¹, °¬øŠ¹ ªêòŸ°Pèœ º¬ø«ò å¼ ñ£PJ¡ ð£


¬îò ñFŠH™ å¡Á Æ쾋, å¡Á °¬ø‚辋 ðò¡ð´ˆîŠ
ð´A¡øù. å¼ñ„ ªêòŸ°Pèœ ªð£¶õ£è ñ£P‚° º¡ð£è Þì‹
ªðÁA¡øù. ⴈ¶‚裆ì£è, x â¡Â‹ int ñ£PJ¡ ºèõK¬ò
ÜPò, &x âùŠ ðò¡ð´ˆ¶A«ø£‹. Ýù£™, I°Š¹, °¬øŠ¹ ªêòŸ
°Pè¬÷Š ªð£Áˆîõ¬ó ªêò«ôŸHJ¡ (ñ£PJ¡) º¡ù£™ ܙ
ô¶ H¡ù£™ Þì‹ ªðøº®»‹.
234
âù«õ, I°Š¹, °¬øŠH™ Þó‡´ õ®õƒèœ àœ÷ù:
® H¡ªù£†´ (postfix) I°Š¹ ܙô¶ °¬øŠ¹
® º¡ªù£†´ (prefix) I°Š¹ ܙô¶ °¬øŠ¹
ÝAò å¼ñ„ ªêòŸ°Pèœ ªêò«ôŸHJ¡ (ñ£PJ¡)
++, --
º¡ù£™ Þ싪ðÁñ£J¡, º¬ø«ò ‘º¡ªù£†´ I°Š¹’ ܙô¶
‘º¡ªù£†´‚ °¬øŠ¹’ â¡Á ܬö‚èŠð´A¡øù. ܬõ ªêò
«ôŸH¬ò Ü´ˆ¶ Þ싪ðÁñ£J¡, º¬ø«ò ‘H¡ªù£†´ I°Š¹’
ܙô¶ ‘H¡ªù£†´‚ °¬øŠ¹’ â¡Á ܬö‚èŠð´A¡øù. ÞõŸ
P¡ ðò¡ð£´èœðŸP ފð£ìˆF¡ HŸð°FJ™ 𮊫ð£‹.
4.2.4.2 Þ¼ñ„ ªêòŸ°Pèœ Binary Operators)
èí‚W†´„ ªêòŸ°Pèœ (Arithmatic operators)
+, -, *, /, % ÝAò èí‚W†´„ ªêòŸ°Pèœ Þó‡´ ªêò
«ôŸ Hèœ e¶ ªêò™ð´‹ â¡ð Þ¬õ Þ¼ñ„ ªêòŸ°Pèœ
â¡Á ܬö‚èŠð´A¡øù. èí‚W†´„ ªêòŸ°PèO¡ ð†®ò¬ô
܆ìõ¬í 4.2-™ 裇è. ܬùˆ¶ èí‚W†´„ ªêòŸ°PèO¡
F¬êºè‹ ÞìI¼‰¶ õô‹ Ý°‹.
܆ìõ¬í 4.2 èí‚W†´„ ªêòŸ°Pèœ

°Pf´ ªêò™ð£†´ õ¬è F¬êºè‹

+ Ã†ì™ (Addition)
- èNˆî™ (Subtraction)
* ªð¼‚è™ (Multiplication) ÞìI¼‰¶ õô‹
/ õ°ˆî™ (Division)
% õ°eF (Modulus)

èí‚W†´„ ªêòŸ°Pè¬÷ º¿â‡ (int) ñŸÁ‹ Iî¬õ (float)


ñFŠ¹À‚°Š ðò¡ð´ˆî º®»‹. õ°eF (modulus) ªêòŸ°P º¿
⇠ñFŠ¹èO™ ñ†´«ñ ªêò™ð´‹. õ°ˆîH¡ õ¼‹ eF¬ò
M¬ìò£èˆ . º¿â‡ õ°ˆîL¡ ß¾ º¿â‡í£è«õ Þ¼‚
°‹. H¡ùŠ ð°F ¹ø‚èE‚èŠð´‹.

235
ⴈ¶‚裆´:
5 / 2 = 2 (H¡ùŠ ð°F ¹ø‚èE‚èŠð†´œ÷¶)
5 % 2 = 1 (õ°ˆîH¡ õ¼‹ eF)
º¿â‡è¬÷Š ªð£Áˆîõ¬ó, õ°ˆî™ ªêòŸ°P, õ°ˆîH¡
õ¼‹ ßM¬ù M¬ìò£èˆ . õ°eF ªêòŸ°P, õ°ˆîH¡
õ¼‹ eF¬ò M¬ìò£èˆ . õ°ˆî™, ªð¼‚è™, õ°eF ªêòŸ
°Pèœ, Ã†ì™ ñŸÁ‹ èNˆî™ ªêòŸ°Pè¬÷‚ 裆®½‹ àò˜
º¡ÂK¬ñ ªðŸø¬õ.
°PŠ¹: * °Pf´, ªð¼‚轂è£ù Þ¼ñ„ ªêòŸ°Pò£è
¾‹, ²†´ ñ£PèO¡ å¼ñ„ ªêòŸ°Pò£è¾‹ (àœ
« ï £ ‚ è ™ - indirection) ðò¡ð´ˆîŠð´Aø¶. * °Pf´ ðò¡
ð´ˆîŠð´‹ Åö¬ôŠ ªð£Áˆ¶ Üî¡ ªêò™ð£´ ܬñ
»‹.
4.2.4.3 åŠd†´„ ªêòŸ°Pèœ (Relational Operators)
åŠd†´ ܙô¶ ÌLò¡ ªêòŸ°Pèœ âŠ«ð£¶«ñ Þó‡´
ªêò«ôŸHèO¡ e¶ ªêò™ð´õ ܬõ Þ¼ñ„ ªêòŸ°P
è÷£è«õ è¼îŠð´A¡øù. å«óªò£¼ MFMô‚° ! â¡Â‹ ÌL
ò¡ ªêòŸ°P (âF˜ñ¬ø„ ªêòŸ°P â¡Á‹ ܬö‚èŠð´‹) å¼ñ„
ªêòŸ°P Ý°‹. Üî£õ¶, å«óªò£¼ ªêò«ôŸHJ¡ e«î ªêò™
ð´‹. ܆ìõ¬í 4.3-™ åŠd†´„ ªêòŸ°PèO¡ ð†®ò¬ô‚
裇è. ܬùˆ¶ åŠd†´„ ªêòŸ°PèO¡ F¬êºè‹ ÞìI¼‰¶
õôñ£°‹. Üî£õ¶, å¡Á‚° «ñŸð†ì ªêòŸ°Pèœ å¼ èí‚
W†´‚ «è£¬õJ™ Þ싪ðŸP¼‚°ñ£J¡ ÞìI¼‰¶ õôñ£è åš
ªõ£¡ø£è„ ªêò™ð´ˆîŠð´‹.
܆ìõ¬í 4.3 åŠd†´„ ªêòŸ°Pèœ
°Pf´ ªêò™ð£†´ õ¬è F¬êºè‹
== Gèó£ù (equla to)
< Mì„ CPò (less than)
> MìŠ ªðKò (greater than) ÞìI¼‰¶ õô‹
<= Mì„ CPò ܙô¶ Gèó£ù
(less than or equal to)
>= MìŠ ªðKò ܙô¶ Gèó£ù
(greater than or equal to)
!= Gè˜ Ü™ô£î (not equal to)
236
åŠd†´„ ªêòŸ°Pèœ Þó‡´ ñFŠ¹è¬÷ (àÁŠ¹è¬÷) åŠ
H†´ M¬ì ÜPòŠ ðò¡ð´ˆîŠð´A¡øù. M¬ì, êK (True), îõÁ
(False) ÝAò Þ󇮙 å¡ø£è Þ¼‚°‹. &&, || ÝAò è„
ªêòŸ°Pèœ, Þó‡´ Ü™ô¶ Ü «ñŸð†ì åŠd†´‚ «è£¬õ
è¬÷ Þ¬í‚èŠ ðò¡ð´ˆîŠð´A¡øù. && ªêòŸ°P, “è
à‹” (logical AND) ªêòŸ°P Ý°‹. Þ‰î„ ªêòŸ°P,  Þ¬í‚
A¡ø Þó‡´ åŠd†´‚ «è£¬õèÀ«ñ ‘êK’ âù M¬ì î¼ñ£J¡
Þ¶¾‹ ‘êK’ â¡ø M¬ì¬òˆ . Þ󇮙 å¡Á ܙô¶
Þ󇴫ñ ‘îõÁ’ âù M¬ì î¼ñ£J¡ Þ¶¾‹ ‘îõÁ’ âù M¬ì
. ‘è ܙô¶’ (logical OR) ªêòŸ°P ÞFL¼‰¶ ñ£Áð†ì¶.
 Þ¬í‚A¡ø Þó‡´ åŠd†´‚ «è£¬õèÀ«ñ ‘îõÁ’ âù
M¬ì î¼ñ£J¡ Þ¶¾‹ ‘îõÁ’ â¡ø M¬ì . Þ󇮙 å¡Á
ܙô¶ Þ󇴫ñ ‘êK’ â¡Á M¬ì î¼ñ£J¡ Þ¶¾‹ ‘êK’ â¡ø
M¬ì. åŠd†´„ ªêòŸ°Pèœ, èí‚W†´„ ªêòŸ°Pè¬÷‚
裆®½‹ °¬øõ£ù º¡ÂK¬ñ ªè£‡ì¬õ. &&, || ÝAò¬õ åŠ
d†´„ ªêòŸ°Pè¬÷ M쾋 º¡ÂK¬ñ °¬ø‰î¬õ.
ⴈ¶‚裆´:
â¡Â‹ «è£¬õ ⊫𣶫ñ ‘êK’ â¡ø M¬ì
(10<15) && (14<23)
¬ò«ò . Þ‰î‚ «è£¬õ ÞìI¼‰¶ õôñ£è ñFŠHìŠð´‹.
Þó‡´ åŠd†´‚ «è£¬õèœ, è && ªêòŸ°Pò£™ Þ¬í‚èŠ
ð†´œ÷ù. && ªêòŸ°P º¿‚«è£¬õ¬ò»‹ ñFŠH´õ º¡
ð£è, Þó‡´ åŠd†´‚ «è£¬õèÀ‹ Ü´ˆî´ˆ¶ ñFŠHìŠð´‹.
Þ¡«ù£˜ ⴈ¶‚裆¬ìŠ 𣘊«ð£‹.
(10<15) || (14<23) â¡Â‹ «è£¬õ»‹ ‘êK’ â¡ø M¬ì¬ò«ò
. è || ªêòŸ°P, Þó‡´ åŠd†´‚ «è£¬õè¬÷ Þ¬í‚
A¡øù. ‘è ܙô¶’ MFJ¡ð®, Þó‡´ åŠd†´‚ «è£¬õ
èÀ«ñ ‘êK’ âQ™, 冴ªñ£ˆî‚ «è£¬õ»‹ ‘êK’ . މî ⴈ
¶‚裆®™ ºî™ åŠd†´‚ «è£¬õ ‘êK’ â¡ð, Þó‡ì£õ¶
åŠd†´‚ «è£¬õ ñFŠHìŠð죶. Þ‰î‚ è¼ˆ¶¼¾‚°Š ªðò˜
‘°Á‚°„ ²ŸÁ ñFŠd´’ (Short Circuit Evaluation) Ý°‹.
‘è à‹’ (logical AND-&&) ªêò™ð£†®™, Þó‡´ «è£¬õ
èÀœ ºî™ «è£¬õ ‘îõÁ’ âQ™, 冴ªñ£ˆî‚ «è£¬õ»«ñ
‘îõÁ’ Ý°‹. âù«õ Þó‡ì£õ¶ «è£¬õ ñFŠHìŠð죶.

237
4.2.4.4 ñFŠH¼ˆ¶ ªêòŸ°Pèœ (Assignment Operators)
ñFŠH¼ˆ¶‹ ªêòŸ°P (=), õôŠð‚躜÷ ªêò«ôŸHJ¡
ñFŠ¬ð, ÞìŠð‚è„ ªêò«ôŸHJ™ Þ¼ˆ¶‹. C-ªñ£NJ™, +=,
-=, *=, /=, %= ÝAò èí‚A†´-ñFŠH¼ˆ¶‹ ªêòŸ°PèÀ‹
àœ÷ù.
i=i+1;

â¡Â‹ ߬ø «ï£‚°ƒèœ. ÞF™, i â¡Â‹ ñ£PJ¡ º‰¬îò


ñFŠH™ å¡Á I°‚èŠð†´, I°‚èŠð†ì ñFŠ¹, i- ¡ ¹Fò ñFŠ
ð£è Þ¼ˆîŠð´Aø¶. Þ‰î‚ ÃŸP¬ù, èí‚A†´-ñFŠH¼ˆ¶‹
ªêòŸ°PJ¡ àîM»ì¡,
i +=1 ;

â¡Á â¿îô£‹.
«ñŸè‡ì ßP™, i- ¡ ñFŠH™ å¡Á I°‚èŠð†´ ¹Fò
ñFŠ¬ð i- J«ô«ò Þ¼ˆ¶õ += ªêòŸ°P ðò¡ð´ˆîŠð†
´œ÷¶. Þ«î«ð£ô, i *= 2 ; â¡Â‹ ßP™, i - ¡ º‰¬îò ñFŠ¹
2-ݙ ªð¼‚èŠð†´, ¹Fò ñFŠ¹ i-J«ô«ò Þ¼ˆîŠð´Aø¶.
ܬùˆ¶ ªêòŸ°PèO½‹, ñFŠH¼ˆ¶‹ ªêòŸ°Pè«÷ Iè‚
°¬ø‰î º¡ÂK¬ñ ªè£‡ì¬õ.
4.2.4.5 ñFŠHì™ õK¬ê (The order of evaluation)
ªêòŸ°PèO¡ º¡ÂK¬ñ ðŸP 㟪èù«õ Mõ£Fˆ¶œ
«÷£‹. ªêòŸ°PèO¡ º¡ÂK¬ñ Ü®Šð¬ìJ™ å¼ «è£¬õ¬ò
âšõ£Á ñFŠH´õ¶ âùŠ 𣘊«ð£‹. â™ô£õŸÁ‚°‹ º¡ð£è,
H¬ø ܬ승‚°PèÀ‚°œ àœ÷ «è£¬õ ñFŠHìŠðì «õ‡
´‹.
5 * 2 + 8 + 3 ( 3 - 2 ) * 5
â¡Â‹ «è£¬õ¬ò ⴈ¶‚ªè£œ«õ£‹. Þ¶, W«ö àœ÷õ£Á
ñFŠHìŠð´‹:
5 * 2 + 8 + 1 * 5
(ܬ승‚°PèÀ‚°œ Þ¼‰î «è£¬õ ºîL™ ñFŠHìŠð†´œ÷¶)
10 + 8 + 5 (ªð¼‚è™, Æì¬ôMì º¡ÂK¬ñ ªðÁAø¶)
23 (Ã†ì™ º®‰îH¡ «è£¬õJ¡ ñFŠ¹ 23)
238
4.2.4.6 º‹ñ„ ªêòŸ°P Ternary Operator)
C-ªñ£NJ™ å¼ º‹ñ„ ªêòŸ°P àœ÷¶. Þ¶ªõ£¼ Gð‰î
¬ù„ ªêòŸ°P (Conditional Operator) Ý°‹. ބ ªêòŸ°P‚°Š ðò¡
𴋠°Pf´ ? : Ý°‹. Þ¶ Í¡Á ªêò«ôŸHè¬÷‚ ªè£‡®
¼‚°‹. Gð‰î¬ù„ ªêòŸ°PJ¡ è†ì¬÷ ܬñŠ¹:
(Gð‰î¬ù‚ «è£¬õ) ? «è£¬õ1 : «è£¬õ2 ;
Gð‰î¬ù‚ «è£¬õ ‘êK’ âQ™, «è£¬õ1 ñFŠHìŠð´‹. Gð‰-
î¬ù‚ «è£¬õ ‘îõÁ’ âQ™, «è£¬õ2 ñFŠHìŠð´‹.
ⴈ¶‚裆´:
j = ( i < 0 ) ? -i : i;

â¡ø è†ì¬÷J™ Gð‰î¬ù„ ªêòŸ°PJ¡ ðò¡ð£†¬ì «ï£‚


°ƒèœ. i-¡ ºŸÁ ñFŠ¬ð (absolute value) j- J™ Þ¼ˆ¶õ«î Þî¡
«ï£‚è‹. i- ¡ ñFŠ¹ 0-äMì„ CPªîQ™, j-J™ -i Þ¼ˆîŠð´‹.
i- J¡ ñFŠ¹ 0-¾‚° Gè˜ Ü™ô¶ 0-äMìŠ ªðKªîQ™ j- ™
i- Þ¼ˆîŠð´‹.

4.2.5 GÁˆîŸ°PèÀ‹ CøŠ¹„ ªê£ŸèÀ‹


(Punctuations and Keywords):

C-ªñ£NJ™ ðò¡ð´ˆîŠð´‹ GÁˆîŸ °PèÀ‹ ÜõŸP¡


ðò¡èÀ‹ ð†®òLìŠð´A¡øù:
[ ] - Ü EJ™ ²†´ ⇬í [index] ° P ‚ è Š ð ò ¡ ð ´ A ø ¶
[ ê¶óܬ승‚°P ].
{ } - ªêò™ÃP¡ àìŸð°F‚° õó‹HìŠ ðò¡ð´Aø¶ {ªïO¾
ܬ승‚°P }.
( ) - ªêò™Ã¬ø °PŠH쾋, àÁŠ¹è¬÷‚ °¿õ£‚辋,
«è£¬õè¬÷‚ °¿õ£‚辋 ðò¡ð´Aø¶ (ê£î£óí
ܬ승‚°Pèœ).
< > - º¡-ªêòL‚ (preprocessor) ßP™, î¬ôŠ¹‚ «è£ŠH¡
ªðò¬ó à†ð´ˆîŠ ðò¡ð´Aø¶ <«è£í ܬ승‚°Pèœ >
“ ” -êó G¬ô»¼‚è¬÷‚ °PŠHìŠ ðò¡ð´Aø¶ (Þó†¬ì
«ñŸ«è£œ).
‘ ’- 埬ø‚ °P»¼ ñ£PLè¬÷‚ °PŠHìŠ ðò¡ð´Aø¶
(埬ø «ñŸ«è£œ).
239
/* */- °PŠ¹¬ó (Comment) ܬñŠð.
; - å¼ ÃŸP¡ º®¾‚°P (ܬ󊹜O)
, - àÁŠ¹è¬÷Š HKˆ¶‚è£†ìŠ ðò¡ð´Aø¶ (裟¹œO)
ªõŸÁ, ªõ‡ ÞìªõOèœ - GóL¡ 𮊪ðO¬ñ¬ò (read
ability) «ñ‹ð´ˆîŠ (Blank, white spaces) ðò¡ð´A¡øù.

º‚Aò CøŠ¹„ ªê£ŸèO¡ ð†®ò™ W«ö îóŠð†´œ÷¶.


å¼ GóL™ ñ£PèO¡ ªðò˜è÷£è ÞõŸ¬øŠ ðò¡ð´ˆî‚ Ã죶.
auto break case char continue default do
else if float for int return static
switch while
CøŠ¹„ ªê£Ÿèœ, ð†®òL™ âšõ£Á àœ÷ù«õ£ ܚõ£«ø
¶™Lòñ£èˆ îóŠðì«õ‡´‹. ⴈ¶‚裆ì£è, auto â¡ð¶î£¡
CøŠ¹„ ªê£™. Auto, AUTO ÝAò¬õ CøŠ¹„ ªê£Ÿèœ ܙô.
4.3 ñ£FK C-Gó™
M¼‹¹A¡ø M¬ì¬òŠ ªðÁõîŸè£è, ªî£ì˜„Cò£è„ ªêò™
ð´ˆî «õ‡®ò ݬíèO¡ ªî£°F«ò ‘Gó™’ (Program) âùŠð´
Aø¶. å¼ ªî£°F«ò ªðKò GóL¡ CPò ðE¬ò„ ªêŒ¶ º®Š
ðîŸè£èŠ ðò¡ð´ˆîŠð´Aø å¼ Gó«ô ‘ªêò™ÃÁ’ (Function) Ý°‹.
C- Gó™èœ Iè„ CPò¬õò£è¾‹ Þ¼‚èô£‹. C-Gó™èœ ªêò™
ÃÁè÷£™ Ýù¬õ. ªêò™ÃÁ ޙô£ñ™ C-ªñ£NJ™ å¼ Gó¬ô
â¿î º®ò£¶. ªêò™ÃÁ, º¡«ð õ¬óòÁ‚èŠð†´ C-ªñ£NJ™
àœO¬í‚èŠð†ìî£è Þ¼‚èô£‹ ܙô¶ ðòù˜ ñ õ¬ó
òÁˆî£è Þ¼‚èô£‹. å¼ C - GóL¡ °Pº¬ø¬ò‚ W«ö 裇è:

#include <stdio.h>
main()
{
printf(“Hello World”);
}

C-ªñ£NJ™ å¼ ñ£FK Gó™

240
މî Gó¬ô Þò‚Aù£™, Hello world â¡Â‹ ªêŒF¬òˆ F¬ó
J™ 裆´‹. C-GóL™, main() âù õ¬óòÁ‚èŠð´‹ å¼ ªêò™ÃÁ
è†ì£òñ£è Þ¼‚è «õ‡´‹. main() - ðòù˜ õ¬óòÁ‚°‹ ªêò™
Ãø£°‹. ÞîŸè£ù è†ì¬÷ˆ ªî£°F¬òŠ ðòù˜ â¿î«õ‡´‹.
å¼ C-Gó¬ô Þò‚°‹«ð£¶, 膴Šð£´ main() ªêò½ÃÁ‚° ñ£Ÿ
øŠð´Aø¶. Þ‰î„ ªêò™ÃÁ, GóL¡ ¸¬ö¾ õ£J™ âùŠð´A
ø¶. «ñ«ô»œ÷ GóL™ Þó‡´ ªêò™ÃÁèœ àœ÷ù. ÜF™
å¡Á, GóL¡ ¸¬ö¾ õ£Jô£è M÷ƒ°‹ main( ) - ðòù˜ õ¬ó
òÁˆî¶. Þ¡ªù£¡Á, printf() - º¡ õ¬óòÁ‚èŠð†ì¶. Ü®Šð¬ì
ªõOf†®™ (F¬ó ܙô¶ F¬óòè‹) GóL¡ M¬ì¬ò‚ 裆´
õŠ ðò¡ð´ˆîŠð†´œ÷¶. ªêò™ÃÁ â¡ð¬î à혈Fì
H¬ø ܬ승‚°Pèœ ( ) ðò¡ð´ˆîŠð†´œ÷ù. Þó‡´ ªêò™
ÃÁèÀœ main( ), ܬö‚°‹ ªêò™Ãø£°‹. printf() ܬö‚èŠð´‹
ªêò™Ãø£°‹. Hello world Gó™ «î¬õò£ù M÷‚èƒèÀì¡ W«ö
îóŠð†´œ÷¶.

#include <stdio.h> /* <= preprocessor statement */


main() /* <= function header statement */
/* function definition starts <= comment statement */
{
function call statement
printf(“Hello World”); function body

GóL¡ ºî™õK #include <stdio.h> â¡ð¶ º¡-ªêòL‚ (Prepro-


cessor) ßø£°‹. #include â¡ð¶ º¡-ªêòL ªïP»Áˆî‹ Ý°‹.
º¡ -ªêòL â¡ð¶, Gó¬ô ªñ£N ªðò˜‚°‹ «ð£¶ (compile time)
Íô‚ °Pº¬ø¬ò MKˆªî¿¶‹ å¼ ªñ¡ªð£¼œ Góô£°‹.
# include <stdio.h> â¡Â‹ ßÁ, stdio.h (standard input and output header
file) â¡Â‹ «è£ŠH¡ àœ÷ì‚般î GóL™ main() ªêò™ÃP¡
º¡ð£è„ «ê˜ˆ¶‚ ªè£œAø¶. printf(), scanf() «ð£¡ø º¡-õ¬óò
Á‚èŠð†ì àœk†´, ªõOf†´ ªêò™ÃÁèO¡ ÜPMŠ¹‚ ßÁ
è«÷ stdio.h «è£ŠH™ Þì‹ ªðŸÁœ÷ù.
241
printf() , scanf() ÝAò ªêò™ÃÁèO¡ ÜPMŠ¹èœ,
int printf(char *, ...);
int scanf (char *, ...) ;

â¡Á ܬñ‰F¼‚°‹.
«ñŸè‡ì ªêò™ÃÁèœ åšªõ£¡Á‹ ªõš«õÁ â‡E‚
¬èJ™ Ü÷¹¼‚è¬÷ (variable numbers of parameters) ãŸè º®»‹
â¡ð¬î ºŠ¹œOèœ(...) à혈¶A¡øù. ºîô£õî£è Þ싪ðÁ‹
Ü÷¹¼ å¼ êóñ£è«õ (string) Þ¼‚°‹. Ü÷¹¼ â¡ð¶, ܬö‚
èŠð´‹ ªêò™ÃP‚° õöƒèŠð´‹ îó¾ ܙô¶ îèõ¬ô‚
°P‚°‹. ªð£¶õ£è, ªêò™ÃÁèÀ‚° ވî¬èò Ü÷¹¼‚èœ Cô
ÜŠðŠðìô£‹ ܙô¶ ÜŠðŠðì£ñ½‹ Þ¼‚èô£‹. å¡Á‚°
«ñŸð†ì Ü÷¹¼‚èœ Þ싪ðÁ‹«ð£¶ ܬõ, ªêò™ÃP¡ ªðò¬ó
Ü´ˆ¶, ܬ승‚°PèÀ‚°œ 裟¹œOJ†´ å¡ø¡H¡ å¡
ø£è‚ °PŠHìŠð´A¡øù. «ñ«ô»œ÷ GóL™ printf( ) ªêò™ÃP™
å«óªò£¼ Ü÷¹¼ ñ†´«ñ Þ싪ðŸÁœ÷¶. ܶ, F¬óòèˆF™
裆ìŠðì«õ‡®ò å¼ êóñ£°‹. ºî™ Ü÷¹¼õ£è Þ싪ðŸ
Áœ÷ char * â¡Â‹ (êó Þù) Ü÷¹¼, “°P»¼„ ²†´” (Character
pointer) â¡Á ܬö‚èŠð´Aø¶. Þ¬îŠðŸPŠ Hø° 𮊫ð£‹.

C-ªñ£N Gó™ªðò˜ŠH (Compiler), º¡-õ¬óòÁ‚èŠð†ì ªêò™


ÃÁè¬÷ ܬìò£÷‹ 致ªè£œÀ‹. è£óí‹, GóL™  «ê˜ˆ
¶‚ªè£‡´œ÷ î¬ôŠ¹‚ «è£Š¹èO™ (Header Files) ܬõ º¬øŠ
ð® ÜPM‚èŠð†´œ÷ù. î¬ôŠ¹‚ «è£Š¹èO¡ ðò¡ð£†®¬ù‚
W«ö»œ÷ GóL™ 裇è:

#include <stdio.h>
#include <conio.h>
main()
{
clrscr();
printf(“hello”);
}

242
މî GóL™ ðò¡ð´ˆîŠð†´œ÷ clrscr() â¡Â‹ º¡-õ¬óò
Á‚èŠð†ì ªêò™ÃP¡ ñ£FK õ®õ‹ (ÜPMŠ¹) conio.h â¡Â‹
î¬ôŠ¹‚ «è£ŠH™ Þ싪ðŸÁœ÷¶. âù«õ, ܂«è£ŠH¬ù މî
GóL™ ެ툶‚ªè£‡´œ«÷£‹. # include <conio.h> â¡Â‹ ßÁ
މî GóL™ Þ¬í‚èŠðìM™¬ôªòQ™, C-ªñ£N Gó™
ªðò˜ŠH (Compiler), clrscr() ªêò™ÃP¬ù Góô«ó õ¬óòÁˆ¶œ÷£ó£
âùŠ 𣘂°‹. ܊ð® ޙ¬ôªòQ™, H¬ö âù ÜPM‚°‹.
4.3.1 ßÁèœ (Statements)
C - GóL¡ 嚪õ£¼ õKèÀ‹ å¼ ÃŸø£è‚ (Statement) è¼îŠ
ð´A¡øù. ªð£¶õ£è, ° õ¬èò£ù ßÁèœ àœ÷ù. ܬõ
® º¡-ªêòL‚ ßÁèœ (Preprocessor Statements)
® ªêò™ÃÁ î¬ôŠ¹‚ ßÁèœ (Function Header Statements)
® ÜPMŠ¹‚ ßÁèœ (Declaration Statements)
® ªêò™ð£†´‚ ßÁèœ (Executable Statements)

cƒèœ 㟪èù«õ ÜP‰îð®, º¡ -ªêòL‚ßÁ, °PŠH†ì


î¬ôŠ¹‚ «è£Š¹èOL¼‰¶ ªêò™ÃÁèO¡ ÜPMŠ¹‚ ßÁè¬÷
ⴈ¶„ «ê˜ˆ¶, Íô Gó¬ô MK¾ð´ˆ¶‹ ðE¬ò„ ªêŒA¡øù.
ªêò™ÃÁ î¬ôŠ¹‚ ßÁ, å¼ ªêò™ÃP¡ õ¬óò¬øJ™ ºî™
õKò£è Þ싪ðÁAø¶. ÜPMŠ¹‚ ßÁè¬÷, ñ£P ÜPMŠ¹‚ ßÁ
(variable declaration statement), ªêò™ÃÁ ÜPMŠ¹‚ ßÁ (function decla-
ration statement) âù «ñ½‹ Þ¼õ¬èò£èŠ HK‚èô£‹.
#include <stdio.h> => º¡-ªêòL‚ ßÁ
main() => ªêò™ÃÁ î¬ôŠ¹‚ ßÁ
{
int a,b,c; => ñ£P ÜPMŠ¹‚ ßÁ
int add(int,int); => ªêò™ÃÁ ÜPMŠ¹‚ ßÁ
a = 10; => ªêò™ð£†´‚ ßÁ
}
ðòù˜ õ¬óòÁ‚°‹ ªêò™ÃÁèO¡ ÜPMŠ¹ ñŸÁ‹ õ¬ó
ò¬ø ðŸP “ªêò™ÃÁ蜔 â¡Â‹ ð°FJ™ M÷‚èŠð†´œ÷¶.
ªêò™ð£†´‚ ßÁèO™ ðô õ®õƒèœ àœ÷ù. ÜõŸÁœ ñFŠ
H¼ˆ¶ ßÁ (assignment statement) Ü®Šð¬ìò£ù å¡Á. å¼ ñ£P
J™ ñFŠ¬ð Þ¼ˆî ܶ ðò¡ð´Aø¶.
243
4.3.1.1 ñFŠH¼ˆ¶ ßÁèœ Assignment Statements)
ñFŠH¼ˆ¶ ßÁ ޚõ£Á ܬñ»‹:
ñ£P (Variable) = «è£¬õ (Expression) ;
æ˜ Ü¬óŠ¹œO ߬ø º®ˆ¶¬õ‚Aø¶. «è£¬õ â¡ð¶
ðô õ¬èŠð´‹. ܶðŸPŠ Hø° 𣘊«ð£‹. å¼ «è£¬õ ñFŠ
HìŠð´‹«ð£¶, ܶ å¼ M¬ì¬òˆ . Üî£õ¶, ܶ âŠ
«ð£¶«ñ 埬ø ñFŠð£è„ ²¼‚èŠð†´M´‹. «è£¬õJ™ ܉î
埬ø ñFŠ¹, ÞìŠð‚躜÷ ñ£PJ™ Þ¼ˆîŠð´Aø¶. = â¡Â‹
°P, ñFŠH¼ˆ¶ ªêòŸ°Pò£°‹. å¼ ñ£PJ™ ñFŠ¬ð Þ¼ˆ¶
õŠ ðò¡ð´Aø¶. ñFŠH¼ˆ¶ ªêòŸ°P‚° (=) õôŠð‚è‹
Þ싪ðŸÁœ÷ ܬùˆ¶‹ å¼ «è£¬õò£è‚ è¼îŠð´A¡øù.
㟪èù«õ  ÜP‰îð®, å¼ ªêò™ÃP™ Þ싪ðŸÁœ÷
ܬùˆ¶‚ ßÁèÀ‹ ªïO¾ ܬ승‚°PèÀ‚°œ ܬñ‚èŠ
ð´A¡øù.
printf (“hello”) ;
â¡ð¶ å¼ ªêò™ÃÁ ܬöŠ¹‚ ßÁ (function call statement) Ý°‹.
Þ‰î„ ªêò™ÃÁ Þò‚èŠð´‹«ð£¶, hello â¡Â‹ ªêŒF F¬óJ™
裆ìŠð´‹. F¬óJ™ âˆî¬ù ⿈¶èœ 裆ìŠð†ìù â¡Aø
â‡E‚¬è¬ò ªêò™ÃÁ F¼ŠH ÜŠ¹‹. printf() ªêò™ÃP¡
õ¬óò¬ø¬ò «ï£‚°‹«ð£«î, ܶ å¼ º¿â‡ ñFŠ¬ðˆ F¼Š
HòŠ¹‹ â¡ð¬î  ¹K‰¶ªè£œ÷ º®»‹. ⴈ¶‚裆ì£è,
å¼ GóL¡ ð°F¬ò‚ 裵ƒèœ:
int n ; /* ñ£P ÜPMŠ¹‚ ßÁ */
n = printf (‘hello”) ; */ ñFŠH¼ˆ¶ ßÁ */
ރ«è, n â¡Â‹ ñ£P å¼ º¿â‡ (integer) âù ÜPM‚èŠ
ð†´œ÷¶. ñFŠH¼ˆ¶ ßÁ ªêò™ð´‹«ð£¶, ºîL™ õôŠð‚è
ºœ÷ «è£¬õ ñFŠHìŠð´‹. Hø°, Üî¡ ñFŠ¹ ÞìŠð‚è ñ£P
J™ Þ¼ˆîŠð´‹. މî ⴈ¶‚裆®™, ñFŠH¼ˆ¶ ßP¡
õôŠð‚è‹, å¼ ªêò™ÃÁ ܬöŠ¹‚ «è£¬õ (function call expres-
sion) Þ싪ðŸÁœ÷¶. âù«õ, ފ«ð£¶ printf() â¡Â‹ ªêò™ÃÁ
Þò‚èŠð†´, hello â¡Â‹ ªêŒF F¬óJ™ 裆ìŠð´‹. printf() ªêò™
ÃÁ, 5 ⿈¶è¬÷ˆ F¬óJ™ 裆´õ 5 â¡Â‹ ñFŠ¬ðˆ
F¼ŠHòŠ¹‹. ܶ«õ õôŠð‚è‚ «è£¬õJ¡ ñFŠð£°‹. 5
â¡Â‹ ދñFŠ¹ ÞìŠð‚躜÷ n â¡Â‹ ñ£PJ™ Þ¼ˆîŠð´‹.
244
4.3.1.2 I°Š¹, °¬øŠ¹‚ ßÁèœ
(Increment and Decrement Statements)

å¼ ñ£PJ¡ º‰¬îò ñFŠH™ 1 Æ®Š ¹Fò ñFŠ¬ð Ü«î


ñ£PJ™ Þ¼ˆF¬õ‚è,
i =i+1;

â¡Â‹ ßÁ ðò¡ð´Aø¶.


Þ«î ðE¬ò, I°Š¹‚ ßÁ (Increment Statement) Íôñ£
辋 ªêŒ¶ º®‚èô£‹. ޚõ£ø£è:
i ++ ; /* H¡ªù£†´ õ®õ‹ */
++i;/* º¡ªù£†´ õ®õ‹ */
«ñ«ô 裆®òõ£Á, I°Š¹„ ªêòŸ°P¬òˆ îQG¬ô‚ ßÁ
èO™ (stand-alone statements) ðò¡ð´ˆFù£™, º¡ªù£†´‚°‹ H¡
ªù£†´‚°‹ «õÁ𣴠ⶾI™¬ô. Þ󇮽«ñ i- ¡ ñFŠ¹
å¡Á I°‚èŠð´‹. i- ¡ º‰¬îò ñFŠH™ 塬ø‚ °¬ø‚è,
°¬øŠ¹„ ªêòŸ°P¬òŠ ðò¡ð´ˆî«õ‡´‹. i -- ; ܙô¶ -- i;
I°Š¹, °¬øŠ¹„ ªêòŸ°Pèœ «õÁ śG¬ô¬ñèO™ «õÁMî
M¬÷¾è¬÷ˆ . ܶðŸPŠ Hø° 𣘊«ð£‹.
4.3.1.3 «è£¬õ (Expression)
«è£¬õ â¡ð¶ ªð¼‹ð£½‹, å¼ ñFŠH¼ˆ¶ ªêòŸ°P‚°
õôŠð‚èñ£è ܬñõ¶‡´. ܬî ñFŠH´‹«ð£¶, å¼ ‘ñFŠ¹’
M¬ìò£è‚ A¬ì‚°‹. «è£¬õèœ ð™«õÁ õ®õ‹ ªè£‡ì¬õ.
ÜõŸÁœ Cô:
int a,b,c; /* ñ£P ÜPMŠ¹‚ ßÁ */
a =10 ; /* ñFŠH¼ˆ¶ ßÁ */
Þó‡ì£õ¶ ßP™, 10 â¡Â‹ ñ£ø£ ñFŠ¹ õôŠð‚è‹
Þ싪ðŸÁœ÷¶. âù«õ Þ¶ ‘ñ£PL‚ «è£¬õ’ (constant expression)
âùŠð´Aø¶. Üî¡ ñFŠ¹ 10.
b= a ;

ÞF™, õôŠð‚è‹ å¼ ‘ñ£P‚ «è£¬õ’ (variable expression) Þì‹


ªðŸÁœ÷¶. Üî¡ ñFŠ¹ 10. ñFŠH¼ˆ¶ ßP¡ õôŠð‚è‹ Þ¼
õ¬èò£ù ñFŠ¹èœ Þ싪ðø º®»‹. å¼ ñ£PJ¡ ñFŠ¹ ܙ
245
ô¶ å¼ «è£¬õJ¡ ñFŠ¹. މî ⴈ¶‚裆®™ Þ󇴋 å¡«ø.
Ýù£½‹, «è£¬õJ¡ ñFŠ«ð ÞìŠð‚è ñ£PJ™ Þ¼ˆîŠð´A
ø¶ â¡ð¬î ⊫𣶋 G¬ùM™ ªè£œè.
ðò¡ð´ˆîŠð´‹ ªêòŸ°PèO¡ Ü®Šð¬ìJ™ «è£¬õèœ
ܬö‚èŠð´õ¶‡´. «õÁCô «è£¬õèœ W«ö:
«è£¬õ õôŠð‚è‹
c=a+b; èí‚W†´‚ «è£¬õ
c=a>b; åŠd†´‚ «è£¬õ
f=d =e; ñFŠH¼ˆ¶ «è£¬õ
åŠd†´‚ «è£¬¬õ¬òŠ ªð£Áˆîõ¬ó, ‘êK’ (true) ܙô¶
‘îõÁ’ (false) â¡Â‹ ñFŠ¹. ÞìŠð‚è ñ£PJ™ Þ¼ˆîŠð´‹. Üî£
õ¶ 1 ܙô¶ 0 â¡Â‹ ñFŠ¹ c â¡Â‹ ñ£PJ™ Þ¼ˆîŠð´‹. =
â¡Â‹ °P, ñFŠH¼ˆ¶ ªêòŸ°Pò£èŠ ðò¡ð´ˆîŠð´Aø¶.
âù«õ, C-ªñ£NJ™ ñFŠH¼ˆ¶ «è£¬õ ãŸèŠð´Aø¶ â¡Á
ªð£¼œ. ªî£ì˜ ñFŠH¼ˆî½‹ ÜÂñF‚èŠð´Aø¶. Í¡ø£õ¶
ßP™, ñFŠH¼ˆ¶ «è£¬õJ¡ ñFŠ¹ (Üî£õ¶, d- ™ Þ¼ˆîŠ
𴋠ñFŠ«ð, ñFŠH¼ˆ¶ «è£¬õJ¡ ñFŠð£°‹) f â¡Â‹
ñ£PJ™ Þ¼ˆîŠð´Aø¶.
f = d =10;

â¡Á‹ ߬ø ⴈ¶‚ªè£œ«õ£‹. ÞF™ ñFŠH¼‰¶ «è£¬õ


J¡ ñFŠ¹ 10 Ý°‹. ދñFŠ¹ d- ™ Þ¼ˆîŠð´Aø¶. Hø°,
ñFŠH¼‰¶ «è£¬õJ¡ މî ñFŠ¹ f-™ Þ¼ˆîŠð´Aø¶.
4.3.1.4 H¡ªù£†´, º¡ªù£†´ I°Š¹‚ «è£¬õèœ
(Postfix and Prefix Increment Expressions)

W«ö»œ÷ Gó™ ð°F¬ò «ï£‚°è:


int x, i;
i = 10;
x = i++; /* õôŠð‚è‹ H¡ªù£†´ I°Š¹‚«è£¬õ*/
printf(“%d %d\n”, x, i);

å¼ñ„ ªêòŸ°P ++ e¾ò˜ º¡ÂK¬ñ ªðŸø¶. ñFŠH¼ˆ¶


ªêòŸ°P e‚°¬ø‰î º¡ÂK¬ñ ªðŸø¶. H¡ªù£†´ õ®M™,
ºîL™ ñ£PJ¡ ñFŠ¹, «è£¬õJ¡ ñFŠð£èŠ ðò¡ð´ˆîŠð´
246
Aø¶. Üî¡Hø«è, ñ£PJ¡ ñFŠ¹, å¡Á I°‚èŠð´Aø¶. âù«õ,
õôŠð‚èˆF™ Þó‡´ ªõš«õÁ ñFŠ¹èœ àœ÷ù. å¡Á, «è£¬õ
J¡ ñFŠ¹; ñŸø¶ ñ£PJ¡ ñFŠ¹. «ñ«ô»œ÷ ñFŠH¼ˆ¶ ß
P™ «è£¬õJ¡ ñFŠ¹ 10. ܶ«õ ÞìŠð‚è ñ£P x-™ Þ¼ˆîŠ
ð´Aø¶. ފ«ð£¶ i-¡ ñFŠ¹ 11 ÝAø¶. å¼ ñFŠH¼ˆ¶ ß
P™ ÞìŠð‚è ñ£PJ™ å¼ ñFŠ¬ð Þ¼ˆî º¬ù»‹«ð£¶, õôŠð‚
肫裬õJ¡ ñFŠ¬ð«ò ⊫𣶋 èí‚A™ ⴈ¶‚ªè£œ÷
«õ‡´‹. âù«õ, printf() ªêò™ÃP¡ ªõOf´,
10 11

â¡Á ܬñ»‹. W«ö»œ÷ Gó™ ð°F¬ò «ï£‚°è:


int x, i;
i = 10;
x = ++i; /*õôŠð‚è‹ º¡ªù£†´ I°Š¹‚«è£¬õ*/
printf(“%d %d\n”, x, i);

º¡ªù£†´ õ®M™, ºîL™ ñ£PJ¡ ñFŠ¹, å¡Á I°‚èŠ


ð†´, ¹Fò ñFŠ¹, «è£¬õJ¡ ñFŠð£èŠ ðò¡ð´ˆîŠð´Aø¶.
«è£¬õJ¡ ñFŠ¹ 11 â¡ð ܶ«õ ÞìŠð‚è ñ£P x-™ Þ¼ˆîŠ
ð´Aø¶. âù«õ ªõOf´,
11 11

âù ܬñ»‹. åŠd†´‚ «è£¬õ Þ싪ðŸÁœ÷ ⴈ¶‚裆


¬ì‚ W«ö 裇è:
nt x, z;
x = 100;
z = (x == x++); H¡ªù£†´ I°Š¹‚ «è£¬õ¬ò å¼
/*
ªêò«ôŸHò£è‚ ªè£‡ì åŠd†´‚ «è£¬õ */
printf(“%d %d\n”, z, x);

Þî¡ ªõOf´ â¡ùõ£è Þ¼‚°‹?


«ñŸè‡ì ñFŠH¼ˆ¶ ßP™ Þ싪ðŸÁœ÷ åŠd†´‚
«è£¬õ, êK ܙô¶ îõÁ Üî£õ¶, 1 ܙô¶ 0 â¡Â‹ ñFŠ
¬ðˆ . âù«õ, z â¡Â‹ ñ£PJ¡ ñFŠ¹ 1 ܙô¶ 0 Ýè
Þ¼‚èô£‹. ++ ªêòŸ°PJ¡ e¾ò˜ º¡ÂK¬ñ è£óíñ£è,
åŠd†´‚ «è£¬õJ¡ õôŠð‚è ªêò«ôŸH«ò ºîL™ ñFŠHìŠ
ð´‹. ܶ H¡ªù£†´‚ «è£¬õ â¡ð, «è£¬õJ¡ ñFŠ¹
247
100 Ý°‹. Üî¡Hø° x-¡ ñFŠ¹ I°‚èŠð†´ Üî¡ ñFŠ¹ 101
ÝAø¶. ފ«ð£¶ åŠd†´‚ «è£¬õJ¡ ÞìŠð‚è„ ªêò«ôŸH
(å¼ ñ£P‚ «è£¬õ) 101 â¡Â‹ ñFŠ¬ðŠ ªðÁ‹. âù«õ, åŠ
Hì«õ‡®ò ñFŠ¹èœ 101 ñŸÁ‹ 100 Ý°‹. ܬõJ󇴋 Gè
ó£ù¬õ ܙô. âù«õ, z-™ 0 Þ¼ˆîŠð´‹. Þî¡ ªõOf´,
0 101
âù ܬñ»‹.
ñFŠH¼ˆ¶ ßP™, «è£¬õJ¡ ñFŠ
G¬ùM™ ªè£œè:
¹‚«è º‚Aòˆ¶õ‹ îó«õ‡´‹. ñ£PJ¡ ñFŠ¹‚°
ܙô.
4.3.1.5 àœk†´, ªõOf†´‚ ßÁèœ:
(Input and Output Statements)

 㟪èù«õ ÜP‰îð®, M¬ì¬ò Ü®Šð¬ì ªõOf†®™


(F¬óJ™) 裇H‚è printf() ªêò™ÃÁ ðò¡ð´Aø¶. F¬óòèˆF™
å¼ êóˆ¬î‚ 裆´õ printf() ðò¡ð†ì¬î 㟪èù«õ 
𣘈«î£‹. à‡¬ñJ™, printf() ªêò™ÃP¡ ºî™ Ü÷¹¼ å¼
êó‹ Ý°‹. ªõOf†¬ì‚ 膴Šð´ˆî («î¬õ‚«èŸð ܬñˆ
¶‚ªè£œ÷) ܶ ðò¡ð´Aø¶. âù«õ ܶ ‘膴Šð£†´„ êó‹’
(control string) â¡Á ܬö‚èŠð´Aø¶. މî Ü÷¹¼, ªõOf†¬ìˆ
F¬óJ™ 裆´õ ãŸøõ£Á õ®õ¬ñ‚èŠð´õ Þî¬ù
‘õ®õ¬ñŠ¹„ êó‹’ (formatting string) â¡Á‹ ܬö‚èô£‹.
ⴈ¶‚裆´:
å¼ º¿â‡ ñFŠ¬ð ªõOJì™:
int n ; /* º¿ ⇠ñ£Pò£è n ÜPM‚èŠð´Aø¶ */
n = 10;
printf (“%d” ,n);

މî ⴈ¶‚裆®™, “%d” â¡Â‹ ‘õ®õ¬ñŠ¹‚ °P»¼’


ªêò™ÃP¡ 膴Šð£†´„ êóˆ¶œå¼ º¿
(formatting character) printf()
⇠ñFŠ¬ð ªõOJì, ðò¡ð´ˆîŠð†´œ÷¶. printf() ªêò™ÃP¡
膴Šð£†´„ êó‹, Í¡Á õ¬èò£ù °P»¼‚ è¬÷ ãŸÁ‚ªè£œÀ‹.
® ê£î£óí °P»¼‚èœ (Ordinary Characters)
® õ®õ¬ñŠ¹‚ °P»¼‚èœ (Formatting Characters)
® M´ð´ õK¬ê‚ °P»¼‚èœ (Escape Sequence Characters)
248
膴Šð£†´„ êóˆF½œ÷ ê£î£óí‚ °P»¼‚èœ ܊
ð®«ò àœ÷õ£«ø 裆ìŠð´‹. printf (“hello”); â¡Â‹ ßP™ 膴Š
𣆴„ êó‹ ê£î£óí‚ °P»¼‚è¬÷«ò ªè£‡´œ÷¶. âù«õ,
ܬõ àœ÷õ£«ø F¬óJ™ 裆ìŠð´A¡øù. ð™«õÁ îóMù
ñFŠ¹è¬÷ F¬óJ™ è£†ìŠ ðò¡ð´‹ õ®õ¬ñŠ¹‚ °P»¼‚è
O¡ ð†®ò¬ô ܆ìõ¬í 4.4-™ 裇è:

 õ®õ¬ñŠ¹‚ °P»¼ îóMù‹

%d int

%f float
%c char
%s char [ ]

%ld long int


%lf long float or double

܆ìõ¬í 4.4 õ®õ¬ñŠ¹ õ¬óòÁŠ¹èœ

 㟪èù«õ ÜP‰îð®, M´ð´ õK¬ê‚ °P»¼‚èœ


â¡ð¬õ, å¼ H¡ê£Œ¾‚ «è£†¬ì Ü´ˆ¶ æ˜ â¿ˆ¬î‚ ªè£‡
®¼‚°‹. à‡¬ñJ™ ܬõ 埬ø‚ °P»¼ ñ£PLè«÷ Ý°‹.
ܬõ 埬ø‚ °P»¼‚è÷£è«õ «êI‚èŠð´A¡øù, ¬èò£÷Š
ð´A¡øù. ªõOf†®¡ õ®õ¬ñŠ¬ð æó÷¾ 膴Šð´ˆî M´
ð´ õK¬êèœ ðò¡ð´A¡øù. printf() ªêò™ÃP¡ 膴Šð£†’g„
êóˆF™ Ü®‚è® ðò¡ð´ˆîŠð´A¡ø M´ð´ õK¬êèœ Cô:
‘\n’ - ¹Fò õK‚ °P»¼
‘\t’ - îˆî™ °P»¼
‘\b’ - H¡ ÞìªõO‚ °P»¼
W«ö»œ÷ printf() ªêò™ÃÁ ܬöŠ¹‚ ߬ø «ï£‚°è:
int i =15;
printf (‘the value of i = &%d\n”, i);
249
F¬óJ™ 裆ìŠð´‹ ªõOf´:
the value of i = 15

«ñŸè‡ì printf() ªêò™ÃP™, ê£î£óí‚ °P»¼‚èœ, õ®õ


¬ñŠ¹‚ °P»¼‚èœ, M´ð´ õK¬ê‚ °P»¼‚èœ ÝAò Í¡Á
õ¬è °P»¼‚èÀ«ñ ðò¡ð´ˆîŠð†´œ÷ù. ê£î£óí‚ °P»¼‚
èœ àœ÷õ£«ø 裆ìŠð†´œ÷ù. %d â¡Â‹ õ®õ¬ñŠ¹‚ °P
»¼M¡ è£óíñ£è Ü´ˆ¶œ÷ º¿ ⇠ñFŠ¹ F¬óJ™ 裆ìŠ
ð†´œ÷¶. ¹Fò õK‚ °P»¼ ‘\n’ Þ¼Šðî¡ è£óíñ£Œ, ªõOf´
裆ìŠð†ì õK‚° Ü´ˆî õKJ™, 裆® õ‰¶ GŸAø¶. Ü´ˆ¶
õ¼‹ ªõOf´èœ ¹Fò õKJ™ 裆ìŠð´A¡øù.
printf (“one\n two\n three\n”) ;

â¡Â‹ ßÁ,
one
two
three

âùˆ F¬óJ™ 裆´‹.


¹FòõK‚ °P»¼ \n Þì‹ ªðŸÁœ÷ è£óíˆî£™ 嚪õ£¼
ªê£™½‹ îQ õKJ™ 裆ìŠð´Aø¶.
W«ö õ¼‹ GóL¡ ð°F¬ò «ï£‚°è:
int x;
float y;
x = 10;
y = 10.5;
printf(“%d %f”, x, y);

Þî¡ ªõOf´,
10 10.500000
âù Þ¼‚°‹.
Iî¬õŠ ¹œO ñFŠ¹èœ º¡Qò™ð£è (by default) ÝÁ Þô‚
èˆ ¶™LòˆF™ 裆ìŠð´‹. Þó‡´ Þô‚èˆ ¶™LòˆF™ ªõO
Jì M¼‹Hù£™, õ®õ¬ñŠ¹ õ¬óòÁŠ¹ % 0.2f â¡Á ܬñò
«õ‡´‹. ÞF™, ðF¡ñŠ H¡ù‹ Þó‡´ Þô‚èˆ ¶™Lòñ£è‚
膴Šð´ˆîŠð´Aø¶. âù«õ,
250
printf (“ %0.2f ”, y);

â¡Â‹ ßP¡ ªõOf´ 10.50 âù ܬñ»‹. Ýè, ªõOf†


¬ìˆ F¬óJ™ 裆´‹«ð£¶ Üî¡ Üèôˆ¬î‚ 膴Šð´ˆî, õ®
õ¬ñŠ¹ õ¬óòÁŠ¹èO™ Üèôˆ¬î»‹ àì¡ «ê˜ˆ¶‚ªè£œ÷
º®»‹.
printf (“ %10d %10.2f ”, x, y);

â¡Â‹ ßÁ,
bbbbbbbb10bbbbb10.50 /* b â¡ð¶ ªõŸÁ ÞìªõO¬ò‚ °P‚Aø¶ */
M¬êŠðô¬èJL¼‰¶ àœk´ (Input from keyboard)
M¬êŠ ðô¬èJL¼‰¶ (Ü®Šð¬ì àœk´) ñFŠ¹è¬÷ àœ
kì£èŠ ªðø scanf() ªêò™ÃÁ ðò¡ð´Aø¶. scanf()- ¡ ñ£FK õ®õ‹
(prototype), printf()-¡ ñ£FK õ®õˆ¬î åˆî‹. Þ¶¾‹ «õÁð†ì
â‡E‚¬èJ™ Ü÷¹¼‚è¬÷ 㟰‹.
å¼ º¿â‡ ñ£P x-¡ ñFŠ¬ð M¬êŠðô¬è Íô‹ ªðø,
int x ;
scanf (“%d”, &x);
â¡Â‹ °Pº¬ø (code) ðò¡ð´ˆîŠð´Aø¶.
ªêò™ÃÁ Þò‚èŠð´‹«ð£¶, ðòùK¡ àœk†´‚è£è‚
scanf()
èEŠªð£P 裈F¼‚°‹. ðòù˜ M¬êŠðô¬è Íôñ£èˆ îóM¬ù
àœOì«õ‡´‹. ðòù˜ Enter M¬ê¬ò Ü¿ˆFò Hø«è, àœ
O†ì îó¾ G¬ùõèˆF™ x-‚°Kò ÞìˆF™ Þ¼ˆîŠð´Aø¶. scanf()
ªêò™ÃP¡ Þó‡ì£õ¶ Ü÷¹¼õ£è &x Þ싪ðŸÁœ÷¶. Þ¶ x
â¡Â‹ ñ£PJ¡ G¬ùõè ºèõK¬ò‚ °P‚Aø¶. & â¡ð¶ ºè
õK ²†´‹ ªêòŸ°P â¡ð¬î ÜP«õ£‹. Üî¬ù å¼ ñ£P»ì¡
«ê˜ˆ¶Š ðò¡ð´ˆ¶‹«ð£¶, ܉î ñ£PJ¡ ºèõK¬ò‚ °P‚Aø¶.
4.3.2 ðòù˜ õ¬óòÁ‚°‹ ªêò™ÃÁèœ (User -defined Functions)
å¼ GóL™ å¼ °PŠH†ì ðE¬ò e‡´‹ e‡´‹ ªêŒò
«õ‡®J¼‰î£«ô£, ܊ðE¬ò ܉GóL™ ªõš«õÁ ÞìƒèO™
G¬ø«õŸø «õ‡®ò «î¬õ ãŸð†ì£«ô£, ܊ðE¬ò å¼ ªêò™
ÃPì‹ åŠð¬ìˆ¶M†´, «õ‡®ò«ð£¶ Ü‰î„ ªêò™ÃP¬ù
ܬöˆ¶‚ªè£œ÷ô£‹. ðòù˜ ܙô¶ Góô˜ (Programmer) °PŠ
H†ì ðEè¬÷ G¬ø«õŸÁõîŸè£èˆ ñ ªêò™ÃÁè¬÷ à¼
251
õ£‚A ¬õˆ¶‚ªè£‡´, GóL¡ ð™«õÁ ÞìƒèO™ ÜõŸ¬øŠ
ðò¡ð´ˆF‚ªè£œ÷ º®»‹. âù«õ, ªêò™ÃÁ â¡ð¶, M¼‹
¹‹ M¬ì¬òŠ ªðÁõîŸè£è, õK¬êò£è„ ªêò™ð´ˆî «õ‡®ò
è†ì¬÷ˆ ªî£°F¬ò àœ÷ì‚Aò å¼õ¬è Gó«ô Ý°‹. «õªø£¼
ªêò™Ã¬ø ܬö‚A¡ø ªêò™ÃÁ “ܬö‚°‹ ªêò™ÃÁ”
(calling function) â ù Š ð ´ ‹ . ܬö‚èŠð´A¡ø ªêò™ÃÁ,
“ܬö‚èŠð´‹ ªêò™ÃÁ” (called function) âùŠð´‹. ܬö‚èŠ
𴋠ªêò™ÃÁ Ü÷¹¼‚è¬÷‚ ªè£‡®¼‚èô£‹. ޙô£ñ½‹
Þ¼‚èô£‹.
ªêò™ÃÁèœ, ªêò™ÃÁ ܬöŠH¡ Íô‹ Þò‚èŠð´A¡
øù. ªêò™ÃÁ ܬöŠ¹, °PŠH†ì ªêò™ÃP¡ ªðò¬ó‚ °PŠ
H†´ ܬö‚Aø¶. ܚõ£Á ܬö‚°‹«ð£¶, °PŠH†ì ðE
¬ò„ ªêŒ¶ º®‚°‹ ªð£¼†´, ܬö‚èŠð†ì ªêò™ÃP‚°ˆ
«î¬õŠð´‹ îèõ™è¬÷ Ü÷¹¼‚èœ õ®M™ ÜŠH¬õ‚Aø¶.
ñ£Pè¬÷ ÜPMŠð¶«ð£¡«ø ªêò™ÃÁèÀ‹ ÜPM‚èŠð´õ¶
C-ªñ£NJ™ H¡ðŸøŠð´‹ Cø‰î ï¬ìº¬øò£°‹. å¼ ªêò™
ÃÁ ÜPMŠ¹ (function declaration) â¡ð¶, ‘ªêò™ÃP¡ ñ£FK õ®
õ‹’ (Function Prototype) ܙô¶ ‘ªêò™ÃÁ ñ£FKò‹’ (Function Model)
â¡Á ܬö‚èŠð´Aø¶. ªêò™ÃP¡ ñ£FK õ®õ‹ ° ÃÁ
è¬÷‚ ªè£‡ì¶:
® ªêò™ÃP¡ ªðò˜
® F¼ŠH ÜŠðŠð´‹ ñFŠH¡ îóMù‹
® Ü÷¹¼‚èO¡ â‡E‚¬è
® 嚫õ£˜ Ü÷¹¼M¡ îóMù‹
ⴈ¶‚裆ì£è, Þó‡´ â‡è¬÷‚ Æ®, M¬ì¬ò, ܬöŠ
ðõ˜‚° ÜŠH¬õ‚°‹ å¼ ðòù˜-õ¬óòÁˆî ªêò™ÃP¬ù‚
裇è:
int add (int, int);

«ñŸè‡ì ªêò™ÃÁ ÜPMŠ¹‚ ßP™ add â¡ð¶ ªêò™


ÃP¡ ªðò˜. Þó‡´ Ü÷¹¼‚è¬÷ ãŸAø¶. Þ󇴋 int Þùˆ¬î„
꣘‰î¬õ. ÞÁFJ™ æ˜ int ñFŠ¬ð«ò F¼ŠHòŠ¹‹. ªêò™ÃÁ
ޚõ£Á õ¬óòÁ‚èŠð´Aø¶:

252
int add(int a, int b) /* function header statement */
{
return (a+b);
}

ðòù˜-õ¬óòÁˆî ªêò™ÃÁ
ªêò™ÃP¡ ñ£FK õ®õ‹ Üî£õ¶ ªêò™ÃÁ ÜPMŠ¹‚
ßÁ, ܬ󊹜O»ì¡ ºŸÁŠªðÁAø¶. Ýù£™ ªêò™ÃP¡
î¬ôŠ¹‚ ßÁ ܬ󊹜O»ì¡ ºŸÁŠªðÁõF™¬ô. å¼ ªêò™
ÃÁ õ¬óòÁ‚èŠð´‹«ð£¶ ºî™ ßø£è ܬñõ¶, ªêò™ÃÁ
î¬ôŠ¹‚ ßø£°‹.
å¼ ªêò™Ã¬ø õ¬óòÁŠð¶ â¡ðî¡ ªð£¼œ, ÜKò
è†ìì¬÷è¬÷ ªïO¾ ܬ승‚°PèÀ‚°œ { } ⿶õ‹.
ªïO¾ ܬ승‚°PèÀ‚°œ â¿îŠð´‹ °Pº¬ø (code), ªêò™
ÃP¡ àì™ð°F (body) ܙô¶ ªî£°F (block) â¡Á ܬö‚èŠ
ð´‹. å¼ ªêò™ÃPœ ÜPM‚èŠð´‹ ñ£Pèœ Ü¬ùˆ¶‹ àœ
÷¬ñ ñ£Pèœ (local variables) Ý°‹. ܬõ â‰î‚ ªêò™ÃPœ
õ¬óòÁ‚èŠð†ìù«õ£ Ü‰î„ ªêò™ÃP‚° ñ†´«ñ ªîK‰î¬õ.
å¼ ªêò™ÃP¡ Ü÷¹¼‚èÀ‹ àœ÷¬ñ ñ£Pè«÷. ܬö‚°‹
ªêò™ÃÁ, ܬö‚èŠð´‹ ªêò™ÃÁ-Þ󇴂°‹ Þ¬ì«ò îèõ™
ðKñ£Ÿøˆ¶‚è£ù å¼ õNº¬ø¬ò Ü÷¹¼‚èœ õöƒ°A¡øù.
add() ªêò™ÃP¬ù Þò‚°‹ º¿ Gó¬ô‚ W«ö 裇è:

253
#include <stdio.h>
#include <conio.h>
main()
{
int a, b,c;
int add(int, int);
a = 12;
b = 11;
c = add(a,b); /* a »‹ b »‹ ªñŒò£ù Ü÷¹¼‚èœ */
printf(“%d\n”, c);
}
int add(int x, int y) /* x à‹ y à‹ º¬øò£ù Ü÷¹¼‚èœ*/
{
return(x+y);
}

ܬö‚°‹ ªêò™ÃP™ õ¬óòÁ‚èŠð´‹ Ü÷¹¼‚èœ ‘ªñŒ


ò£ù Ü÷¹¼‚蜒 (Actual Parameters) âùŠð´A¡øù. ܬö‚èŠ
𴋠ªêò™ÃP‚° ÜŠðŠðì«õ‡®ò ªñŒò£ù ñFŠ¹è¬÷
ܬõ ªè£‡´œ÷ù.
ܬö‚èŠð´‹ ªêò™ÃP™ õ¬óòÁ‚èŠð´‹ Ü÷¹¼‚èœ
‘º¬øò£ù Ü÷¹¼‚蜒 (Formal Parameters) âùŠð´A¡øù. ªêò™
ÃÁ Þò‚èŠð´‹«ð£¶, ªñŒò£ù Ü÷¹¼‚èO¡ ñFŠ¹è¬÷
Þ¬õ«ò ªðŸÁ‚ªè£œA¡øù.
«ñŸè‡ì GóL™,
c = add (a+b);

â¡Â‹ ñFŠH¼ˆ¶ ßÁ ªêò™ð´ˆîŠð´‹«ð£¶, GóL¡ è†


´ Š ð £ ´ add() ª ê ò ™ à P  ‚ ° ñ £ Ÿ ø Š ð ´ A ø ¶ . a, b Ý A ò ¬ õ
ª ñ Œ ò £ ù Ü ÷ ¹ ¼ ‚ è œ Ý ° ‹ . è £ ó í ‹ , add( ) ª ê ò ™ à Á
Þò‚èŠð´‹«ð£¶, Ü ÜŠH¬õ‚èŠðì«õ‡®ò ªñŒò£ù
ñFŠ¹è¬÷ މî Ü÷¹¼‚è«÷ ªè£‡´œ÷ù. މî ñFŠ¹è¬÷
ܬö‚èŠð†ì ªêò™ÃP¡ º¬øò£ù Ü÷¹¼‚è÷£ù x, y ÝA
ò¬õ ªðŸÁ‚ªè£œA¡øù. add( ) ªêò™ÃÁ ܬö‚èŠð´‹«ð£¶,
ªñŒò£ù Ü÷¹¼‚èO¡ ñFŠ¹èœ, º¬øò£ù Ü÷¹¼‚èO™ å¡
254
Á‚° å¡Á ªð£¼ˆîºÁ‹ð®ò£è, ïèªô´‚èŠð´A¡øù. ވî
¬èò ªêò™¸†ð‹ ‘ñFŠ¹ Íô‹ ܬöŠ¹’ (call by value) â¡Á
ܬö‚èŠð´Aø¶. add( ) ªêò™ÃÁ, M¬ì¬ò ܬö‚°‹ ªêò™
ÃP‚° F¼ŠH ÜŠ¹Aø¶. C = add(a+b) â¡Â‹ ßP¡ õôŠ
ð‚è‹ å¼ ªêò™ÃÁ ܬöŠ¹‚ «è£¬õ àœ÷¶. ܂«è£¬õJ¡
ñFŠ¹, add() ªêò™ÃÁ F¼ŠH ÜŠ¹‹ ñFŠð£°‹.
ªêò™ÃÁ ÞòƒA º®‰î¶‹, GóL¡ 膴Šð£´, ܬö‚°‹
ªêò™ÃP™, â‰î ÞìˆFL¼‰¶ 膴Šð£´ ñ£ŸøŠð†ì«î£ ܉î
Þ숶‚«è F¼‹Hõ¼‹. ªêò™ÃÁ ܬöŠ¹‚ ߬øŠ ªð£Áˆî
õ¬ó GóL¡ 膴Šð£´, ܬö‚°‹ ªêò™ÃP™ Ü´ˆî‚ ßÁ‚
°ˆ F¼‹Hõ¼‹. Þ¡ªù£¼ º‚Aò Mõóˆ¬î ñùF™ ªè£œ÷
«õ‡´‹. ܬö‚èŠð†ì ªêò™ÃP½œ÷ àœ÷¬ñ ñ£PèO¡ ñFŠ
¹èœ Þö‚èŠð´A¡øù. ªêò™ÃÁ ªêò™ð†´ º®‰î¶‹ ܬö‚
èŠð†ì ªêò™ÃP¡ àœ÷¬ñ ñ£Pèœ ÜN‚èŠð´A¡øù. å¼
ªêò™ÃP‚°œ ÜPM‚èŠð´A¡ø, õ¬óòÁ‚èŠð´A¡øù, ðò¡
ð´ˆîŠð´A¡ø ñ£Pè«÷ àœ÷¬ñ ñ£Pèœ âùŠð´A¡øù.
«ñŸè‡ì ⴈ¶‚裆®™, add() ªêò™ÃÁ, ‘ñFŠ¹ Íô‹
ܬöˆî™’ º¬øJ™ Þò‚èŠð´Aø¶. ñFŠ¹ Íô‹ ܬöˆî™
º¬øJ™ Ü÷¹¼‚èœ ÜŠðŠð´‹«ð£¶, Ü÷¹¼ ñFŠ¹èO¡
ïè™èœ à¼õ£‚èŠð†´, ܬö‚èŠð†ì ªêò™ÃP‚° ÜŠH
¬õ‚èŠð´A¡øù. ܬö‚èŠð†ì ªêò™ÃPœ ܋ñFŠ¹èO™
ªêŒòŠð´‹ ñ£Ÿøƒèœ, ܬö‚°‹ ªêò™ÃP½œ÷ Íô ñ£Pè
O¡ ñFŠ¹è¬÷ âšõ¬èJ½‹ ð£FŠðF™¬ô. ܬö‚°‹ ªêò™
ÃP½œ÷ àœ÷¬ñ ñ£PèO¡ ºèõKè¬÷ ܬö‚èŠð´‹ ªêò™
ÃÁ ÜP‰¶ ¬õˆF¼ŠH¡, ܬö‚èŠð†ì ªêò™ÃÁ, ܬö‚°‹
ªêò™ÃP½œ÷ àœ÷¬ñ ñ£PèO¡ ñFŠ¹è¬÷ ñ£ŸPò¬ñ‚è
º®»‹. ‘ºèõK Íô‹ ܬöŠ¹’ (call by address) 輈¶¼ Íô‹
ފðE¬ò„ ê£F‚è º®»‹.
ⴈ¶‚裆´:
W«ö àœ÷ Gó¬ô «ï£‚°è:

255
#include <stdio.h>
main()
{
int i;
void change(int *);
i = 20;
change(&i);
printf(“%d\n”, i);
}
void change(int *x)
{
*x = 23;
}

މî GóL¡ ªõOf´ 23 Ýè Þ¼‚°‹. Üî£õ¶, ܬö‚°‹


ªêò™ÃP½œ÷ àœ÷¬ñ ñ£PJ¡ ñFŠ¹ ñ£ŸøŠð†´ M†ì¶.
change() ªêò™ÃP¡ º¬øò£ù Ü÷¹¼ x, å¼ º¿â‡ ²†´ (in
teger pointer) Ý°‹. Þ¶, ܬö‚°‹ ªêò™ÃP¡ àœ÷¬ñ ñ£P i-¡
ºèõK¬ò ãŸÁ‚ªè£œAø¶. âù«õ x, i- ä„ ²†´Aø¶. ܬö‚èŠ
ð†ì ªêò™ÃP™, *x = 23; â¡ø ñFŠH¼ˆ¶ ßÁ, x ²†´‹ ºèõK
J™ ¹Fò ñFŠ¬ð Þ¼ˆ¶Aø¶. x, i-ä„ ²†´õ, i- ¡ ñFŠ¹
ñ£PM´Aø¶.
å¼ ²†´, ²†´A¡ø G¬ùõè ºèõKJ™ Þ¼‚°‹ ñFŠ¬ðŠ
ªðŸÁˆîó, àœ«ï£‚° ªêòŸ°P * ðò¡ð´ˆîŠð´Aø¶ â¡ð¬î
㟪èù«õ 𣘈«î£‹. W«ö»œ÷ Gó™ð°F¬ò «ï£‚°è:
int i = 32;
int * p;
int m;
p = &i;
m = *p;
ñFŠH¼ˆ¶ ßP¡ õôŠð‚è‹ Þ¼‚°‹ *p, p-Jù£™ ²†ìŠð
´‹ ºèõKJ½œ÷ ñFŠ¬ðŠ ªðŸÁˆ î¼Aø¶. ܋ñFŠ¹, i â¡ø
ñ£PJ¡ ñFŠ«ð Ý°‹. õôŠð‚è‹ *p ðò¡ð´ˆ¶õî¡ Íô‹,
å¼ G¬ùõè ºèõKJ™ Þ¼‚°‹ ñFŠ¬ðŠ ªðŸÁˆîó º®»«ñ
åNò ܃°œ÷ ñFŠ¬ð ñ£ŸPò¬ñ‚è º®ò£¶. change() ªêò™
256
ÃP™, ²†´ ñ£P p- àì¡, àœ«ï£‚° ªêòŸ°P * «ê˜ˆ¶ (*p âù),
ñFŠH¼ˆ¶ ßP¡ ÞìŠð‚è‹ ðò¡ð´ˆF»œ«÷£‹. ޚõ£Á,
àœ«ï£‚° ªêòŸ°P»ì¡ ²†´ ñ£P, ÞìŠð‚è‹ Þ싪ðÁñ£
J¡ ܶ, G¬ùõè Þ¼ŠHìˆF¡ ºèõK¬òˆ ñ ܙô£¶
ÜF½œ÷ ñFŠH¬ùˆ îó£¶. âù«õ *x = 23; â¡ø ßP¡ Íô‹,
x ²†´‹ ºèõKJ™ 23 â¡Aø ñFŠ¹ Þ¼ˆîŠð´Aø¶.

²¼ƒè‚ÃP¡, àœ«ï£‚° ªêòŸ°P¬ò( *), õôŠð‚è‹ ðò¡


ð´ˆFù£™, ܶ îóM¡ ñFŠ¬ðŠ ªðŸÁˆî¼‹; ñFŠ¬ð ñ£ŸP
ܬñ‚裶. ܶ ‘ð®‚è ñ†´‹’ Ýù ñFŠ¹. àœ«ï£‚° ªêòŸ
°P, ÞìŠð‚è‹ ðò¡ð´ˆîŠð´ñ£J¡, ܶ Þ¼ŠHì ºèõK
¬òˆ ; ÜF½œ÷ ñFŠ¬ð ñ£ŸPò¬ñ‚è º®»‹.
ªêò™ÃÁ ðŸPò ñŸÁªñ£¼ 輈¶¼¬õ cƒèœ ÜP‰¶
ªè£œ÷ «õ‡´‹. W«ö»œ÷ Gó™ð°F¬ò «ï£‚°è. Þ¶ ªêò™
ð´‹Mî‹ êŸ«ø «õÁð£ì£ù¶. Þ¬î cƒèœ ÜP‰F¼‚èñ£†¯˜èœ.
int i = 10;
printf (“%d %d”, i, i++);

Þî¡ ªõOf´ 10 10 ܙô¶ 10 11 âù Þ¼‚°‹ â¡Á


cƒèœ â‡Eù£™ ãñ£Ÿø‹ ܬìi˜èœ. މî Gó™ð°FJ™ å¼
輈¶¼ ñ¬ø‰¶ Aì‚Aø¶. C-ªñ£NJ™, å¼ ªêò™ÃÁ Þò‚
èŠð´‹«ð£¶, Üî¡ Ü÷¹¼‚èœ õôI¼‰¶ Þìñ£è, æ˜ Ü´‚
èˆF™ (Stack) Þ¼ˆîŠð´A¡øù. ‘Ü´‚è‹’ â¡ð¶ ‘è¬ì¹°-ºî™
M´’ (Last - In- First - Out /LIFO) ܬñŠH™ Þ¼‚°‹.
꣊H´‹ î†´èœ Ü™ô¶ ì‹÷˜èœ Ü´‚A¬õ‚èŠð´õ¬î
«ï£‚°è. ꣊𣆴 ܬøJ™, è¿õŠð†ì H¡, ܬõ å¡ø¡e¶
å¡ø£è Ü´‚A¬õ‚èŠð´A¡øù. è¬ìCò£è ¬õ‚èŠð†ì 
ܙô¶ ì‹÷˜ (à„CJ™ Þ¼Šð¶) ºîL™ ⴂèŠð´‹. Hø°
Ü´ˆî¶ ⴂèŠð´‹.
‘Ü´‚è‹’ â¡ð¬îŠ ðìˆF™ 裇è:

257
%d %d
Ü´‚èˆF¡ à„C

11

10 Ü´‚èˆF™
Ü´‚è‹ îœ÷Šð†ì
ºî™ àÁŠ¹
«ñ«ô è‡ì printf() ªêò™ÃÁ ܬö‚èŠð´‹«ð£¶, Ü´‚
èˆF™ ºîL™ îœ÷Šð´‹ ñFŠ¹, i++ «è£¬õJ¡ ñFŠð£°‹. Þ¶
å¼ H¡ªù£†´‚ «è£¬õ â¡ð, «è£¬õJ¡ ñFŠ¹ 10 Ü´‚
èˆF™ îœ÷Šð´‹. Üî¡Hø° I°Š¹„ ªêòŸ°PJ¡ (++) ðô
ù£è, i-¡ ñFŠ¹ å¡Á I°‚èŠð†´, 11 âù Ý°‹. õôI¼‰¶
Þìñ£è Ü´ˆ¶ Þ싪ðÁ‹ Ü÷¹¼ i . Üî¡ ñFŠ¹ Þó‡ì£õî£è
Ü´‚èˆF™ îœ÷Šð´‹. Üî£õ¶, 11 Ü´‚èˆF¡ «ñL¼‚°‹.
è¬ìC Ü÷¹¼õ£è, “%d %d” â¡Â‹ 膴Šð£†´„ êó‹ Ü´‚èˆ
F™ îœ÷Šð´‹. ÞQ îœ÷Šð´õ Ü÷¹¼‚èœ ⶾ‹ ޙ
ô£î«ð£¶, printf() ªêò™ÃÁ, Ü´‚èˆF¡ àÁŠ¹è¬÷ à„CJL
¼‰¶ 嚪õ£¡ø£è â´‚èˆ ªî£ìƒ°‹. ºîL™ ªõOJ™ ⴂ
èŠð´‹ àÁŠ¹ “%d %d”. ªêò™ÃÁ 膴Šð£†´„ êóˆ¬î ݌¾
ªêŒ»‹. ºîL™ %d Þ¼Šð, Ü´‚èˆFL¼‰¶ Ü´ˆî àÁŠ¬ð
(ñFŠ¹ 11) ªõOJªô´ˆ¶ å¼ º¿â‡í£è‚ 裆´‹. Ü´ˆ¶œ÷
%d-‚°, Ü´‚ èˆF½œ÷ Ü´ˆî àÁŠ¬ð (ñFŠ¹ 10) ªõOJ™
ⴈ¶ å¼ º¿â‡ ñFŠð£è‚ 裆´‹. ފ«ð£¶ Ü´‚è‹ è£L
ÝAM†ì¶. F¬óJ™,
11 10
â¡Â‹ ªõOf†¬ì‚ è£íô£‹. C-ªñ£N ªêò™ÃÁ ªêò™ð´‹
Mî ފ«ð£¶ ï¡° ¹K‰F¼Šd˜èœ.
4.4 «êIŠ¹ Þù‚°¿‚èœ (Storage Classes)
å¼ ñ£PJ¡ ð‡¹‚ÃÁè÷£è Þ¶õ¬óJ™  𣘈î¬õ
® ªðò˜ (Name)
® Þù‹ (Type)
® ñFŠ¹ (Value)
258
‘«êIŠ¹ Þù‚°¿’ â¡ð¶, ñ£P»ì¡ ªî£ì˜¹¬ìò ñŸªø£¼
ð‡¹‚Ãø£°‹. C-ªñ£N ° Þù‚°¿‚è¬÷ õöƒ°Aø¶.
® auto
® static
® register
® extern

å¼ ñ£PJ¡ õ¬óªò™¬ô¬ò»‹ õ£›ï£¬÷»‹ (scope and


b˜ñ£QŠð Üî¡ «êIŠ¹ Þù‚°¿ ðò¡ð´Aø¶. auto
lifetime)
ñ£Pèœ à‡¬ñJ™ àœ÷¬ñ (local) ñ£Pè÷£°‹. ܬõ ÜPM‚
èŠð†´œ÷ ªêò™ÃPœ GóL¡ 膴Šð£´ ¸¬ö»‹«ð£¶ ܬõ
à¼õ£‚èŠð´A¡øù. ªêò™Ã¬øM†´ ªõO«òÁ‹«ð£¶ ܬõ
ÜN‚èŠð´A¡øù. å¼ ªêò™ÃPœ à¼õ£‚èŠð´ñ ñ£Pèœ
܄ªêò™ÃP¡ àœ÷¬ñ ñ£Pèœ Ý°‹. ÜõŸP¡ õ¬óªò™
¬ô»‹ õ£›ï£À‹ ܄ªêò™ÃPœ«÷«ò º®‰¶M´A¡øù. å¼
ªêò™ÃÁ ªêò™ð†´ º®»‹«ð£¶, ܬùˆ¶ àœ÷¬ñ ñ£PèÀ‹
ÜN‚èŠð´A¡øù â¡ð«î Þ𣼜. àœ÷¬ñ ñ£PèO¡
ñFŠ¹è¬÷ ܄ªêò™ÃP‚° ªõO«ò Üµè º®ò£¶. Üî£
õ¶, àœ÷¬ñ ñ£PèO¡ õ¬óªò™¬ô ܬõ ÜPM‚èŠð†´œ÷
ªêò™ÃPœ ÜìƒAM´Aø¶. W«ö»œ÷ Gó¬ô «ï£‚°è:

#include <stdio.h>
main()
{
add();
add();
}
add()
{
int i = 0;
i = i + 1;
printf(“%d\n”, i);
}
މî GóL¡ ªõOf´,
1
1
259
âù ܬñ»‹. i â¡ð¶, add() ªêò™ÃP¡ àœ÷¬ñ ñ£P. åš
ªõ£¼ º¬ø add() ªêò™ÃÁ ܬö‚èŠð´‹«ð£¶‹, i â¡Â‹ ñ£P
¹F à¼õ£‚èŠð†´ 0 â¡Â‹ ªî£ì‚èñFŠ¹ Þ¼ˆîŠð´Aø¶.
âù«õ M¬ì ⊫𣶫ñ 1 Ýè Þ¼‚°‹. Þ«î ñ£P static
Þùñ£è ÜPM‚èŠð†®¼ŠH¡, ªêò™ÃÁ ªêò™ð†´ º®‰î H¡
‹ Üî¡ ñFŠ¹ î‚è¬õˆ¶‚ ªè£œ÷Šð†®¼‚°‹. add() ªêò™
ÃP¬ù W›‚裵ñ£Á ñ£ŸP ܬñ‚辋:

add()
{
static int i = 0;
i = i + 1;
printf(“d\n”, i);
}

ÞF™, i â¡Â‹ ñ£P static Þùñ£è ÜPM‚èŠð†´œ÷¶. Þ¶


add() ªêò™ÃP¡ àœ÷¬ñ ñ£Pò£°‹. Þî¡ õ¬óªò™¬ô add()
ªêò™ÃÁ‚°œ ñ†´«ñ. Þî¡ ñFŠ¬ð «õªø‰î ªêò™ÃÁ‹
Üµè º®ò£¶. static ñ£Pèœ, ºî¡ºîL™ ªêò™ÃÁ ܬö‚
èŠð´‹«ð£¶ å«óªò£¼ º¬ø ñ†´«ñ à¼õ£‚èŠð´A¡øù. ªêò™
ÃÁ ªêò™ð†´ º®‰îH¡Â‹ ÜõŸP¡ ñFŠ¹è¬÷ˆ î‚è¬õˆ¶‚
ªè£œ÷ º®»‹. Þ¶«õ static ñ£PèO¡ IèŠ ªðKò ÜÂÃôñ£°‹.
âù«õ 嚪õ£¼ º¬ø add() ªêò™ÃÁ ܬö‚èŠð´‹ «ð£¶‹
i-¡ ñFŠ¹ å¡Á I°‚èŠð†´ ªõOf´,

1
2
âù ܬñ»‹.
«ñŸè‡ì GóL™, i â¡Â‹ ñ£P¬ò å¼ º¿î÷£Mò (global)
ñ£Pò£è ÜPMˆ¶, ꟫ø ñ£ŸP â¿FŠ 𣘊«ð£‹. º¿î÷£Mò
ñ£Pèœ main() ªêò™ÃP‚° «ñ«ô ÜPM‚èŠð´A¡øù. މî
ñ£Pè¬÷, GóL™ àœ÷ ܬùˆ¶„ ªêò™ÃÁèÀ‹ ܵèô£‹,
ñ£ŸPò¬ñ‚èô£‹.

260
#include <stdio.h>
int i = 0;
main()
{
add();
add();
}
add()
{

i = i + 1;
printf(“%d\n”,i);
}

މî GóL¡ ªõOf´ ޚõ£Á ܬñ»‹:


1
2

«ñŸè‡ì GóL™, i â¡ð¶ å¼ º¿î÷£Mò ñ£Pò£°‹.


ܬùˆ¶„ ªêò™ÃÁèÀ‹ Þî¬ù ܵ辋 ñ£ŸPò¬ñ‚辋
º®»‹. static ñ£Pèœ, àœ÷¬ñ ñ£PèO¡ ð‡Hò™¹è¬÷‚ ªè£‡
´œ÷ù. º¿ Gó½‹ ªêò™ð†´ º®‰îHø«è static ñŸÁ‹ º¿î
÷£Mò ñ£PèO¡ õ£›ï£œ º®¾‚° õ¼A¡ø¶. static ñ£PJ¡
õ¬óªò™¬ô ܶ ÜPM‚èŠð†´œ÷ ªêò™ÃÁ‚°œ ñ†´«ñ.
Ýù£™ º¿î÷£Mò ñ£PJ¡ õ¬óªò™¬ô, GóL½œ÷ ܬùˆ¶
ªêò™ÃÁèÀ‚°‹ ðóM‚ Aì‚Aø¶. Þ‰î «õÁð£´èœ îMó, å¼
ªêò™ÃP‚° ªõO«ò ÜPM‚èŠð´‹ º¿î÷£Mò ñ£Pèœ
Þò™ð£è«õ static Þù‚°¿¬õ„ ꣘‰î¬õ«ò. Ýù£™, static ñ£P,
å¼ º¿î÷£Mò ñ£P ܙô â¡ð¬î ñùF™ ªè£œè.
register ñ£Pèœ, auto ñ£Pè¬÷Š «ð£¡«ø Þòƒ°A¡øù. å¼
ñ£P register Þùñ£è ÜPM‚èŠð´ñ£J¡, Üî¡ ñFŠ¹, èEŠ
ªð£PJ¡ ÜF«õè õ¡ªð£¼œ ðFõèƒèœ (registers) å¡P™ Þ¼ˆF
¬õ‚èŠð´Aø¶. G¬ùõè Üµè™ «ïóˆ¬î‚ °¬øˆ¶, ªêò™
ð£´è¬÷ «õèŠð´ˆî register ñ£Pèœ ðò¡ð´A¡øù.
º¿î÷£Mò ñ£Pè¬÷, å¼ Gó™ «è£ŠH™ àœ÷ ªêò™
261
ÃÁè÷£™ ܵ躮»‹. º¿î÷£Mò ñ£Pèœ ÜPM‚èŠð†´œ÷
«è£Š¹ ܙô£î Hø «è£Š¹èO™ àœ÷ ªêò™ÃÁèœ Üµè
«õ‡®ò «î¬õJ¼ŠH¡, ÜõŸ¬ø extern Þù‚°¿M™ ÜPMˆ¶‚
¬èò£÷ô£‹. ⴈ¶‚裆ì£è, count â¡Â‹ º¿î÷£Mò º¿â‡
ñ£P¬ò å¼ «è£ŠH™ ÜPMˆ¶, Üî¬ù «õªø£¼ «è£ŠH™
ⴈî£÷ «õ‡´ªñQ™, Þó‡ì£õ¶ «è£ŠH™, ܉î ñ£P¬òŠ
ðò¡ð´ˆ¶õ º¡ð£è,
extern int count ;

â¡Aø ÜPMŠ¹ Þ¼‚è «õ‡´‹. extern ñ£Pèœ º¿î÷£Mò


õ¬óªò™¬ô ªè£‡ì¬õ. ÜõŸP¡ õ£›ï£œ, Gó™ ªêò™ð†´‚
ªè£‡®¼‚°‹ õ¬ó ªî£ì˜‰¶ G¬ôˆF¼‚°‹.
4.5 Gð‰î¬ù‚ ßÁèœ (Conditional Statements)
4.5.1 if ßÁ
C-ªñ£NJ™ Gð‰î¬ù‚ ßÁèœ ÌLò¡ «è£¬õèœ â¡Â‹
輈¬î«ò ꣘‰¶œ÷ù. if ßÁ, Gð‰î¬ù‚ A¬÷HKˆî¬ô‚
膴Šð´ˆ¶Aø¶. ÌLò¡ «è£¬õ ܙô¶ «õÁ ªðòK™ ÃÁõ
ªîQ™ åŠd†´‚ «è£¬õ, ‘êK’ ܙô¶ ‘îõÁ’ â¡Aø ñFŠ¬ð«ò
M¬ìò£èˆ . C-ªñ£NJ™ 0 â¡ð¶ ‘îõÁ’, 0 ܙô£î ñFŠ¹
‘êK’ âù‚ ªè£œ÷Šð´‹. Gð‰î¬ù‚ «è£¬õJ¡ ñFŠ¹ ‘êK’
Üî£õ¶ 0 ܙô£î ñFŠð£è Þ¼‰î£™ if ßP¡ àìŸð°FJ
½œ÷ è†ì¬÷èœ G¬ø«õŸøŠð´‹. if ßÁ‚° Þó‡´ õ®õƒ
èœ àœ÷ù:
1. if (åŠd†´‚ «è£¬õ)
è†ì¬÷;
2. if (åŠd†´‚ «è£¬õ)
è†ì¬÷-1;
else
è†ì¬÷-2 ;
ºî™ õ®M™, åŠd†´‚ «è£¬õ ‘êK’ (0 ܙô£î ñFŠ¹)
âQ™, Ü´ˆ¶œ÷ è†ì¬÷ ªêò™ð´ˆîŠð´‹. «è£¬õJ¡ ñFŠ¹
‘îõÁ’ (0 ñFŠ¹) âQ™, Ü´ˆ¶œ÷ è†ì¬÷ ¹ø‚èE‚èŠð´‹.
Þó‡ì£õ¶ õ®M™, else ðò¡ð´ˆîŠð†´œ÷¶. «è£¬õJ¡ ñFŠ¹
‘îõÁ’ âQ™ è†ì¬÷-2 G¬ø«õŸøŠð´‹. Þó‡´ õ®õƒèO
262
½‹ GóL¡ 膴Šð£´, Ü´ˆ¶ if ßÁ‚°Š Hø°œ÷ è†ì¬÷‚°ˆ
î£MM´‹.
ê£î£óí if ߬ø M÷‚°‹ C-Gó¬ô‚ 裇è:

#include <stdio.h>
main()
{
int x;
printf(“Enter an integer: “);
scanf(“%d”, &x);
if (x > 0)
printf(“The value is positive\n”);
}

މî Gó™, ðòQìI¼‰¶ æ˜ â‡¬í 㟰‹. if ßP¡ Gð‰


î¬ù‚ «è£¬õÍô‹ ܉î ⇠0-äMìŠ ªðKî£ âùŠ ðK
«ê£F‚°‹. ªðKªîQ™ å¼ ªêŒF¬òˆ F¬óJ™ 裆´‹. ޙ¬ô
«ò™ Gó™ ñ¾ùñ£AM´‹. ªõOf´ ⶾ‹ Þó£¶. GóL™ àœ÷
(x > 0) â¡Â‹ ð°F ÌLò¡ «è£¬õ âùŠð´Aø¶. C-ªñ£N,
Þ‰î‚ «è£¬õ¬ò ñFŠH†´, ªêŒF¬ò‚ 裆ìô£ñ£ Ãì£î£ â¡
ð¬îˆ b˜ñ£Q‚Aø¶. ÌLò¡ «è£¬õJ¡ ñFŠ¹ ‘êK’ âQ™, if
ßÁ‚° Ü´ˆF¼‚°‹ 埬ø‚ è†ì¬÷¬ò (ܙô¶ if ßÁ‚°
Ü´ˆF¼‚°‹ ªïO¾ ܬ승‚ °PèÀ‚°œ Þ¼‚°‹ è†ì¬÷
èO¡ ªî£°F¬ò) C-ªñ£N G¬ø«õŸÁ‹. ÌLò¡ «è£¬õ ‘îõÁ’
âQ™, if ßÁ‚° Ü´ˆF¼‚°‹ è†ì¬÷¬ò ܙô¶ è†ì¬÷
èO¡ ªî£°F¬ò C-ªñ£N G¬ø«õŸø£ñ™ îM˜ˆ¶M´‹. Þ¡
«ù£˜ ⴈ¶‚裆¬ìŠ 𣼃èœ:
#include <stdio.h>
main()
{ int x;
scanf(“%d”, &x);
if (x < 0)
printf(“The value is egative\n”);
else if (x == 0)
printf(“The value is zero\n”);
else
printf(“The value is positive\n”);
}
263
މî ⴈ¶‚裆®™, if-else-if è†ì¬÷ ܬñŠ¹Š ðò¡
ð´ˆîŠð†´œ÷¶. Þî¬ùŠ H¡ù™ (nested) if-else ܬñŠ¹ âù
ܬö‚èô£‹. ªîK¾èO¡ (choices) Ü®Šð¬ìJ™ Cô ªêò™ð£´
è¬÷ G¬ø«õŸøŠ H¡ù™ if-else ܬñŠ¹ ðò¡ð´ˆîŠð´Aø¶.
èEîˆF™ æ˜ âO¬ñò£ù è킬è ⴈ¶‚ªè£œ«õ£‹. ðòù
K¡ ªîK¾ Ü®Šð¬ìJ™ Æì™, èNˆî™, ªð¼‚è™, õ°ˆî™
ÝAò ªêò™ð£´èœ G¬ø«õŸøŠðì«õ‡´‹. ªîK¾è¬÷ˆ F¬ó
J™ 裆® ðòùK¡ M¼Šðˆ¬îŠ ªðøô£‹. މî Gó¬ô Þó‡´
õNèO™ â¿îº®»‹:
âOò if ðò¡ð´ˆF-
#include <stdio.h>
main()
{ int a,b,c,choice;
scanf(“%d%d”, &a,&b); /*b ²Nò‹ ޙ¬ô */
printf(“1. addition\n”); /* «î˜¾ 1 */
printf(“2. subtraction\n”); /* «î˜¾ 2 */
printf(“3. multiplication\n”); /* «î˜¾ 3 */
printf(“4. division\n”); /* «î˜¾ 4 */
scanf(“%d”, &choice);
if(choice == 1)
c = a + b;
if(choice == 2)
c = a - b;
if(choice == 3)
c = a * b;
if(choice == 4)
c = a / b;
printf(“the result = %d\n”, c);
}
«ñŸè‡ì Gó™, ªîKM¡ Ü®Šð¬ìJ™ èí‚W†¬ì„ ªêŒ¶
º®ˆ¶ M¬ì¬òˆ F¬óJ™ 裆´‹. ðòù˜ ªîK¾ â¶õ£J‹,
މî GóL™ ªêŒòŠð´‹ åŠd´èœ ° Ý°‹. «î¬õòŸø
åŠd´èÀ‹ ªêŒòŠð´A¡øù. (choice ==1) â¡ð¶ ‘êK’ Ýè Þ¼‚
264
°‹«ð£¶, Hø åŠd´è¬÷„ ªêŒòˆ «î¬õJ™¬ô; îM˜ˆ¶Mì
ô£‹. ܚõ£Á ªêŒò«õ‡´ªñQ™ H¡ù™ if-else ðò¡ð´ˆî
«õ‡´‹.
H¡ù™ if-else ܬñŠ¬ðŠ ðò¡ð´ˆF-

#include <stdio.h>
main()
{ int a,b,c;
int choice;
printf(“Enter two integers: “);
scanf(“%d%d”, &a,&b); /* b ²Nò‹ ޙ¬ô */
printf(“1. addition\n”); /* «î˜¾ 1 */
printf(“2. subtraction\n”); /* «î˜¾ 2 */
printf(“3. multiplication\n”); /* «î˜¾ 3 */
printf(“4. division\n”); /* «î˜¾ 4 */
printf(“Enter your choice: “);
scanf(“%d”, &choice);
if(choice == 1)
c = a + b;
else
if(choice == 2)
c = a - b;
else
if(choice == 3)
c = a * b;
else
if(choice == 4) /* åŠH´ è†ì£òI™¬ô */
c = a / b;
printf(“the result = %d\n”, c);
}

«ñŸè‡ì Gó™, H¡ù™ if-else ܬñŠ¬ðŠ ðò¡ð´ˆF»œ÷¶.


ºî™ Gð‰î¬ù ‘êK’ âQ™, Üî£õ¶ (choice == 1) â¡ð¶ ‘êK’
âQ™, c = a + b ; â¡Â‹ è†ì¬÷ G¬ø«õŸøŠð´‹. else- ‚°Š
265
Hø° ܬñ‰¶œ÷ è†ì¬÷ îM˜‚èŠð´‹. âù«õ, ºî™ Gð‰
î¬ù ‘êK’ Ýè Þ¼ŠH¡ å«ó«ò£˜ åŠd´ ñ†´«ñ ªêŒòŠð´
Aø¶; Hø åŠd´èœ îM˜‚èŠð´A¡øù. ºî™ Gð‰î¬ù ‘îõÁ’
âù Ý°‹«ð£¶î£¡, Góô£ù¶ Þó‡ì£õ¶ åŠd†´‚°„ ªê™
½‹. Þ¶«ð£ô«õ, Ü´ˆî´ˆî Gð‰î¬ù êK 𣘂èŠð´‹. މî
Gó™ º‰¬îò Gó¬ôMì «õèñ£è„ ªêò™ð´‹. Ýù£™ ªîK¾ 4
âQ™, Þó‡´ Gó™èÀ«ñ ° åŠd´è¬÷„ ªêŒò«õ‡®J
¼‚°‹.
4.5.2 switch-case ßÁ
C-ªñ£N GóL™ Cô śG¬ôèO™ C‚è™I°‰î H¡ù™ if-
else ܬñŠ¹‚° ñ£Ÿø£è switch-case ßP¬ùŠ ðò¡ð´ˆî º®
»‹. C‚èô£ù Gð‰î¬ù ñŸÁ‹ A¬÷HKˆî™ ªêò™ð£´è¬÷‚
膴Šð´ˆî switch-case ßÁ àî¾Aø¶. switch ßÁ GóL¡ 膴Š
𣆬ì Üî¡ àìŸð°FJ½œ÷ å¼ ÃŸÁ‚° ñ£ŸÁAø¶. switchcase
ßP¡ ªî£ìó¬ñŠ¬ð‚ 裇è:
switch (Gð‰î¬ù‚ «è£¬õ)
{
case ñ£PL‚«è£¬õ-1:
...............................
break ;
case ñ£PL‚«è£¬õ-2:
...............................
break ;
...............................
..............................
default :
....................................
}

switchßPœ Þ¼‚°‹ Gð‰î¬ù‚ «è£¬õ ñŸÁ‹ ñ£PL‚


«è£¬õèO¡ îóMù‹ º¿â‡ Þùñ£è Þ¼‚è«õ‡´‹. â‰î
case- ¡ ñ£PL‚ «è£¬õ ñFŠ¹, switch- ¡ Gð‰î¬ù‚ «è£¬õ
ñFŠ¹ì¡ 制œ÷«î£ ܉î case ßÁ‚° GóL¡ 膴Šð£´
ñ£ŸøŠð´‹. switch ßP™ âˆî¬ù case ßÁèœ «õ‡´ñ£ù£
½‹ Þ¼‚èô£‹. Ýù£™, å¼ switch ßÁ‚°œ Þó‡´ case
ßÁèœ å«ó ñ£PL‚ «è£¬õ¬ò‚ ªè£‡®¼‚è‚Ã죶. switch
ßP¡ àìŸð°F‚°œ G¬ø«õŸøˆ¶‚°ˆ «î˜‰ªî´‚èŠð†ì case
266
ßP™ ªî£ìƒA, àìŸð°FJ¡ ÞÁF õ¬óJ«ô£ ܙô¶ å¼
break ߬ø„ ê‰F‚°‹ õ¬óJ«ô£ ܬùˆ¶ case ßÁèO¡ è†
ì¬÷èÀ‹ G¬ø«õŸøŠð´‹. å¼ °PŠH†ì case ßP¡ W¿œ÷
è†ì¬÷ˆªî£°F G¬ø«õŸøŠð†ìH¡ GóL¡ 膴Šð£´ switch- ¡
àìŸð°F¬ò M†´ ªõO«ò õ‰¶Mì break è†ì¬÷¬ò ðò¡
ð´ˆî «õ‡´‹. ޙ¬ô«ò™ Ü´ˆ¶œ÷ case ßP¡ è†ì¬÷ˆ
ªî£°FèÀ‹ G¬ø«õŸøŠð´‹.
â‰îªõ£¼ case -¡ ñ£PL‚ «è£¬õ ñFŠ¹‹ switch -¡ Gð‰
î¬ù‚ «è£¬õ ñFŠ¹‚° Gèó£Œ Þ™¬ôªòQ™, default ßÁ‚°Š
H¡Âœ÷ è†ì¬÷ˆ ªî£°F G¬ø«õŸøŠð´‹. switch- ¡ àìŸ
ð°FJ™ default ð°F ޙô£î«ð£¶, â‰îªõ£¼ case ßP¡ ñFŠ
¹‹ Gð‰î¬ù‚ «è£¬õJ¡ ñFŠ«ð£´ 制Š«ð£èM™¬ô âQ™
switch-¡ àìŸð°FJ½œ÷ â‰îªõ£¼ ßP¡ è†ì¬÷èÀ‹ G¬ø
«õŸøŠðì ñ£†ì£¶. default ßÁ è†ì£òñŸø¶. «î¬õªòQ™ °PŠ
Hìô£‹. àìŸð°FJ¡ ÞÁFJ™î£¡ Þ싪ðø«õ‡´‹ â¡ð
F™¬ô. ⃰ «õ‡´ñ£ù£½‹ Þ싪ðøô£‹. âOò èEî„ ªêò™
ð£´è¬÷ G¬ø«õŸø H¡ù™ if-else ܬñŠ¬ðŠ ðò¡ð´ˆF â¿
Fò Gó™, switch-case ߬øŠ ðò¡ð´ˆF â¿îŠð†´œ÷¶ 裇è:
#include <stdio.h>
main()
{ int a,b,c;
int choice;
printf(“Enter two integers: “);
scanf(“%d%d”, &a,&b); /*b ²Nò‹ ޙ¬ô*/
printf(“1. addition\n”); /* «î˜¾ 1 */
printf(“2. subtraction\n”); /* «î˜¾ 2 */
printf(“3. multiplication\n”); /* «î˜¾ 3 */
printf(“4. division\n”); /* «î˜¾ 4 */
printf(“Enter your choice: “);
scanf(“%d”, &choice);
switch(choice)
{
case 1:
c = a + b;
printf(“%d”, c);
break;
case 2:
c = a - b;
printf(“%d”, c);
break;
267
case 3:
c = a * b;
printf(“%d”, c);
break;
case 4:
c = a / b;
printf(“%d”, c);
break;
default:
printf(“the choice is out of range\n”);
}

މî Gó™ ÃÁG¬ô (Modular) ܬñŠH™ àœ÷¶. H¡ù™ if-


elseܬñŠ¹ ðò¡ð´ˆîŠð†ì Gó¬ô‚ 裆®½‹ 𮈶Š ¹K‰¶
ªè£œ÷ âO¬ñò£Œ àœ÷¶. îóŠð†ì ⿈¶, àJªó¿ˆî£ (vowel),
ªñŒªò¿ˆî£ (consonant) â¡ð¬î‚ è‡ìP»‹ Þ¡«ù£˜ ⴈ¶‚
裆´ Gó™ð°F 裇è:
char ch;
ch = ‘a’;
switch(ch)
{
case ‘a’:
case ‘e’:
case ‘i’:
case ‘o’:
case ‘u’: printf(“the given character is vowel”);
break;
default: printf(“the given character is consonant”);
}

«ñ«ô»œ÷ ⴈ¶‚裆®™, ch â¡Â‹ ñ£PJ¡ ñFŠ¹ ‘a’


â¡ð ºî™ case ‘êK’ â¡ø£Aø¶. ÜF™ break ßÁ ޙ¬ô
â¡ð, Gó™, Ü´ˆî case ßÁ‚°„ ªê™½‹. ܃°‹ break
ޙ¬ô. break ߬ø„ ê‰F‚°‹ õ¬ó Ü´ˆî´ˆî case ßÁèÀ‚°„
ªê™½‹. ÞÁFò£è case ‘u’: ߬ø ܬ컋. îóŠð†ì ⿈¶ ‘a’,
268
, ‘u’ ÞõŸÁœ â¶õ£è Þ¼‰î£½‹, Góô£ù¶ u-¾‚° õ‰¶
‘e’, ‘i’, ‘o’
«ê¼‹. ÜKò è†ì¬÷è¬÷ G¬ø«õŸÁ‹. given character is
vowel â¡ø ªêŒF F¬óJ™ 裆ìŠð´‹. Ü´ˆ¶, break è†ì¬÷
Þ¼Šð, Gó™, switch ߬øM†«ì ªõO«òÁ‹. îóŠð†ì ⿈¶
àJ˜ ⿈ ޙô£î«ð£¶, default ð°F‚°Kò è†ì¬÷èœ G¬ø
«õŸøŠð´‹. Üî¡H¡ Gó™, ªïO¾ ܬ승‚ °Pè¬÷ M†«ì
ªõO«òÁ‹.
4.6 膴Šð£†´‚ ßÁèœ (Control Statements)
ßP™ Gð‰î¬ù ‘êK’ âQ™, Üî£õ¶ if -™ àœ÷ åŠd†
if
´‚ «è£¬õJ¡ ñFŠ¹ ‘êK’ âQ™, if- ßP¡ àìŸð°F å«ó
ªò£¼ º¬ø ñ†´«ñ G¬ø«õŸøŠð´‹. Cô śG¬ô¬ñèO™,
°PŠH†ì Gð‰î¬ù ‘êK’ Ýè Þ¼‰¶ ªè£‡®¼‚°‹õ¬ó, å¼
è†ì¬÷ˆ ªî£°F¬ò F¼‹ðˆ F¼‹ð G¬ø«õŸø «õ‡®ò «î¬õ
Þ¼‚èô£‹. ވ«î¬õ¬ò G¬ø¾ªêŒò‚ 膴Šð£†´‚ (control)
ßÁèœ Üî£õ¶ ñ산‚ (looping) ßÁèœ «î¬õ. ñ산 (Loop)
â¡ð¶ GóL¡ å¼ ð°F. ªî£ìƒAò Þ숶‚«è e‡´‹ õ‰¶
«î¬õò£ù îì¬õèœ F¼‹ðˆ F¼‹ð G¬ø«õŸøŠð´‹ è†ì
¬÷èO¡ ªî£°F. C-ªñ£NJ™ Í¡Á õ¬èò£ù 膴Šð£†´‚
ßÁèœ (ñ산èœ) àœ÷ù. ܬõ: while, for,do while ÝAòù.
4.6.1 while ßÁ
°PŠH†ì Gð‰î¬ù ‘êK’ â¡ø G¬ôJ™ Þ¼‚°‹õ¬ó, è†
ì¬÷èO¡ ªî£°F¬òˆ F¼‹ðˆ F¼‹ð ªêò™ð´ˆî while ßÁ
ðò¡ð´Aø¶. while ßP™, è†ì¬÷ˆ ªî£°F‚°œ ¸¬ö»‹ G¬ô
J«ô«ò Gð‰î¬ù êK𣘂èŠð´Aø¶. (ñ산, âˆî¬ù º¬ø
ªêò™ð´ˆîŠðì «õ‡´‹ â¡ð¬î å¼ è†´Šð£†´ ñ£P Íô‹
b˜ñ£Q‚èô£‹). W«ö»œ÷ Gó™ å¡Á ºî™ ðˆ¶ õ¬óJô£ù
â‡è¬÷ Ü´ˆî´ˆî õKèO™ F¬óJ™ 裆´‹. ރ«è, printf( )
ªêò™Ã¬ø 10 º¬ø ªêò™ð´ˆî ‘ñ산’ «î¬õŠð†´œ÷¶.

269
#include <stdio.h>
main()
{
int i;
i = 1; /* ªî£ì‚è ñFŠH¼ˆî™ */
while(i <= 10) /*Gð‰î¬ù */
{
printf(“%d\n”, i); /*ªêòô£‚è‚ ßÁ */
i = i + 1; /*¹¶ŠHˆî™ */
}
}

މî GóL™, i â¡Â‹ ñ£P 膴Šð£†´ ñ£Pò£èŠ ðò¡ð´Aø¶.


while ñì‚A¡ G¬ø«õŸøˆ¬î ܶ«õ 膴Šð´ˆ¶Aø¶. while
ßÁ‚° º¡«ð 膴Šð£†´ ñ£P º¬øŠð® ÜPM‚èŠð†´,
ªî£ì‚è ñFŠH¼ˆîŠð†´œ÷¶. މî Gó™, ºî™ ðˆ¶ Þò™¹
â‡è¬÷‚ 裆ì«õ‡´‹ â¡ð‹, 裆ì«õ‡®ò ºî™ â‡
1 â¡ð‹ 膴Šð£†´ ñ£PJ™ ªî£ì‚è ñFŠð£è 1 Þ¼ˆîŠ
ð†´œ÷¶. ñ산, 10 º¬ø G¬ø«õŸøŠðì«õ‡´‹. âù«õ Gð‰
î¬ù i <= 10 âù ܬñ‚èŠð†´œ÷¶. °PŠð†ì Gð‰î¬ù ‘êK’
âQ™ while ñì‚A¡ àìŸð°F 10 º¬ø G¬ø«õŸøŠð´‹. åš
ªõ£¼ º¬ø ñ산 G¬ø«õŸøŠð´‹ «ð£¶‹ 膴Šð£†´ ñ£P
J¡ ñFŠ¹ 1 I°‚èŠð´Aø¶. è£óí‹, êKò£èŠ ðˆ¶º¬ø ñ†
´«ñ ñ산 G¬ø«õŸøŠðì«õ‡´‹. «ê£î¬ù Gð‰î¬ù ‘îõÁ’
âQ™, GóL¡ 膴Šð£´ ñì‚A¬ù M†´ ªõO«ò õ‰¶M´‹.
ªõO«òPòH¡, ñì‚A¡ àìŸð°F¬ò Ü´ˆ¶ Þì‹ ªðŸÁœ÷
è†ì¬÷JL¼‰¶, GóL¡ ªêòô£‚è‹ ªî£ì¼‹. e‡´‹ 强¬ø
Gó¬ô àŸÁ «ï£‚°ƒèœ. 膴Šð£†´ ñ£PJ™ ªî£ì‚è ñFŠ¹
Þ¼ˆîŠð†ì àì«ù Üî¡ ñFŠ¹ while ßP™ ðK«ê£F‚èŠð´
Aø¶. while ñ산 º®õ„ êŸÁ º¡ð£è (ªïO¾ ܬ승‚°
P‚° º¡ð£è) 膴Šð£†´ ñ£PJ¡ ñFŠ¹, 1 I°‚èŠð´Aø¶.
while ßP¡ ªî£ìó¬ñŠ¹:
/* 膴Šð£†´ ñ£Pè¬÷ˆ ªî£ìƒA¬õˆî™ */
while (Gð‰î¬ù)
{
.................. ; /* è†ì¬÷èœ */
.................. ; ä
膴Šð£†´ ñ£P¬òŠ ¹¶ŠHˆî™ ;
}
270
膴Šð£†´ ñ£PJ¡ ñFŠ¹, while ßP¡ Gð‰î¬ù«ò£´ åŠ
H†´Š 𣘂èŠð´Aø¶. while ñì‚A¬ù º¬øò£è º®ˆ¶¬õ‚è
ñ산‚°œ 膴Šð£†´ ñ£P º¬øò£èŠ ¹¶ŠH‚èŠðì«õ‡´‹.
i- ¡ ñFŠ¬ðŠ ¹¶ŠH‚°‹.

i = i +1 ;

â¡Aø õK, M´ð†´Š «ð£°ñ£J¡, 膴Šð£†´ ñ£PJ¡ ñFŠ¹


⊫𣶋 1 Ýè«õ Þ¼‚°‹. ñ산 ⊫𣶋 º®¾‚° õó£¶.
«ñŸè‡ì GóL™ ªî£ì‚è ñFŠH¼ˆî™, Gð‰î¬ù, ¹¶ŠH‚
°‹ è†ì¬÷ ÝAòõŸ¬ø c‚AM†´Š 𣘈, printf (“%d\n”, i) ;
â¡Â‹ å«óªò£¼ è†ì¬÷ ñ†´«ñ I…²Aø¶. ܶ«õ, މî
GóL¡ «ï£‚般î G¬ø«õŸP ¬õ‚Aø¶.
HP«î£˜ ⴈ¶‚裆´ 𣘊«ð£‹.
1, 2, 4, 7, 11, 16........ â¡ø ⇠õK¬êJ™ 15 â‡è¬÷‚ 裆´õ
 å¼ Gó¬ô â¿FŠ 𣘊«ð£‹.
⇠õK¬êJ™ Þó‡ì£õ¶ â‡, º‰¬îò â‡«í£´ å¡
¬ø‚ Æ®òH¡ ªðøŠð´Aø¶. Í¡ø£õ¶ â‡, º‰¬îò â‡
«í£´ Þó‡¬ì‚ Æ®òH¡ ªðøŠð´Aø¶. è£õ¶ â‡,
º‰¬îò â‡«í£´ Í¡¬ø‚ Æ®òH¡ ªðøŠð´Aø¶. ޚ
õ£ø£èŠ Hø â‡èÀ‹ ªðøŠð´A¡øù. މî ñ산 15 º¬ø
G¬ø«õŸøŠðì«õ‡´‹. Þ«î£ Gó™:

#include <stdio.h>
main()
{
int term;
int i;
i = 1; /* ªêòô£‚è ñ£P*/
term = 1; /*膴Šð£†´ ñ£P*/
while(term <=15)
{
printf(“%d\n”, i);
i = i + term;
term = term + 1;
}
}

271
މî GóL™, term â¡Â‹ ñ£P, ñì‚A¡ ªêò™ð£†¬ì‚ è†
´Šð´ˆîŠ ðò¡ð´ˆîŠð†´œ÷¶. i â¡Â‹ ñ£P ªêòô£‚è ñ£P
ò£èŠ ðò¡ð†´œ÷¶. މî GóL™ ܬñ‰¶œ÷ î¼‚è‹ (logic),
i=i+term â¡Â‹ è†ì¬÷¬ò„ ꣘‰¶œ÷¶. õK¬êJ™ º‰¬îò
â‡µì¡ term -¡ ñFŠ¬ð‚ Æ® Ü´ˆî ⇠ªðøŠð´Aø¶.
嚪õ£¼ º¬ø ñ산 ªêò™ð´‹«ð£¶‹ term-¡ ñFŠ¹ 1 I°‚èŠ
ð´Aø¶. while ñì‚A¬ùŠ ðò¡ð´ˆF»œ÷ މî GóL¡ ªõŸP,
膴Šð£†´ ñŸÁ‹ ªêòô£‚è ñ£Pè¬÷ º¬øò£èŠ ðò¡ð´ˆ¶
õ¬î«ò ꣘‰F¼‚Aø¶. 膴Šð£†´ ñ£PJ™ ªî£ì‚è ñFŠH
¼ˆî «õ‡´‹; Gð‰î¬ùJ™ ðK«ê£F‚è «õ‡´‹, ñì‚Aœ
¹¶ŠH‚è «õ‡´‹. ªêòô£‚è ñ£P»‹ î¡ ðƒ¬è ݟP»œ÷¶.
æ˜ while ßPœ Þ¡«ù£˜ while ߬øŠ H¡ùô£Œ ܬñ‚è
º®»‹. àœO¼‚°‹ while ñ산 ªõO while ñ사èMì «õè
ñ£è„ ªêò™ð´‹. Üî£õ¶ ªõO while ñ산 º®¾‚° õ¼‹
º¡«ð àœ while ñ산 º®¾‚° õ‰¶M´‹. 嚫õ£˜ while ñì‚
°‚°‹ 膴Šð£†´ ñ£PèO™ º¬øò£èˆ ªî£ì‚è ñFŠH¼ˆî
«õ‡´‹. ñì‚°èœ F¼‹ðˆ F¼‹ð„ ªêò™ð´‹ â‡E‚¬è
¬ò‚ 膴Šð´ˆî º¬øò£ù Gð‰î¬ù¬ò ܬñ‚è«õ‡´‹.
ñì‚Aœ, 膴Šð£†´ ñ£Pèœ º¬øŠð® ¹¶ŠH‚èŠðì«õ‡´‹.
ⴈ¶‚裆´:
å¼ Gó™ ⿶è: 1 强¬ø, Ü´ˆî õKJ™ 2 Þ¼º¬ø,
Ü´ˆî õKJ™ 3 º‹º¬ø... ޚõ£ø£è 10 õ¬ó F¬óJ™ 裆ì
«õ‡´‹. ðˆî£õ¶ õKJ™ 10 ðˆ¶º¬ø Þ싪ðø «õ‡´‹.
މî G󽂰 Þ¼ ñì‚°èœ «î¬õ. àœ-ñ산 âˆî¬ù º¬ø
ªêò™ðì«õ‡´‹ â¡ð¬î ªõOñ산 b˜ñ£Q‚°‹. Üî£õ¶,
ªõO-ñì‚A¡ 膴Šð£†´ ñ£PJ¡ ñFŠ¹‚° ãŸð, 嚪õ£¼
º¬ø»‹ àœ-ñ산 F¼‹ð„ ªêò™ð´‹ â‡E‚¬è ܬñ»‹.
Gó¬ô «ï£‚°è:

272
#include <stdio.h>
main()
{ int i, j;
i = 1;
while(i<=10)
{
j = 1;
while(j <= i)
{
printf(“%d “, i);
j++;
}
printf(“\n”);
i++;
}
}

މî GóL¡ ªõOf´ ޚõ£Á ܬñ»‹:


1
2 2
3 3 3
...................
1 0 10 10 10 10 10 10 10 10 10
މî GóL™, 嚫õ£˜ ⇵‚°‹ àœ-ñ산 i îì¬õèœ
F¼‹ð¾‹ Þò‚èŠð´Aø¶. i â¡ð¶ ªõO-ñì‚A¡ 膴Šð£†´
ñ£Pò£°‹.
4.6.2 for ßÁ
C-ªñ£NJ¡ for ñ산, while ßP¬ù ²¼‚ªè¿ˆ¶ º¬øJ™
⿶õ«î Ý°‹. ⴈ¶‚裆ì£è, å¼ C-GóL¡ å¼ ð°F¬ò‚
裇è:
x=1;
while (x<=10)
{
printf(“%d\n”, x);
x++;
}
273
ފð°F¬ò for ñ산Š ðò¡ð´ˆF‚ W«ö àœ÷õ£Á ñ£ŸP
ò¬ñ‚èô£‹:
for(x=1; x<=10; x++)
{
printf(“%d\n”, x);
}

while ñì‚A™ å¼ ªî£ì‚è ñFŠH¼ˆî™ (x=1), å¼ ðK«ê£î¬ù


(x<=10), å¼ ñFŠ¹ I°Š¹ (x++) ÝAò Í¡Á ð®G¬ôèœ Þ¼Š
ð¬î «ï£‚°è. މî Í¡Á ð°Fè¬÷»‹ å«ó õKJ™ ܬñˆ
¶‚ªè£œ÷ for ñ산 Þì‹ ªè£´‚Aø¶. for ñì‚A½‹, ¸¬ö»‹
G¬ôJ«ô«ò Gð‰î¬ù ðK«ê£F‚èŠð´Aø¶. for ñì‚A¡ àìŸ
ð°F 10º¬ø ªêò™ð´Aø¶. ÞF™, 膴Šð£†´ ñ£PJ™ ºîL™
ªî£ì‚è ñFŠ¹ Þ¼ˆîŠð´Aø¶. Hø° Üî¡ ñFŠ¹ ðK«ê£F‚èŠ
ð´Aø¶. Gð‰î¬ù ‘êK’ âQ™, ñì‚A¡ àìŸð°F ªêò™ð´ˆîŠ
ð´Aø¶. ޙ¬ô«ò™, ñ산 º®ˆ¶‚ªè£œ÷Šð†´, ñ산‚°
Ü´ˆ¶ Þ싪ðŸÁœ÷ ßÁè¬÷ G¬ø«õŸøˆ ªî£ìƒ°Aø¶.
ñì‚A¡ àìŸð°F ªêò™ð´ˆîŠð†ìH¡, GóL¡ 膴Šð£†´
e‡´‹ for ßÁ‚°œ õ¼‹. 膴Šð£†´ ñ£P ¹¶ŠH‚èŠð´‹.
Ü´ˆ¶, Gð‰î¬ù ðK«ê£F‚èŠð´‹. Gð‰î¬ù ‘êK’ Ýè Þ¼‚
°‹õ¬ó ñ산 F¼‹ðˆ F¼‹ð Þò‚èŠð´‹.
for ñì‚A¡ ªî£ìó¬ñŠ¹:
for (ªî£ì‚è ñFŠ¹ Þ¼ˆî™; Gð‰î¬ù; ¹¶ŠHˆî™)
{
ñì‚A¡ àìŸð°F ;
}
for ñ사軋 å¡Pœ å¡ø£Œ ܬñ‚èô£‹. 1 å¼ º¬ø,
2 Þ¼º¬ø, 3 º‹º¬ø, .......... ⿶‹ Gó¬ô H¡ù™ for ñ산
ðò¡ð´ˆF â¿FŠ 𣘊«ð£‹:

274
#include <stdio.h>
main()
{
int i;
int j;

for(i=1;i<=10;i++)
{

for(j=0;j<=i;j++)
printf(“%d “, i);
àœ-ñ산
Inner Loop

printf(“\n”);
}
}

àœ for ñì‚Aœ å«óªò£¼ è†ì¬÷ àœ÷¶. ªõO for


ñì‚Aœ Þó‡´ è†ì¬÷èœ àœ÷ù. ñì‚A¡ àìŸð°FJ™
å«óªò£¼ è†ì¬÷ ñ†´«ñ Þ¼‚°ñ£J¡, ñì‚A¡ àìŸð°
F¬ò ªïO¾ ܬ승‚°PèÀ‚°œ ܬñ‚è «õ‡®òF™¬ô.
ñ산 ðò¡ð´ˆF„ ªêŒòŠð´‹ å¼ ðE¬ò for ñ산Š
while
ðò¡ð´ˆF»‹ ªêŒò º®»‹. âˆî¬ù º¬ø ñì‚A¬ù„ ªêò™
ð´ˆî«õ‡´‹ â¡Aø â‡E‚¬è ¶™Lòñ£è º¡«ð ªîK»
ªñQ™ ܊ðE‚° for ñì‚A¬ùŠ ðò¡ð´ˆ¶õ¶ Cø‰î Góô£‚è
ï¬ìº¬ø Ý°‹. âˆî¬ù º¬ø â¡ð¬î ñ산 ªî£ìƒ°‹
º¡«ð G„êJ‚è º®ò£î śG¬ôèO™ while ñ산 àè‰î¶.

275
ⴈ¶‚裆´:

#include <stdio.h>
main()
{
char ch;
int count = 0;
ch = getchar();
while(ch != ‘\n’) /* Gð‰î¬ù*/

{
count++;
ch = getchar();
}

printf(“the number of characters entered: %d\n”, count);


}

«ñŸè‡ì ⴈ¶‚裆®™, ðòù˜ M¬êŠðô¬èJ™ Enter


M¬ê¬ò Ü¿ˆ¶‹ õ¬ó ñ산 ªêò™ð´‹. ܶõ¬óJ™, âˆ
î¬ù º¬ø ñ산 ªêò™ðì«õ‡´‹ â¡ð¬î º¡Ã†®«ò
èE‚躮ò£¶. ch â¡Â‹ ñ£P, ¹Fò õK‚ °P»¼¬õ (‘\n’) M¬êŠ
ðô¬è õNò£èŠ ªðŸø¾ì¡ (ðòù˜ Enter M¬ê¬ò Ü¿ˆFò
¾ì¡), Gð‰î¬ù ‘îõÁ’ â¡Á Ý°‹. GóL¡ 膴Šð£´ while
ñì‚A¡ àìŸð°F‚° Ü´ˆ¶ Þ싪ðŸÁœ÷ printf() ßÁ‚°„ ªê¡Á
M´‹. Þ‰îŠ ðE‚° while ñ산 àè‰î¶. è£óí‹, ðòù˜ âˆî¬ù
⿈¶è¬÷ àœk´ ªêŒõ£˜ â¡ð¬îˆ ¶™Lòñ£è º¡«ð èE‚è
º®ò£¶. މî GóL™, M¬êŠðô¬è JL¼‰¶ å¼ «ïóˆF™ æ˜
⿈¬îŠ ªðÁõ getchar() â¡Â‹ ªêò™ÃÁ ðò¡ð´ˆîŠð†
´œ÷¶. Þ¶ º¡-õ¬óòÁ‚èŠð†ì ªêò™ Ãø£°‹.
4.6.3 do-while ßÁ
ñì‚A™ ¸¬ö»‹ G¬ôJ«ô«ò Gð‰î¬ù êK𣘂èŠ
while
ð´Aø¶. ºî™ îì¬õ«ò Gð‰î¬ù ‘îõÁ’ ÝAŠ«ð£ù£™, ñì‚
A¡ àìŸð°F 强¬øÃì„ ªêò™ð´ˆîŠð죶. do-while ßP™,
ªõO«òÁ‹ G¬ôJ™î£¡ Gð‰î¬ù êK𣘂èŠð´Aø¶. âù«õ,
Gð‰î¬ù ‘êK’ ܙô¶ ‘îõÁ’ âŠð® Þ¼ŠH‹, ñì‚A¡ àìŸ
276
ð°F °¬ø‰î¶ å¼ º¬ø«ò‹ ªêò™ð´ˆîŠð´‹. do-while ñì‚
A¡ ÞÁFJ™ Gð‰î¬ù êK𣘂èŠð†´, ‘êK’ âQ™ ñ산 e‡
´‹ å¼ º¬ø ªêò™ð´ˆîŠð´‹. Gð‰î¬ù ‘êK’ Ýè Þ¼‚°‹
õ¬ó ބªêòô£‚è‹ ªî£ì¼‹. Gð‰î¬ù ‘îõÁ’ Ýù¾ì¡, ñ산
º®¾‚° õ¼‹. GóL¡ 膴Šð£´, do-while ßÁ‚° Ü´ˆ¶œ÷
è†ì¬÷‚° ñ£ŸøŠð´‹.
ⴈ¶‚裆´:
x = 14;
do
{
y = x + 2;
x—;
} while (x > 0);

މî do-while ßP™, x-¡ ªî£ì‚è ñFŠ¹ â¡ùõ£è Þ¼‰î£½‹,


y=x+2;
x -- ;

â¡ø Þ¼ è†ì¬÷èÀ‹ ºî™º¬ø ªêò™ð´ˆîŠð´‹. Üî¡Hø°


x > 0 â¡Â‹ Gð‰î¬ù ñFŠHìŠð´‹. x, 0 -äMìŠ ªðKî£è Þ¼Š
H¡, ñì‚A¡ àìŸð°F e‡´‹ ªêò™ð´ˆîŠð´‹. Hø° x > 0
â¡Â‹ Gð‰î¬ù e‡´‹ ñFŠHìŠð´‹. x-¡ ñFŠ¹ 0-äMìŠ
ªðKî£è Þ¼‚°‹õ¬ó ñì‚A¡ àìŸð°F e‡´‹ e‡´‹ ªêò™
ð´ˆîŠð´‹. x-¡ ñFŠ¹ 0 Ý°‹«ð£«î£, âF˜ñ (negative) â‡
Ý°‹«ð£«î£ do-while ßP¡ ªêòô£‚è‹ GÁˆîŠð´‹. Ýè, do-
while ñì‚A™ àìŸð°F °¬ø‰î¶ å¼ º¬ø«ò‹ ªêò™ð´ˆ
îŠð´‹.
4.7 ÜEèœ (Arrays)
å¼ð®ˆî£ù àÁŠ¹èO¡ Üî£õ¶ å«ó îóMù àÁŠ¹èO¡
ªî£°Š¹ ‘ÜE’ âùŠð´Aø¶. ÜEè¬÷Š ðò¡ð´ˆFù£™ ðô
«ïóƒèO™ Góô£‚è‹ (programming) âOî£AŠ «ð£°‹. ⴈ¶‚裆
ì£è, Í¡Á º¿â‡èO™ ªðKò â‡¬í‚ è‡ìPò «õ‡´‹.
Í¡Á îQˆîQ ñ£Pè¬÷Š ðò¡ð´ˆî º®»‹. âOò if ßÁ
è¬÷Š ðò¡ð´ˆF â¿îŠð†ì Gó¬ô‚ W«ö 裇è:

277
#include <stdio.h>
main ()
{ int a, b, c;
int max;
printf(“Enter the 3integers:”);
scanf(“%d %d %d”,&a,&b,&c);
max = a;
if(b > max)
max = b;
if(c > max)
max = c;
printf (“%d is the maximum “,max);
}

މî Gó¬ô, 100 â‡èO™ ªðKò â‡¬í‚ è‡ìP»ñ£Á


c†®Š«ð£‹ âQ™, 100 îQˆîQ ñ£Pè¬÷Š ðò¡ð´ˆî«õ‡´‹.
˟Á‚° «ñŸð†ì if- ßÁè¬÷Š ðò¡ð´ˆî «õ‡®J¼‚°‹.
Þ¶ Gó¬ô ÜFè„ C‚èô£‚°‹. Iè c‡ì°‹. «ñ½‹, Þ¶
êKò£ù Góô£‚è õNº¬ø Ý裶. Þ‰î„ C‚è¬ôˆ b˜‚è âOò
õN 100 º¿ â‡èÀ‚è£ù å¼ ÜE¬ò ÜPMŠð«î:
int a [100];
Number of
Þù‹
type number of
elements
ÜEŠ
Array
arrayname àÁŠ¹èO¡
elements
name
ªðò˜ â‡E‚¬è

å¼ õK¬ê‚°œ Þ¼‚°‹ 100 ªõš«õÁ â‡è¬÷ àKò ²†´


⇠(index) Íô‹ ܵ躮»‹. 100 ªõš«õÁ ñFŠ¹è¬÷ Þ¼ˆF
¬õ‚è 100 ñ£Pè¬÷Š ðò¡ð´ˆî «õ‡®ò C‚èŸð£†¬ì‚ °¬ø‚
Aø¶. æ˜ ÜE ÜPMŠ¹, ÜEJ¡ ªðò¬ó‚ °PŠH´Aø¶;
Üî¡ àÁŠ¹èO¡ îóMùˆ¬îˆ ªîKM‚Aø¶. ê¶ó ܬ승‚°P
èÀ‚°œ å¼ ñ£PL‚ «è£¬õ¬ò ðò¡ð´ˆî «õ‡´‹. ܶ
àÁŠ¹èO¡ â‡E‚¬è¬ò‚ °P‚Aø¶. Üî¡ ñFŠ¹ ⊫𣶋
0-äMìŠ ªðKòî£è Þ¼‚è «õ‡´‹. æ˜ ÜEJ¡ «êIŠHì‹
â¡ð¶ ܉î ÜEJ½œ÷ ܬùˆ¶ àÁŠ¹è¬÷»‹ «êI‚èˆ
«î¬õò£ù Þìˆ¬î‚ °P‚Aø¶. æ˜ ÜEJ¡ àÁŠ¹èœ ºî™
278
àÁŠH™ ªî£ìƒA è¬ìC àÁŠ¹ õ¬ó, G¬ùõèˆF™ Ü´ˆî´ˆî
Þ¼ŠHìƒèO™ Þ¼ˆîŠð´A¡øù.
C-ªñ£NJ™ ÜE (array) â¡ð¶ å¼ ðKñ£í‹ ªè£‡ìî£è
Þ¼‚èô£‹ ܙô¶ ðôðKñ£í‹ ªè£‡ìî£è¾‹ Þ¼‚èô£‹. ÜE
J¡ àÁŠ¹è¬÷ ²†´ â‡èœ Íô‹ Üµè º®»‹. 10 º¿ â‡
èœ ªè£‡ì æ˜ å¼ðKñ£í ÜE¬ò ޚõ£Á ÜPM‚èô£‹.
int a[10] /* ÜE ÜPMŠ¹‚ ßÁ */
Gó™ ªêò™ðìˆ ªî£ìƒ°‹ªð£¿¶, Gó™ªðò˜ŠH (Compiler)
މî õK¬êJ¡ 10 àÁŠ¹è¬÷ Þ¼ˆF¬õ‚è ºî¡¬ñ G¬ùõ
èˆF™ 20 ¬ð†´è¬÷ 嶂A¬õ‚°‹. è£óí‹ å¼ º¿â‡
µ‚° Þó‡´ ¬ð†´ G¬ùõè Þì‹ «î¬õ. މî 10 àÁŠ¹
èÀ‹ Ü´ˆî´ˆ¶œ÷ G¬ùõè ÞìƒèO™ Þ¼ˆîŠð´A¡øù. ÜE
J¡ ²†´â‡ 0-™ ªî£ìƒ°‹. æ˜ ÜEJ™ n àÁŠ¹èœ Þ¼‚°
ñ£J¡ 0-™ ªî£ìƒA n-1 õ¬ó»œ÷ ²†´ â‡èœ Íô‹ ÜõŸ¬ø
ܵèô£‹. ÜE àÁŠ¹èO™ W«ö àœ÷õ£Á ñFŠH¼ˆîŠð´
A¡øù.
a [0] = 10;

a[1] = 20 ;

...................

a[9] = 100;

ÜEJ¡ ²†´ â‡Eì™ ðŸPò CøŠ¹„ ªêŒF â¡ùªõQ™,


²†´ â‡è¬÷‚ ¬èò£÷ å¼ ñì‚A¬ùŠ ðò¡ð´ˆî º®»‹.
ⴈ¶‚裆ìì£è, W«ö»œ÷ Gó™ð°F, ÜEJ¡ àÁŠ¹èO™ õK
¬êò£èˆ ªî£ì‚è ñFŠ¹ Þ¼ˆ¶Aø¶.

int i;
int a[10];
for(i=0;i<10;i++)
scanf(“%d”, &a[i]);

«ñ«ô»œ÷ scanf() ßP™ àœ÷ Þó‡ì£õ¶ Ü÷¹¼ &a[i]


â¡ð¶, i = 0 ºî™ 9 õ¬ó Þ¼‚°‹ G¬ôJ™ i-õ¶ àÁŠH¡
ºèõK¬ò„ ²†´Aø¶. scanf() ªêò™ÃÁ M¬êŠðô¬èJL¼‰¶ ñFŠ
279
H¬ùŠ ªðŸÁ, G¬ùõèˆF™ àKò ÞìˆF™ (ºèõKJ™) Þ¼ˆF
¬õ‚Aø¶.
æ˜ ÜEJ™ ފ𮻋 ªî£ì‚è ñFŠH¼ˆîô£‹.
int a[3] = {10,15,20} ;

ÜEJ¡ àÁŠ¹èœ G¬ùõèˆF™ ޚõ£Á Þ¼ˆîŠð†®¼‚°‹:


948 950 952 Ž ºèõK
10 15 20 Ž àÁŠ¹èO¡ ñFŠ¹èœ
a[0] a[1] a[2] Ž àÁŠ¹è¬÷ ܵ°‹ ªðò˜èœ
嚪õ£¼ º¿â‡µ‹ 2 ¬ð†´ G¬ùõ般î ⴈ¶‚
ªè£œAø¶. Gó™ªðò˜ŠH (Compiler) ªî£ì˜„Cò£è ÝÁ ¬ð†´è¬÷
嶂Aˆ î¼Aø¶. Þ¶ G¬ùõèˆ ªî£°F (block of memory) âùŠ
ð´Aø¶. ވªî£°FJ¡ ªî£ì‚è ºèõK ðìˆF™ 致œ÷ð®
948. a[0], a[1], a[2] ÝAò àÁŠ¹èO¡ ºèõKèœ º¬ø«ò 948, 950,
952 Ý°‹.
ºî™ àÁŠH¡ ºèõK &a[0] â¡Á °PŠHìŠð´Aø¶. ïñ¶
ⴈ¶‚裆®™ Þ‰î ºèõK 948 Ý°‹. Þ‰î ºèõKJ™ ðFõ£A
»œ÷ ñFŠ¹ 10. a[0] â¡ø, àÁŠH¡ ªðò˜ Íôñ£è މî ñFŠ¬ðŠ
ªðŸÁ‚ªè£œ÷ º®»‹. âù«õ, a[0] -¡ ñFŠ¹ 10, ºèõK 948
âù‚ ªè£œ÷«õ‡´‹. Gó™ªðò˜ŠH, މî ÜE‚°Kò G¬ù
õèˆ ªî£°F¬ò 嶂W´ ªêŒîHø°, ܈ªî£°FJ¡ ªî£ì‚è
ºèõK¬ò (948), ÜEJ¡ ªðòK«ô«ò Þ¼ˆF¬õ‚Aø¶. âù«õ,
a, &a[0] ÝAò Þ󇴫ñ ÜEJ¡ ªî£ì‚è ºèõK¬ò‚ °P‚A¡
øù. ‘ÜEJ¡ ªðò˜ a, ÜE¬ò„ ²†´Aø¶’ âù„ ªê£™ôô£‹.
Þ𣼜, a, ªî£ì‚è ºèõK¬ò„ ²†´Aø¶ â¡ð‹. «õÁ
õ¬èJ™ ªê£™õªîQ™, a, ÜEJ¡ ºî™ àÁŠH¬ù„ ²†´Aø¶
âùô£‹.
948 950 952
a Ž
10 15 20

a[0] a[1] a[2]

 㟪èù«õ ÜP‰îð® àœ«ï£‚° ªêòŸ°P¬òŠ


ðò¡ð´ˆF G¬ùõè ÞìˆF½œ÷ ñFŠ¬ðŠ ªðŸÁˆîó º®»‹.
âù«õ, *a â¡ð¶ 10 â¡Â‹ ñFŠ¬ðŠ ªðŸÁˆî¼‹. «ñ½‹,
280
a[0]

*a
*(&a[0])
ÝAò Í¡Á «è£¬õèÀ«ñ 10 â¡Aø ñFŠ¬ð«ò  â¡ð
îPè. Ýè,
a[0] ⇔ *a ⇔ *(&a[0])
âù„ ªê£™ôô£‹. ރ«è, ⇔ â¡Â‹ °Pf´, “â™ô£õ¬èJ½‹
Þ󇴋 å¡«ø” â¡Â‹ ªð£¼¬÷ˆ î¼Aø¶. ނ°Pf´
C-ªñ£N ªêòŸ°P Ü¡Á.
«ñŸè‡ì M÷‚èƒèOL¼‰¶, æ˜ ÜEJ¡ ªî£ì‚è ºèõK
(ܙô¶ î÷ ºèõK) ܉î ÜEJ¡ ªðòK«ô«ò Þ¼ˆîŠð´A
ø¶ â¡ð¬îŠ ¹K‰¶ ªè£‡®¼Šd˜èœ. ÜEJ¡ ªðò˜, ‘ºèõ
K¬ò‚’ ªè£‡®¼Šð ܶ å¼ ²†´ (pointer) ÝAø¶. ܉îŠ
ªðò˜, ÜEJ¡ ºî™ àÁŠH¬ù„ ²†®‚ªè£‡®¼‚Aø¶. ÜE
J¡ ªðò˜, ⊫𣶋 õK¬êJ¡ ªî£ì‚è ºèõK¬ò„ ²†®‚
ªè£‡®¼‚°‹ â¡ð¬î ñùF™ ªè£œè. æ˜ ÜEJ¡ î÷ ºè
õK¬ò (base address) ñ£ŸPò¬ñ‚è º®ò£¶. Üî£õ¶, ÜEJ¡
ªðò˜ Þó‡ì£õ¶ àÁŠ¬ð„ ²†®‚ªè£‡®¼‚°ñ£Á ñ£ŸPò¬ñ‚è
º®ò£¶. ÜEJ¡ ªðòK™ Þ¼ˆîŠð†´œ÷ ºèõK¬ò ñ£ŸPò
¬ñ‚è º®ò£¶ â¡ð ܶ ‘²†´ ñ£PL’ (pointer constant) ÝAø¶.
ÜEèÀ‹ ²†´èÀ‹ å¡Á‚ªè£¡Á ªï¼‚èñ£ù ªî£ì˜¹
¬ìò¬õ. x â¡Â‹ ²†´ ñ£P¬ò ⴈ¶‚ªè£œ«õ£‹.
int *x;

㟪èù«õ M÷‚Aòð®, Í¡Á º¿â‡ àÁŠ¹èœ ªè£‡ì


æ˜ ÜE¬ò ⴈ¶‚ªè£œ«õ£‹.
int a[3] = {10, 15, 20};

ÞF™ x â¡ð¶ å¼ ²†´ ñ£P (pointer variable). Þ¶ int Þù‹


â¡ð, Þ¡«ù£˜ int Þù ñ£PJ¡ ºèõK¬ò ãŸÁ‚ªè£œÀ‹.
a â¡ð¶, æ˜ int Þù ñFŠ¬ð„ ²†´‹. Üî£õ¶, ÜEJ¡ ºî™
àÁŠH¬ù„ ²†´‹ ²†´ ñ£PL (pointer constant) ÜEJ¡ î÷ ºè
õK¬ò x â¡Â‹ ²†´ ñ£PJ™ Þ¼ˆF ¬õ‚躮»‹.
281
x=a;

ފ«ð£¶, x â¡Â‹ ²†´ ñ£P, ÜEJ¡ ªî£ì‚è ºèõK


¬ò„ ²†®‚ ªè£‡®¼‚°ñ£Á ªêŒ¶œ«÷£‹. x â¡ð¶ (²†´)
ñ£P (variable) â¡ð, Gó™ ÞòƒA‚ªè£‡®¼‚°‹ «ð£«î Üî¡
ñFŠ¬ð ñ£ŸPò¬ñˆ¶, ÜEJ™ «õªø‰î àÁŠH¬ù»‹ ²†´
ñ£Á ªêŒò º®»‹. ވî¬èò ²†´‚ èí‚W´ (pointer arithmatic)
C-ªñ£NJ¡ à¡ùîñ£ù CøŠ¹‚ÃÁ Ý°‹.
²†´è¬÷‚ ªè£‡´ W›‚裵‹ ªêò™ð£´è¬÷ G蛈î
º®»‹:
l å¼ ²†®¡ ñFŠH™ å¼ º¿â‡¬í‚ Æì«õ£, èN‚
è«õ£ º®»‹.
l Þó‡´ ²†´èO¡ ñFŠ¹èO¬ì«ò èNˆî™ ªêŒòº®»‹.
W«ö»œ÷ M÷‚èŠ ðì‹ è£‡è:
948 950 952

10 15 20
a Ž
a[0] a[1] a[2]

â¡ø ßP¡ è£óíñ£è, x, a ÝAò Þ󇴫ñ ÜEJ¡


x = a
ºî™ àÁŠ¬ð«ò ²†®‚ªè£‡´œ÷ù. Üî£õ¶, x, a Þ󇴋 948
â¡Â‹ ºèõK¬ò„ ²†´A¡øù. Þ󇮽‹ 0-ä‚ Ã†®ù£™, x, a
ÝAòõŸP¡ ºèõK ñFŠ¹èO™ âšMî ñ£Ÿøº‹ ãŸð죶. àœ
«ï£‚° ªêòŸ°P * ðò¡ð´ˆF Ü‰î ºèõKJ½œ÷ ñFŠH¬ùŠ
ªðŸÁ‚ªè£œ÷ º®»‹. âù«õ, *(a+0), * (x+0) ÝAò Þ󇴫ñ 10
â¡Â‹ ñFŠ¬ðŠ ªðŸÁˆ î¼A¡øù. *(a+0) â¡Â‹ «è£¬õ, ÜE
J™ ºî™ àÁŠH¡ ñFŠ¬ð ܵ°õîŸè£ù °Pñ£ù‹ (notation)
Ý°‹. ÜE¬êJ™ ºî™ àÁŠH¡ ñFŠ¬ð õö‚èñ£è a[0] â¡Â‹
ÜE‚ °Pñ£ù‹ ªè£‡´ ªðø º®»‹ â¡ð¬î ÜP«õ£‹. W«ö
»œ÷ G蘊ð£´è¬÷‚ 裇è:
x+0 ⇔ a+0

*( x + 0 )⇔ *( a + 0 )

*( a + 0 ), a[0] ÝAò Þ󇴋 å¡«ø â¡ð,


* (x+0) ⇔x[0]
282
â¡Á â¿î º®»‹. ÞF™, x â¡Â‹ ²†´ ñ£P»ì¡ 0 â¡Â‹
W›å†´ (subscript) ܙô¶ ²†´ ⇠(index) «ê˜ˆ¶, ܶ ²†®‚
ªè£‡®¼‚°‹ ÜEJ¡ ºî™ àÁŠ¬ð ܵ躮Aø¶. å¼ ²†
®¬ù ²†´õK¬ê Ý‚è º®»‹ (a pointer can be idexed) â¡ð¬î
Þî¡Íô‹ ÜPòô£‹. å¼ ²†´, ªî£ì˜„Cò£ù G¬ùõèˆ ªî£°
F¬ò„ ²†®‚ ªè£‡®¼‚°‹«ð£¶î£¡ Þ¶ ꣈Fòñ£°‹. x+0
â¡ð¶ ºî™ àÁŠH¡ ºèõK. * (x+0) â¡ð¶ Ü‰î ºèõKJ™
àœ÷ ºî™ àÁŠH¡ ñFŠ¹. ÜEJ¡ ªðò˜ a ܙô¶ ²†´ ñ£P
x-àì¡ 1-ä‚ Ã†®ù£™, Þó‡ì£õ¶ àÁŠH¡ ºèõK A¬ì‚°‹.

x+1 ⇔ a+1
ރ«è, å¼ ºèõKJ™ å¼ º¿â‡ ÆìŠð´Aø¶. Þ¶,
ê£î£óí‚ èí‚W´ Ü¡Á, ²†´‚ èí‚W´ Ý°‹. º‚Aòñ£ù
މî MFº¬ø¬ò G¬ùM™ ªè£œè. “²†´‚ èí‚W´èO™, ܄
²†´ ꣘‰î îóMùˆF¡ Ü®Šð¬ìJ«ô«ò Ü÷i´èœ ܬñ»‹”.
ރ«è x, int Þù ñFŠ¬ð„ ²†´Aø¶. int Þù‹ 2 ¬ð†´è¬÷‚
ªè£‡ì¶. âù«õ Ü÷i†´‚ è£óE (scale factor) 2 Ý°‹. Ýè,
x+1 ⇔ 948 + 1 * 2 = 950

a+1 ⇔ 948 + 1 * 2 = 950 ⇔ &a[ 1 ]


.............................
.............................
a+i ⇔ &a[ i ] ⇔ x + i ⇔ &x[ i ]
a+i â¡ð¶ ÜEJ™ i- õ¶ àÁŠH¡ ºèõK¬ò‚ °P‚Aø¶.
*(a+i), i-õ¶ àÁŠH¡ ñFŠ¬ð‚ °P‚Aø¶.
«ñŸè‡ì M÷‚èƒèOL¼‰¶ cƒèœ ¹K‰¶ªè£œ÷ «õ‡®
ò¬õ:
® ÜEèÀ‹ ²†´èÀ‹ ªï¼‚èñ£ù àø¾ ªè£‡ì¬õ.
® å¼ ²†®¬ù, æ˜ ÜE «ð£ô«õ ð£M‚è º®»‹.
ⴈ¶‚裆´:
10 º¿â‡èœ ªè£‡ì å¼ ÜE‚°Kò ñFŠ¹è¬÷ M¬êŠ
ðô¬èJL¼‰¶ ãŸÁ‚ªè£œ÷ å¼ Gó™ ⿶è:

283
#include <stdio.h>
main()
{
int i;
int a[10];
for(i=0;i<10;i++)
scanf(“%d”, a+i);
}
scanf()ªêò™ÃP™, &a[i] â¡Á Þ¼‚è «õ‡®ò ÞìˆF™ a + i
â¡Á ðò¡ ð´ˆîŠð†´œ÷¬î «ï£‚°è. è£óí‹, Þ󇴋 å¡
Á‚ªè£¡Á Gèó£ù¬õ â¡ð¬î 㟪èù«õ GÁM»œ«÷£‹. i = 0
Ýè Þ¼‚°‹«ð£¶, a + i â¡ð¶ ºî™ àÁŠH¡ ºèõK¬òˆ î¼
Aø¶. i = 1 Ýè Þ¼‚°‹«ð£¶, Þó‡ì£õ¶ àÁŠH¡ ºèõK¬òˆ
î¼Aø¶. ޚõ£ø£è, a + i Íô‹ ܬùˆ¶ ºèõKè¬÷»‹ ªðø
º®Aø¶.
Þ¶õ¬óJ™  º¿â‡ ÜEè¬÷»‹, ²†´èœ Íô‹
ÜõŸ¬ø âšõ£Á ¬èò£œõ¶ â¡ð¬î»‹ 𣘈«î£‹. ïñ¶ Ü´ˆî
«ï£‚è‹ °P»¼ ÜE Ý°‹. 24 ⿈¶èœ (ªð¼‹ð£ô£ù ś
G¬ôèO™ °P»¼ â¡ð¶ ⿈¬î«ò °P‚Aø¶) ªè£‡ì æ˜
ÜE¬ò ÜPMŠ«ð£‹.
char name [24];
ÞF™, name â¡ð¶ 24 ⿈¶èœ ªè£‡ì æ˜ ÜEò£°‹.
G¬ùõèˆF™ ªî£ì˜„Cò£è 24 ¬ð†´èœ 嶂èŠð´‹. ªî£ì‚è
ºèõK ÜEJ¡ ªðò˜ name- ™ Þ¼ˆîŠð´‹. êó‹ (string) â¡ð¶,
Þ¡ñ‚ °P»¼ (null character - ‘\0’) ¾ì¡ º®¾Á‹ ⿈¶èO¡
ªî£°Š¹ âù õ¬óòÁ‚èô£‹. âù«õ, å¼ êóˆ¬î‚ ¬èò£÷,
⿈¶èO¡ ÜE «î¬õŠð´Aø¶. M¬êŠðô¬èJL¼‰¶ å¼
êóˆ¬îŠ ªðÁõ,
scanf (“%s”, name);
â¡Â‹ ßÁŠ ðò¡ð´Aø¶.
ÞF™, å¼ êóˆ¬îŠ ð®‚è %s â¡Â‹ õ®õ¬ñŠ¹ õ¬óò
Á Š ¹ ð ò ¡ ð ´ ˆ î Š ð † ´ œ ÷ ¶ . %s, ê ó ˆ F L ¼ ‚ ° ‹ ª õ Ÿ Á Þ ì
ªõO¬ò (blank space) õó‹ªð™¬ô‚ °P»¼õ£è‚ (delimiting charac-
ter) è¼F‚ªè£œÀ‹. âù«õ, ï´M™ ªõŸÁ ÞìªõO ªè£‡ì
êóˆ¬îŠ ªðÁõ Þî¬ùŠ ðò¡ð´ˆî Þòô£¶. «ñŸè‡ì
284
߬ø Þò‚°‹«ð£¶, ðòùK¡ àœk†´‚è£è‚ 裈F¼‚°‹. ðòù˜
àœO´‹ ܬùˆ¶ ⿈¶èÀ‹ name ²†®‚ ªè£‡®¼‚°‹ ºè
õKJ™ ªî£ìƒA, õK¬êò£è Þ¼ˆîŠð´‹. ÞÁFJ™ ‘\0’ â¡Â‹
Þ¡ñ‚ °P»¼ î£ù£è«õ «ê˜ˆ¶‚ªè£œ÷Šð´‹. êóˆ¬îˆ F¬ó
J™ 裆ì,
printf (“%s”, name);

â¡ø ßP¬ù ܬñ‚èô£‹.


õ®õ¬ñŠ¹ õ¬óòÁŠ¹‚ °P»¼õ£ù ‘%s’, name ²†´‹
ªî£ì‚è ºèõK ªî£ìƒA, Þ¡ñ‚ °P»¼ õ¬ó»œ÷ ⿈¶è
¬÷ˆ ªî£ì˜„Cò£èŠ ªðŸÁˆ .
êó‹ â¡ð¶, ⿈¶èO¡ ªî£°F (æ˜ ÜE) â¡ð Üî¡
îóMù‹ char * Ý°‹. êó ñ£PL (string constant) »ì¡ ªî£ì˜¹¬ìò
îóMù‹ å¼ ²†´ (char *) â¡ð, Üî¡ ñFŠ¹ å¼ ºèõKò£
èˆî£¡ Þ¼‚è º®»‹, êóˆF¡ àœ÷ì‚è ñFŠð£è Þ¼‚è º®
ò£¶. Ýè, å¼ êó ñ£PLJ¡ ñFŠ¹, ܄êó‹ Þ¼ˆîŠð†´œ÷
G¬ùõèˆ ªî£°FJ¡ ªî£ì‚è ºèõKò£°‹.
W«ö»œ÷ Gó™ ð°F¬ò «ï£‚°è:
if(“rama” == “rama”)
printf(“equal”);
else
printf(“not equal”);
ÞF™, Hø ñ£PLèœ åŠHìŠð´õ¬îŠ «ð£ô«õ G蘄 ªêòŸ°P
Íô‹ Þó‡´ êóƒèœ åŠHìŠð†´œ÷ù. C-ªñ£N Gó™ªðò˜ŠH
(Compiler) ވªî£ìó¬ñŠ¬ð ãŸÁ‚ ªè£œÀ‹. މî Gó™ð°F not
equal â¡Â‹ M¬ì¬òˆ . ÞF™, º¿‚辋 å«ó ñ£FKò£ù
Þ¼ êóƒèœ åŠHìŠð†ì«ð£¶‹, Þó‡´ êóƒèÀ‹ G¬ùõèˆF™
ªõš«õÁ ÞìƒèO™ Þ¼ˆîŠð†´œ÷ù â¡ð¬î ñø‚è‚ Ã죶.
å¼ êó ñ£PLJ¡ ñFŠ¹, ܄êóˆF¡ ªî£ì‚è ºèõK, êóˆF¡
àœ÷ì‚èˆ¬î‚ °P‚裶 â¡ð¬î  㟪èù«õ ÜP«õ£‹.
âù«õ, «ñŸè‡ì åŠd†®™, G¬ùõè ÞìˆF¡ ºèõKè«÷ åŠ
HìŠð†´œ÷ù. ܬõ å¡ø£ù¬õ ܙô. âù«õ, «ñŸè‡ì
Gó™ð°F not equal â¡Â‹ ªõOf†¬ìˆ î¼Aø¶.
°PŠH†ì êóˆF½œ÷ ⿈¶è¬÷ â‡E„ ªê£™½‹ å¼
Gó¬ô‚ 裇«ð£‹. string.h â¡Â‹ î¬ôŠ¹‚ «è£Š¹, êóˆ¬î‚
285
¬èò£À‹ ªêò™ÃÁèœ ðôõŸ¬ø àœ÷ì‚A»œ÷¶. å¼ êóˆ
F¡ c÷ˆ¬î‚ è‡ìPò strlen() â¡Â‹ ªêò™ÃÁ ðò¡ð´Aø¶.
strlen() â¡ð¶ º¡-õ¬óòÁ‚èŠð†ì ªêò™ÃÁ. Þî¡ ñ£FK õ®õ‹
string.h «è£ŠH™ ÜPM‚èŠð†´œ÷¶. strlen() ªêò™ÃP¡ ñ£FK
õ®õ‹:
int strlen (char * );

strlen() ªêò™ÃÁ, Ü÷¹¼õ£è å¼ êóˆ¬î ãŸÁ, Üî¡ c÷ˆ¬î


å¼ º¿â‡í£èˆ F¼ŠH ÜŠ¹‹.
#include <stdio.h>
#include <string.h>
main()
{ char name[24];
int len;
printf(“enter a string: “);
scanf(“%s”, name);
len = strlen(name);
printf(“%d\n”, len);
}

މî Gó™ M¬êŠðô¬èJL¼‰¶ å¼ êóˆ¬îŠ ªðŸÁ, Üî¡


c÷ˆ¬î‚ è‡ìP‰¶ M¬ì¬òˆ F¬óJ™ 裆´‹.
å¼ ªêò™ÃP‚°, æ˜ ÜE¬ò Ü÷¹¼õ£è ÜŠH ¬õ‚è
«õ‡®J¼‰î£™, ²†´è¬÷Š ðò¡ð´ˆF‚ªè£œ÷ º®»‹. êóˆF¡
c÷ˆ¬î ÜPò, ïñ¶ ªê£‰î„ ªêò™ÃP¬ù â¿FŠ 𣘊«ð£‹.
W«ö»œ÷ °Pº¬øJ™, lenstr() â¡Â‹ ªêò™ÃÁ, ðòù˜-õ¬óòÁˆî
ªêò™ÃÁ (user-defined function) Ý°‹.
õ®õ‹- 1:
int lenstr(char *s)
{
int count = 0;
while(s[count] != ‘\0’)
count++;
return(count);
}

“rama” â¡Â‹ êóˆ¬î Ü÷¹¼õ£è lenstr() ªêò™ÃP‚°


ÜŠH¬õˆî£™, ªêò™ÃP¡ º¬øò£ù Ü÷¹¼õ£™ (s) ªðŸÁ‚
ªè£œ÷Šð´‹. ܶ å¼ °P»¼„ ²†´ (character pointer) Ý°‹.
286
âù«õ, s â¡ð¶ “rama” â¡Â‹ êóˆ¬î„ ²†®‚ªè£‡®¼‚°‹.
while ñ산 count = 0-L¼‰¶ ªî£ìƒ°Aø¶ â¡ð, s[0] êóˆF¡
ºî™ ⿈¬î‚ °Pˆ¶ GŸAø¶. Üî£õ¶ r â¡Â‹ ⿈¬î‚
°P‚Aø¶. ܶ Þ¡ñ‚°P»¼ Ü¡Á. while ßP¡ Gð‰î¬ù
‘êK’ â¡ø£Aø¶. âù«õ, while ñì‚A¡ àìŸð°F ªêò™ð´ˆîŠ-
ð´Aø¶. count -¡ ñFŠ¹ å¡Á I°‚èŠð´Aø¶. s[count] == ‘\0’
â¡ø£°‹ õ¬ó, ñ산 ªî£ì˜‰¶ ªêò™ð´ˆîŠð´‹. ÞÁFJ™
ªêò™ÃÁ count- ¡ ñFŠ¬ðˆ F¼ŠH ÜŠ¹‹. ܶ«õ, êóˆF
½œ÷ ⿈¶èO¡ â‡E‚¬è Ý°‹.
õ®õ‹-2
int lenstr(char *s)

{ int count = 0;
while(*s != ‘\0’)

{
count++;
s++;
}

return(count);
}

GóL¡ 膴Šð£´ ºî™ º¬ø ñì‚Aœ ¸¬ö»‹«ð£¶, *s- ™,


â¡ø êóˆF¡ ºî™ ⿈î£ù r â¡ø ⿈¶ Þ¼‚°‹. while
“rama”
ñì‚A¡ àìŸð°FJ™, 嚪õ£¼ º¬ø»‹, ²†´ I°‚èŠð†´,
êóˆF½œ÷ Ü´ˆî´ˆî ⿈¶è¬÷„ ²†´‹. *s, ‘\0’ Ý°‹õ¬ó
Þ‰î„ ªêòô£‚è‹ ªî£ì¼‹.
õ®õ‹ - 3
int lenstr(char *s)
{
char *start, *end;
start = end = s;
while(*end)
end++;
return(end – start);
}

287
ªêò™ÃÁ Þò‚èŠð´‹«ð£¶, start, end, s ÝAò ܬùˆ
lenstr()
¶‚ °P»¼„ ²†´èÀ‹ “rama” â¡Â‹ êóˆ¬î„ ²†´ñ£Á ܬñ‚
èŠð†´œ÷ù. “rama” â¡Â‹ êó‹ Ü÷¹¼õ£è ÜŠH¬õ‚èŠ
ð´Aø¶ .

“
ªî£ì‚è‹ º®¾

start, end, s ÝAò¬õ, êóˆF¡ ºî™ ⿈F¡ ºèõKò£Aò


948-ä„ ²†´Aø¶. end ²†®¬ù ‘\0’ ä„ ²†´‹õ¬ó ï蘈F„ ªê™ô
while ñì‚A¬ùŠ ðò¡ð´ˆF»œ«÷£‹. ñ산, ªêò™ð£†¬ì º®‚
°‹«ð£¶, end ²†´ 952 â¡Â‹ ºèõK¬ò„ ²†®‚ªè£‡®¼‚°‹.
while ßP¡ Gð‰î¬ù¬ò «ï£‚°ƒèœ. ªî£ì‚èˆF™ * end -™ r
â¡Â‹ ñFŠ¹ Þ¼‚°‹. ܶ 0 ܙô â¡ð Gð‰î¬ù ‘êK’
â¡ø£°‹. * end -™ ‘\0’ â¡Â‹ ñFŠ¹ Þ¼‚°‹«ð£¶, ܶ 0
â¡ð Gð‰î¬ù ‘îõÁ’ ÝAM´Aø¶. while ñ산 º®¾Á‹
«ð£¶, end ²†´ 952 â¡Â‹ ºèõK¬ò„ ²†®‚ªè£‡®¼‚°‹.
start ⊫𣶋 948 â¡Â‹ ºèõK¬ò«ò ²†®‚ªè£‡®¼‚°‹.
end-start (952-948) â¡Â‹ «è£¬õ 4 â¡ø M¬ì¬òˆ . މî
ñFŠ¹ îóŠð†ì êóˆF™ àœ÷ ⿈¶èO¡ â‡E‚¬èò£èˆ
F¼ŠH ÜŠðŠð´‹. å¼ ²†®L¼‰¶ Þ¡ªù£¼ ²†®¬ù‚ èN‚
°‹«ð£¶, Þó‡´ ²†´èÀ‚° Þ¬ì«ò»œ÷ ¬ð†´èO¡ â‡
E‚¬è M¬ìò£è‚ A¬ì‚°‹. ²†´è¬÷‚ ªè£‡´ ÜEè¬÷‚
¬èò£œõ¬î, ²†´‚ èí‚W´ â¡Â‹ ð‡¹‚Ã«ø ꣈Fòñ£‚A
»œ÷¶ â¡ð¬î‚ èõùˆF™ ªè£œè.
4.7.1 ðôðKñ£í ÜEèœ (Multi dimensional Arrays)
C-ªñ£NJ™ ðôðKñ£í ÜE â¡ð¶, ÜEèO¡ ÜEò£
è‚ è¼îŠð´Aø¶. Þ¼ðKñ£í ÜE ޚõ£Á ÜPM‚èŠð´Aø¶:
int a[3][3];

މî ÜPMŠ¹, 3x3 ÜE‚ «è£¬õ¬ò (matrix) à¼õA‚Aø¶.


ÞF™ 9 àÁŠ¹èœ àœ÷ù. Gó™ªðò˜ŠH, މî ÜE‚«è£¬õJ¡
àÁŠ¹è¬÷ Þ¼ˆF¬õ‚è, ªî£ì˜„Cò£ù 18 ¬ð†´è¬÷ 嶂A
¬õ‚Aø¶. ºî™ ðKñ£í‹, A사èèO¡ (rows) â‡E‚¬è¬ò‚
288
°P‚Aø¶. Þó‡ì£õ¶ ðKñ£í‹ ªï´‚¬èèO¡ (columns) â‡
E‚¬è¬ò‚ °P‚Aø¶. މî ÜE‚«è£¬õ‚° (Þ¼ðKñ£í‹)
ñFŠ¹è¬÷Š ªðø, ïñ‚° Þó‡´ ²†´ õK¬ê â‡èœ «î¬õ.
å¡Á Aì‚¬è„ ²†´ ⇠(Row Index), ñŸø¶ ªï´‚¬è„ ²†´
⇠(Column Index). C-ªñ£NJ™ ÜE„ ²†´ ⇠0-M™ ªî£ìƒ°
Aø¶. ºî™ àÁŠ¬ð a[0][0] Íô‹ ܵèô£‹. W«ö»œ÷ Gó™
ð°F¬ò «ï£‚°è:

int a[3[[3];
int i;
int j;
for(i=0;i<3;i++)
for(j=0;j<3;j++)
scanf(“%d”, &a[i][j]);

މî Gó™ð°F, ÜE‚ «è£¬õ‚°Kò ñFŠ¹è¬÷ A사è


õ£Kò£èŠ ªðÁAø¶. ªõO for ñì‚A™ i = 0 Ýè Þ¼‚°‹«ð£¶,
àœ - ñ산 j = 0, 1, 2 ÝAò ñFŠ¹èÀ‚° Í¡Á º¬ø ªêò™
ð´Aø¶. âù«õ, ºî™ A사èJ¡ Í¡Á â‡¬íŠ ªðÁAø¶.
Þ¶«ð£«õ, i = 1, i = 2 ÝAò ñFŠ¹èÀ‚°‹ àœ-ñ산 ªêò™ð´
Aø¶. ñFŠ¹è¬÷ àœO´‹«ð£¶, â‡èÀ‚A¬ì«ò å¡Á ܙ
ô¶ «ñŸð†ì ªõŸÁ ÞìªõO(èœ) M†´ å¡ð¶ â‡è¬÷»‹
ªî£ì˜„Cò£è àœOì«õ‡´‹.
މî ÜE‚«è£¬õJ™ Í¡Á A사èèœ àœ÷ù. 嚪õ£¼
A사軋 Í¡Á â‡èœ ªè£‡ì æ˜ ÜE¬ò‚ °P‚A¡øù.
Þ¶, ÜEèO¡ ÜE õ®M™ àœ÷¶. ºî™ ðKñ£í‹ Í¡Á
àÁŠ¹è¬÷‚ ªè£‡´œ÷¶. 嚫õ£˜ àÁŠ¹‹ Í¡Á â‡è¬÷‚
ªè£‡ì æ˜ ÜE¬ò‚ °P‚A¡øù. ãªùQ™ Þó‡ì£õ¶ ðK
ñ£íº‹ 3 âù àœ÷¶.
W«ö»œ÷ ÜE‚ «è£¬õ¬ò «ï£‚°è:
1 2 3
4 5 6
7 8 9
Þ¬î«ò, ÜEèO¡ ÜEò£è, ޚõ£Á °PŠHìô£‹:
289
a[0] Ž {1, 2. 3}
a[1] Ž {4, 5, 6}
a[2] Ž {7, 8, 9}
ºî™ ðKñ£í‹ 3 àÁŠ¹èœ ªè£‡ì æ˜ ÜE. 嚫õ£˜
àÁŠ¹‹ å¼ º¿â‡ ÜEò£°‹. âù«õ 嚫õ£˜ àÁŠ¹‹ å¼
º¿â‡ ²†´ (integer pointer) Ý°‹. Ýè , int a[3] [3] â¡Â‹ ÜP
MŠ¹‚° ޚõ£Á ªð£¼œ M÷‚è‹ îóô£‹. ºî™ ðKñ£í‹ 3
º¿ ⇠²†´è¬÷‚ ªè£‡ì æ˜ ÜEò£°‹. Þó‡ì£õ¶ ðK
ñ£í‹ 3 º¿ â‡è¬÷‚ ªè£‡ì æ˜ ÜEò£°‹. Þó‡ì£õ¶
ðKñ£í‹ 3 º¿ â‡è¬÷‚ ªè£‡ì ºî™ A사è¬ò„ ²†´
Aø¶; ܶ å¼ º¿â‡ ²†´ Ý°‹. Ü«î «õ¬÷J™ a[0][0]
â¡ð¶ ÜE‚ «è£¬õJ¡ ºî™ àÁŠð£°‹. Üî£õ¶, ºî™
A사èJ¡ ºî™ àÁŠ¹. a[1] â¡ð¶ Í¡Á º¿â‡èœ ªè£‡ì
Þó‡ì£õ¶ A사è¬ò„ ²†´Aø¶. C-ªñ£N Gó™ªðò˜ŠH, Þ¼
ðKñ£í ÜE¬ò Þ‰î º¬øJ™î£¡ ¬èò£œAø¶. Ýù£™ ñ£
ºî™ ðKñ£í‹ A사èè¬÷»‹, Þó‡ì£õ¶ ðKñ£í‹ ªï´‚¬è
è¬÷»‹ °P‚A¡øù â¡Á è¼F‚ªè£œA«ø£‹.
3x3 ðKñ£íºœ÷ ÜE‚«è£¬õ‚°Kò ñFŠ¹è¬÷Š ªðÁõ¶
âŠð® â¡ð¬î ï£ñP«õ£‹. Ü´ˆ¶, ÜE‚«è£¬õJ¡ àÁŠ¹
è¬÷‚ A사è õ£Kò£èˆ F¬óJ™ 裆´‹ Gó™ð°F¬ò â¿FŠ
𣘊«ð£‹.
for(i = 0; i < 3; i++)
{
for(j = 0; j < 3; j++)
printf(“%d “, a[i][j]);
printf(“\n”);
}

3x3 ðKñ£í‹ ªè£‡ì Þó‡´ ÜE‚«è£¬ õè¬÷‚Æ®


M¬ì¬ò Í¡ø£õ¶ ÜEJ™ ⿶‹, ‘ÜE‚«è£¬õ‚Æ왒
(matrix Addition) Gó¬ô‚ W«ö 裇è:

290
 #include <stdio.h>

#include <conio.h>
main()
{
int a[3][3], b[3][3], c[3][3];
int i, j;
/* read values for the input matrix a */
for(i=0;i<3;i++)
for(j=0;j<3;j++)
scanf(“%d”, &a[i][j]);

/* read values for the input matrix b */


for(i=0;i<3;i++)
for(j=0;j<3;j++)
scanf(“%d”, &b[i][j]);
/* initialize the output matrix c with all elements 0 */
for(i=0;i<3;i++)
for(j=0;j<3;j++)
c[i][j] = 0;
/* add matrix a and b and store the result in matrix c */
for(i=0;i<3;i++)
for(j=0;j<3;j++)
c[i][j] = a[i][j] + b[i][j];
/* print the resultant matrix c */
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
printf(“%d ”, c[i][j]);
printf(“\n”);
}
}


291
މî GóL¡ 嚪õ£¼ ð°F¬ò»‹ ï¡° ¹K‰¶ªè£œÀ‹
ªð£¼†´ ݃裃«è M÷‚辬óèœ (comments) «ê˜‚èŠð†´œ
÷ù. æ˜ ÜE‚«è£¬õJ½œ÷ A사èè¬÷ îQˆîQò£è‚ ¬èò£
À‹ º¬ø¬ò M÷‚°‹ Gó¬ô‚ W«ö 裇è. މî Gó™, ªè£´‚èŠ
ð†ì 3x3 ðKñ£í‹ ªè£‡ì ÜE‚«è£¬õJ™ 嚪õ£¼ A사è
J½‹ àœ÷ â‡èO™ ªð¼ñ ñFŠ¹ (maximum value) ⶪõù‚
è‡ìPAø¶.
#include <stdio.h>
#include <conio.h>
main()
{ int a[3][3], max[3];
int maximum(int *); /* declaration of user-defined function */
int i, j;
clrscr(); /* to clear the contents of the screen */
/* read values for the input matrix a */
for(i=0;i<3;i++)
for(j=0;j<3;j++)
scanf(“%d”, &a[i][j]);
/* find the maximum in each row and store in the array max */
for(i = 0; i < 3; i++)
max[i] = maximum(a[i]);
/* print the max array */
for(i =0; i < 3; i++)
printf(“The maximum value of row %d = %d\n”, i+1,
max[i] );
}
int maximum(int *x)
{ int mvalue;
mvalue = x[0];
for(i = 1; i < 3; i++)
if(x[i] > mvalue)
mvalue = x[i];
return(mvalue);
}

292
މî GóL™, 3 º¿â‡ àÁŠ¹èœ ªè£‡ì ÜEJ™ ªð¼ñ
ñFŠ¬ð‚ è‡ìPò å¼ ðòù˜-õ¬óòÁˆî ªêò™ÃÁ â¿îŠð†
´œ÷¶. ܄ªêò™ÃP¡ ªðò˜ maximum() . ܶ, å«óªò£¼ int *
Þù Ü÷¹¼¬õ 㟰‹. å¼ º¿â‡ ñFŠ¬ðˆ F¼ŠH ÜŠ
¹‹. ܶ«õ ªð¼ñ ñFŠð£°‹. Þ‰î„ ªêò™ÃÁ main() ªêò™
ÃP™, å¼ for ñì‚Aœ 3 º¬ø ܬö‚èŠð´Aø¶. 嚪õ£¼
º¬ø maximum() ªêò™ÃÁ ܬö‚èŠð´‹«ð£¶‹, Í¡Á º¿
â‡èœ ªè£‡ì å¼ A사è Ü÷¹¼õ£è ÜŠH¬õ‚èŠð´
Aø¶. a[i], i =0,1,2 ÝAò A사èè«÷ Ü÷¹¼‚èœ Ý°‹. ܬö‚
èŠð†ì ªêò™ÃP™, º¿â‡ ²†´ x â¡Â‹ º¬øò£ù Ü÷
¹¼M™, 嚪õ£¼ A사èJ¡ ªî£ì‚è ºèõK»‹ ªðøŠð´
Aø¶. 㟪èù«õ  ÜP‰îð®, x â¡Â‹ ²†®¬ù ²†´õK¬ê
ò£‚è (ܶ 3 àÁŠ¹èœ ªè£‡ì õK¬ê¬ò„ ²†´Aø¶ â¡ð)
º®»‹. Üî¡õN«ò ÜEJ¡ àÁŠ¹è¬÷ Üµè º®»‹. åš
ªõ£¼ A사èJ¡ ªð¼ñ ñFŠ¹‹, º¬ø«ò mx â¡Â‹ ÜE
J™ Þ¼ˆF¬õ‚èŠð´A¡øù. ޚõ£ø£è, æ˜ ÜE‚«è£¬õJ½œ÷
嚪õ£¼ A사è¬ò»‹ Üî¡ ªî£ì‚è ºèõK¬òŠ ðò¡
ð´ˆFˆ îQˆîQ«ò ¬èò£÷º®»‹ â¡ðîPè.
4.8 膴¼‚èœ (Structures)
C-ªñ£NJ™ 膴¼ (structure) â¡ð¶ ‘î¼M‚èŠð†ì îó¾ Þù‹’
(derived data type) Ý°‹. Hø îóMù ñ£Pè¬÷‚ ªè£‡´ à¼õ£‚
èŠð´A¡ø¶. (ðô ñ£Pè¬÷ å¡ø£è‚ 膮 à¼õ£‚èŠð´õ
‘膴¼’ ÝJŸÁ). ðòù˜-õ¬óòÁ‚°‹ îóMùƒè¬÷ à¼õ£‚è‚
膴¼‚èœ ðò¡ð´A¡øù. ªð£¶õ£è, å¼ «è£ŠHQ™ «êI‚
èŠð´‹ ã´è¬÷ (record) õ¬óòÁ‚è‚ 膴¼‚èœ ðò¡ð´A¡øù.
«è£Š¹ â¡ð¶ ã´èO¡ ªî£°Š¹. ã´ â¡ð¶ îèõ™ ¹ôƒèO¡
(fields of information) ªî£°Šð£°‹.

å¼ ñ£íõ˜-ã´ W›‚裵‹ ¹ôƒè¬÷‚ ªè£‡®¼‚èô£‹:


õK¬ê â‡, ªðò˜, õò¶
ފ¹ôƒèO¡ ñFŠ¹,
1001, Ýù‰ˆ, 18
âù Þ¼‚èô£‹.
«ñŸè‡ì ã´ Ýù‰ˆ â¡ø ñ£íõ¬óŠ ðŸPò îèõ™
293
è¬÷‚ ªè£‡´œ÷¶. Üõó¶ õK¬ê⇠1001, õò¶ 18 Ý°‹.
‘ÜE’ â¡ð¶ å«ó îóMù àÁŠ¹èO¡ ªî£°Šð£°‹. ‘è†
´¼’ â¡ð¶ ªõš«õÁ îóMù àÁŠ¹èO¡ ªî£°Šð£°‹. ÜE
â¡ð¶ å¼ð®ˆî£ù (homegeneous) àÁŠ¹èO¡ ªî£°Š¹. 膴¼
â¡ð¶ èî‹ð (hetrogeneous) àÁŠ¹èO¡ ªî£°Š¹.
«ñŸè‡ì ⴈ¶‚裆®™ ªê£™ôŠð†ì ñ£íõ˜ ㆮ½œ÷
¹ôƒèœ ªõš«õÁ îóMùƒè¬÷„ ꣘‰î¬õ:
õK¬ê⇠: º¿â‡ ¹ô‹
ªðò˜ : ⿈¶èO¡ ÜE
õò¶ : º¿â‡ ¹ô‹
W«ö»œ÷ 膴¼ õ¬óò¬ø¬ò «ï£‚°è:
struct student
{
int rollno;
char name[24];
int age;
};
struct â¡ð¶ C-ªñ£NJ¡ CøŠ¹„ ªê£™. å¼ è†´¼¬õ õ¬ó
òÁ‚èŠ ðò¡ð´Aø¶. student â¡Â‹ °PŠªðò˜ ‘膴¼ 冴’
(structure tag) ܙô¶ ‘冴Š ªðò˜’ (tag name) âùŠð´Aø¶. «ñŸ
è‡ì õ¬óò¬ø, ㆮ¡ è†ì¬ñŠ¹ ðŸP, Üî£õ¶ âˆî¬ù
¹ôƒè¬÷‚ ªè£‡´œ÷¶, ܬõ â‰îˆ îóMùˆ¬î„ «ê˜‰î¬õ
â¡ø Mõóƒè¬÷ ïñ‚°ˆ ªîKM‚Aø¶. 膴¼M¡ õ¬óò¬ø
ㆮ¡ õ£˜Š¹¼¬õ (template) ñ†´«ñ õöƒ°Aø¶. ܶ ㆮ¡
ªõÁ‹ à¼õ¬ó«õ (skeleton) Ý°‹. 膴¼ õ¬óò¬øJ™, ªïO¾
ܬ승‚°PèÀ‚°œ ÜPM‚èŠð†´œ÷ ñ£Pèœ (¹ôƒèœ) è†
´¼M¡ àÁŠ¹è÷£°‹ (members). å¼ è†´¼ àÁŠ¹èœ ܬùˆ¶‹
îQˆî (unique) ªðò˜è¬÷‚ ªè£‡®¼‚è «õ‡´‹. 膴¼ õ¬óò¬ø
ܬ󊹜O»ì¡ º®¾Á‹. 膴¼ õ¬óò¬ø G¬ùõèˆF™ Þì‹
â¬î»‹ 嶂W´ ªêŒò£¶. Üî£õ¶, 膴¼¬õ õ¬óòÁ‚°‹«ð£¶
ÜîŸè£ù G¬ùõèŠ ð°F 嶂èŠðì ñ£†ì£¶. âù«õ, 膴¼
õ¬óò¬ø‚°œ«÷ àÁŠ¹èO™ ªî£ì‚è ñFŠH¼ˆî º®ò£¶.
294
«ñŸè‡ì ⴈ¶‚裆®™, 膴¼M¡ Þù‹ struct student â¡
ð‹. ފ«ð£¶, struct student â¡ð¶ ðòù˜-õ¬óòÁˆî å¼ ¹Fò
îóMù‹ ÝAM´‹. 膴¼ õ¬óò¬ø å¼ ¹Fò îóMùˆ¬î
à¼õ£‚°Aø¶. ܚMùˆF™, ñ£Pè¬÷ ÜPM‚è º®»‹. Hø
ñ£Pè¬÷Š «ð£ô«õ 膴¼ ñ£Pè¬÷ ÜPM‚è º®»‹.
ⴈ¶‚裆´:

struct student x, y;

x, y ÝAò¬õ struct student Þù ñ£Pè÷£°‹. 嚪õ£¼ ñ£P


»‹ 膴¼M™ õ¬óòÁˆîð® Í¡Á ¹ôƒè¬÷‚ ªè£‡´œ÷ù.
嚪õ£¼ struct student Þù ñ£P‚°‹ ªñ£ˆî‹ 28 ¬ð†´èœ 嶂
èŠð´A¡øù.
膴¼¬õ ⊫𣶋 å¼ º¿î÷£Mò ༪ð£¼÷£Œ (global
entity) õ¬óò¬ø ªêŒõ¶ ï™ô¶. è£óí‹, GóL™ àœ÷ ܬùˆ¶
ªêò™ÃÁèÀ‚°‹ Üî¡ õ¬óò¬ø A¬ì‚芪ðÁ‹.
膴¼ ñ£Pè¬÷»‹ º¿î÷£Mò ñ£Pè÷£è ÜPM‚è º®
»‹. ⴈ¶‚裆ì£è,
struct student

int rollno;

char name[24];

int age;

} x, y ;

ÞF™, 膴¼¬õ õ¬óòÁ‚°‹«ð£«î 膴¼ ñ£PèÀ‹ ÜP


M‚èŠð†´œ÷ù. 冴Š ªðò˜ (tag name) ޙô£ñ½‹ å¼
膴¼¬õ õ¬óòÁ‚è º®»‹. ܊ð® õ¬óòÁˆî£™ ÜîŸè£ù
ñ£Pè¬÷ ܊«ð£«î ÜPMˆ¶Mì«õ‡´‹. 冴Š ªðò˜ ޙ
¬ô«ò™, 膴¼ õ¬óò¬ø ðòù˜-õ¬óòÁˆî å¼ îóMùñ£è
ãŸÁ‚ ªè£œ÷Šðì ñ£†ì£¶.
295
ⴈ¶‚裆´:
struct
{
int empno;
float salary;
} x, y ;

މî ⴈ¶‚裆®™ îóŠð†´œ÷ 膴¼ õ¬óò¬øJ¡ Ü®Š


ð¬ìJ™, x,y îMó «õÁ ¹Fò 膴¼ ñ£Pè¬÷ à¼õ£‚è Þò
ô£¶. 冴Šªðò˜ ޙô£ñ½‹, ¹ôƒèœ ⶾ‹ ޙô£ñ½‹ õ¬ó
òÁ‚èŠð´‹ 膴¼‚èœ ðòùŸø¬õ, ܬìò£÷ñŸø¬õ.
W«ö»œ÷ 膴¼ õ¬óò¬ø¬ò‚ ªè£‡´ ⶾ‹ªêŒò
Þòô£¶:
struct
{
int empno;
float salary ;
};

4.8.1 膴¼M¡ àÁŠ¹è¬÷ ܵ°î™


(Accessing the members of the structure)

膴¼M¡ àÁŠ¹è¬÷ (¹ôƒèœ) ܵ°õ, ¹œO„


ªêòŸ°P (dot operator) ðò¡ð´Aø¶. ¹œO„ ªêòŸ°P»ì¡ 膴¼
M¡ àÁŠ¹è¬÷ ܵ°‹«ð£¶, 膴¼ñ£P å¼ ð‡¹˜íˆF
(Qualifier) ò£èŠ ðò¡ð´ˆîŠð´Aø¶. ⴈ¶‚裆ì£è, ñ£íõK¡
õK¬ê ⇬í ܵè, Üî£õ¶, 膴¼ ñ£P x Íôñ£è, rollno
¹ôˆ¬î ܵè, ðò¡ð´ˆîŠð´‹ °Pñ£ù‹:
x.rollno

¹ôƒèO™ ñFŠH¼ˆîô£‹; ¹ôƒèO¡ ñFŠ¬ðŠ ð®ˆîPò


ô£‹. x, y â¡Â‹ ñ£íõ˜èO¡ rollno ¹ôˆF™ ñFŠH¼ˆ¶‹ ß
Áèœ:
x.rollno = 1000;
y.rollno = 1001;
296
ㆮ¡ àÁŠ¹èÀ‚° ñFŠ¬ðŠ ªðÁõ scanf() ªêò™
student
ìø ޚõ£Á ܬñ‚èô£‹:
scanf (“%d %s %d”, &x.rollno, x.name, &x.age);

student â¡Â‹ 膴¼M™ name â¡Â‹ ¹ôŠªðò˜, 24


⿈¶èœ ªè£‡ì å¼ õK¬êJ¡ ªî£ì‚è ºèõK¬ò‚ °P‚A
ø¶. âù«õ, scanf() ªêò™ÃP™, ñ£íõ˜ x-¡ ªðò¬óŠ ªðŸÁ‚
ªè£œ÷ x.name â¡Á ñ†´‹ °PŠH†ì£™ «ð£¶‹. ªõOŠð¬ì
ò£è & ªêòŸ°P¬òŠ ðò¡ð´ˆF, &x.name â¡Á ܬñ‚è«õ‡
®ò «î¬õJ™¬ô â¡ð¬î ñùF™ ªè£œè.
4.8.2 膴¼‚èÀ‚è£ù ²†´èœ (Pointers to Structures)
Íôˆ îóMùƒèÀ‚è£ù ²†´è¬÷Š «ð£ô«õ 膴¼‚è
À‚è£ù ²†´è¬÷»‹ ÜPM‚è º®»‹. ⴈ¶‚裆ì£è,
struct student *ptr;

މî ÜPMŠ¹‚ ßP™, ptr â¡ð¶ ðòù˜-õ¬óòÁˆî îóM


ùñ£ù struct student -ä„ ²†´A¡ø å¼ ²†ì£°‹. Ü«î Þùˆ¬î„
꣘‰î «õªø£¼ 膴¼ ñ£PJ¡ ºèõK¬ò ptr- ޙ Þ¼ˆîº®
»‹.
ⴈ¶‚裆´:
struct student s1;
ptr = &s1 ; /* ptr â‹ ²†´ 膴¼ s1- ä„ ²†´Aø¶ */
ptr Íôñ£è, 膴¼ s1-¡ àÁŠ¹è¬÷ ܵè, ¹œO„ ªêòŸ
°P‚°Š ðFô£è ܋¹„ ªêòŸ°P¬òŠ (->) ðò¡ð´ˆî «õ‡´‹.
Üî£õ¶, rollno ¹ôˆ¬î ܵè ptr->rollno â¡Â‹ «è£¬õ¬òŠ
ðò¡ð´ˆî«õ‡´‹. (*ptr).rollno â¡ð¶ ð¬öò ªî£ìó¬ñŠð£°‹.
4.8.3 膴¼‚èO¡ ÜE (An array of structures)
膴¼‚èO¡ ÜE¬ò ޚõ£Á ÜPM‚èô£‹:
struct student x[5] ;

ÞF™, x â¡ð¶, 䉶 膴¼ àÁŠ¹èO¡ ÜEò£°‹. x[0],


x[1], .....x[4] ÝAò¬õ, struct student Þù‚ 膴¼M¡ îQˆîQ
àÁŠ¹è÷£°‹. ÞõŸP¡ ¹ôƒè¬÷, ޚõ£Á ܵèô£‹:

297
x[0].rollno, x[0].name, x[0].age

ÜEJ™ àœ÷ Þó‡ì£õ¶ àÁŠH¡ ¹ôƒèÀ‚° ñFŠ¹


è¬÷Š ªðŸÁ‚ªè£œ÷,
scanf (“%d %s %d”,& x [1] -rollno, x [1].name, &x [1].age);

5 ñ£íõ˜èO¡ ã´èÀ‚°Kò Mõóƒè¬÷Š ªðÁõ, for


ñì‚A¬ùŠ ðò¡ð´ˆîô£‹.
for (i=0; i<5; i++)
scanf (“%d %s %d”, &x[i].rollno, x[i].name, &x[i].age);

Þ«î«ð£ô, ñ£íõ˜èO¡ ã´è¬÷ å¡ø¡H¡ å¡ø£èˆ F¬ó


J™ 裆´õ‹ for ñì‚A¬ùŠ ðò¡ð´ˆî º®»‹. ã´è¬÷
õK¬ê⇠õ£Kò£è, ªðò˜ õ£Kò£è ܙô¶ õò¶õ£Kò£è„ «êI‚è
º®»‹. îQˆîQ ÜP‚¬èè¬÷ˆ îò£K‚è º®»‹. ã´è¬÷‚
膴¼ õ®M™ ¬èò£÷ º®»‹ â¡ð, îó¾ˆî÷„ ªêò™ð£´
èÀ‚°Š ªð¼‹ð£½‹ 膴¼‚èœ ðò¡ð´ˆîŠð´A¡øù.

ðJŸC Mù£‚èœ
I. êK ܙô¶ îõÁ âù‚ °PŠH´è
1. å¼ Gó¬ô ⿶õ º¡ð£èŠ 𣌾Šðì‹ õ¬óõ¶
è†ì£òñ£°‹.
2. «ð£L‚ °Pº¬øè¬÷MìŠ ð£Œ¾Šðìƒèœ âOî£ù¬õ.
3. b˜¾ªïP (Algorithm) â¡ð¶ õó‹¹Á â‡E‚¬èJô£ù ð®
G¬ôè¬÷‚ ªè£‡®¼‚è «õ‡´‹.
4. G„êJˆFì£î 𡺬ø„ ªêòL™ (Indefinite Iteration) ²†´ â‡
ñ£P (Index variable) ðò¡ð´ˆîŠð´Aø¶.
5. G„êJˆFì£î 𡺬ø„ ªêòL™ 嚪õ£¼ º¬ø»‹ Gð‰
î¬ù êK𣘂èŠð´Aø¶.

298
II ¹œOJ†ì Þìƒè¬÷ GóŠ¹è
1. Gó™ ⿶õ _________ 𣌾Šðì‹ õ¬óòŠð´
Aø¶.
2. «ð£L‚ °Pº¬ø¬òŠ ¹K‰¶ ªè£œõ¶, 𣌾Šð숬îŠ
¹K‰¶ ªè£œõ¬îMì _________.
3. 嚪õ£¼ Gó¬ô»‹ å¼ ð£Œ¾Šðìˆî£™ à¼õA‚è
_________.
4. êK𣘊¹ (walkthrough) Íô‹ õ®õ¬ñŠH™ àœ÷ ܬùˆ¶Š
H¬öè¬÷»‹ è‡ìPò _________ .
5. b˜¾ ªïPJ™ (Algorithm) àœ÷ 嚪õ£¼ ð®G¬ô»‹
_________ Ü÷M™ _________»‹, _________»‹ ⴈ
¶‚ ªè£œ÷«õ‡´‹.

III. ðF™ õ¬óè


1. 𣌾Šð숶‚°‹ «ð£L‚ °Pº¬ø‚°‹ Þ¬ì«ò àœ÷
Þó‡´ «õÁð£´è¬÷‚ ÃÁè.
2. 𣌾ŠðìˆF™ ðò¡ð´ˆîŠð´‹ ð™«õÁ õ¬èò£ù ªð†®
è¬÷ õ¬ó‰¶ 裆´è. 嚪õ£¡P¡ ðò¡ð£†¬ì»‹
M÷‚°è.
3. ðôõN‚ A¬÷HKˆî½‚° Þó‡´ â´ˆ¶‚裆´èœ î¼è.
«ð£L‚ °Pº¬ø â¿F‚ 裆´è.
4. Þ¼õN‚ A¬÷HKˆî½‚° Þó‡´ â´ˆ¶‚裆´èœ î¼è.
𣌾Šðì‹ õ¬ó‰¶ 裆´è.
5. ²†´â‡ ñ£P‚° Þó‡´ â´ˆ¶‚裆´èœ  M÷‚°è.
6. G„êJˆî 𡺬ø„ ªêò¬ô Þó‡´ â´ˆ¶‚裆´èÀì¡
M÷‚°è.
7. G„êòˆFì£î 𡺬ø„ ªêò¬ô Þó‡´ â´ˆ¶‚裆´
èÀì¡ M÷‚°è
8. G„êJˆî, G„êòˆFì£î 𡺬ø„ ªêò™èÀ‚°œ÷ Í¡Á
«õÁð£´è¬÷‚ °PŠH´è.
299
9. Þ¼õN‚ A¬÷HKˆî¬ôMìŠ ðôõN‚ A¬÷HKˆî™ Iè
¾‹ Þò™ð£ù¶ â¡ð¬î M÷‚è Þó‡´ â´ˆ¶‚裆´èœ
î¼è.
10. «ð£L‚ °Pº¬ø Íô‹ Ü®Šð¬ìò£ù 膴Šð£†´ ܬñŠ
¹è¬÷ M÷‚°è.
11. b˜¾ªïP (Algorithm) J¡ ð‡¹‚ÃÁèœ â¬õ?
IV. Góô£‚èŠ ðJŸCèœ: 嚪õ£¼ G󽂰‹,ªð£¼ˆîñ£ù
𣌾Šðì‹ õ¬ó‰¶, «ð£L‚ °Pº¬ø»‹ ⿶è.
1. F¬óòèˆF™ àƒèœ ªðò¬ó 5 º¬ø 裆ì å¼ C-Gó™
⿶è
2. Þó‡´ ñ£PèO¡ ñFŠ¹è¬÷ Þì‹ ñ£Ÿø å¼ C-Gó™
⿶è
3. W›‚裵‹ ðEè¬÷„ ªêŒò C-Gó™èœ ⿶è:
(i) å¼ º‚«è£íˆF¡ ðóŠð÷¬õ‚ è‡ìPò
(ii) ªõŠðG¬ô¬ò çð£ó¡q†®L¼‰¶ ªê™Còú§‚°
ñ£Ÿø
ñE: GIì‹: Mù£® âù Þ¼‚°‹ «ïóˆ¬î
(iii)
Mù£®èO™ ñ£Ÿø
4 . Þó‡´ º¿ â‡èO™ ªðKò â‡¬í‚ è‡ìPò C-Gó™
⿶è
(i) if ßÁ ðò¡ð´ˆF
(ii) if ßÁ ðò¡ð´ˆî£ñ™
[àîM‚°PŠ¹ : max =((a+b)+abs(a-b)/2]

5. Þ¡¬øò «îFJ™ àƒèœ õò¬î ވî¬ù ݇´èœ,


ñ£îƒèœ, ï£†èœ âù‚ èí‚A†´„ ªê£™ô å¼ C-Gó™
⿶è. (âO¬ñ è¼F 嚪õ£¼ ñ£îˆ¶‚°‹ 30 èœ
âù ¬õˆ¶‚ªè£œè).
6. ºî™ ðˆ¶ Þò™ªð‡èO¡ Æ´ˆ ªî£¬è¬ò‚ è‡ìPò
Üî£õ¶ 1+2+3+..... +10 è‡ìPò C-Gó™ ⿶è.
7. ç¬ð«ð£ù£C õK¬êJ™ (Fibonacci series) ºî™ 15 â‡è¬÷‚
è‡ìPò å¼ C-Gó™ ⿶è.
300
8. àƒèœ ªðòK™ àœ÷ àJªó¿ˆ¶è¬÷ â‡E„ ªê£™½‹
C-Gó¬ô ⿶è
9. ªè£´‚èŠð†ì Þ¼ â‡è¬÷»‹ õ°‚è‚îò eŠªð¼
ªð£¶‚ è£óE¬ò‚ (greatest common factor) è ‡ ì P » ‹
C-Gó¬ô ⿶è.
(àîM‚°PŠ¹: e.ªð£.è£. è‡ìPò‚ W›‚裵‹ ðòù˜-
õ¬óòÁˆî ªêò™ÃP¬ùŠ ðò¡ð´ˆ¶è:
int gcf(int first, int second)
{ int temp;
while(second > 0)
{
temp = first % second;
first = second;
second = temp;
}
return (first);
}

10. «ñŸè‡ì gcf() ªêò™Ã¬øŠ ðò¡ð´ˆF, ªè£´‚èŠð†ì H¡


ù™ â‡¬í„ ²¼‚°‹ C - Gó¬ô ⿶è. 16/64 âù àœ
k´ îóŠð†ì£™ 1/4 âù ªõOf´ ܬñò«õ‡´‹.
11. 3025 â¡ø â‡E¡ ºî™ ð£F¬ò»‹ (30), Þó‡ì£õ¶
ð£F¬ò»‹ (25) Æ®, Þ󇮡 ñ샰 (Square) èí‚
A†ì£™ Ü«î ⇠(3025) M¬ìò£è‚ A¬ì‚°‹. Üî£õ¶
(30+25)2 = 3025. Þ«î«ð£™ ܬñ‰î ܬùˆ¶ °
Þô‚è â‡è¬÷»‹ è‡ìPò å¼ C-Gó™ ⿶è.
12 . ‘Ýì‹ â‡’ â¡ðî¡ Þô‚èí‹: æ˜ â‡E¡ Þ󇮡
ñìƒ¬èˆ (square) F¼ŠHŠ «ð£†ì£™ õ¼‹ â‡, ܉î
â‡¬íˆ F¼ŠHŠ «ð£†´ õ¼‹ â‡E¡ Þ ó ‡ ® ¡
ñ샰‚° Gèó£ù¶. ⴈ¶‚裆ì£è, ܉î ⇠12 â¡è.
122 =144. 12 äˆ F¼ŠHŠ «ð£†ì£™ 21. 212 = 441 (144 äˆ
F¼ŠHŠ «ð£†ì£™ A¬ì‚°‹) ! 10 ºî™ 100 õ¬ó»œ÷
Ýì‹ â‡è¬÷‚ è‡ìPò C-Gó™ ⿶è.
301
13. ªè£´‚èŠð†ì â‡, ç¬ð«ð£ù£C õK¬êJ™ Þ싪ðÁ‹
â‡í£ â¡ð¬îŠ ðK«ê£F‚è å¼ C-Gó™ ⿶è.
14. CPò ⿈F™ (lower case) ܬñ‰¶œ÷ êóˆ¬îŠ ªðKò
⿈F™ (upper case) ñ£Ÿø¾‹, ªðKò ⿈¶„ êóˆ¬î„ CPò
⿈F™ ñ£Ÿø¾‹ å¼ C-Gó™ ⿶è.
15. å¼ ðF¡ñ ⇬í (Decimal Number) Ü ßì£ù Þ¼ñ
(binary), â‡ñ(octal), ðFùÁñ (hexa decimal) â‡í£è ñ£Ÿø
å¼ C-Gó™ ⿶è.
16. æ˜ Þ¼ñ â‡¬íŠ ðF¡ñ â‡í£è ñ£Ÿø C-Gó™ ⿶è
17. å¼ º¿G¬ø¾ (perfect) ⇠â¡ð¶, ܚªõ‡ îM˜ˆ¶
Hø õ°â‡èO¡ (divisions) Æ´ˆ ªî£¬è‚° Gèó£è Þ¼‚
°‹. 6 å¼ º¿G¬ø¾ ⇠ݰ‹. è£óí‹, 6 îM˜ˆî Hø
õ° â‡èO¡ Æ´ˆ ªî£¬è 1+2+3=6. 1 ºî™ 10000 õ¬ó
»œ÷ º¿G¬ø¾ â‡è¬÷‚ è‡ìPò å¼ C-Gó™ ⿶è.
18. å¼ I°G¬ø¾ (abundant) ⇠â¡ð¶, ܚªõ‡ îM˜ˆî
Hø õ° â‡èO¡ Æ´ˆ ªî£¬è¬òMì„ CPî£è Þ¼‚
°‹. 12 å¼ I°G¬ø¾ ⇠ݰ‹. è£óí‹ 1 2 î M ˜ ˆ î ,
Hø õ° â‡èO¡ Æ´ˆ ªî£¬è (1+2+3+4+6=16) 12ä MìŠ
ªðKò‹. 1 ºî™ 10000 õ¬ó»œ÷ I°G¬ø¾ â‡è¬÷‚
è‡ìPò å¼ C-Gó™ ⿶è.
19. å¼ °¬øð´ (deficient) ⇠â¡ð¶, ܚªõ‡ îM˜ˆî Hø
õ° â‡èO¡Ã†´ˆ ªî£¬è¬òMìŠ ªðKî£è Þ¼‚°‹. 9
å¼ °¬øð´ ⇠ݰ‹. è£óí‹ 9 îM˜ˆî Hø õ°â‡
èO¡ Æ´ˆ ªî£¬è (1+3), 9ä Mì„CPò‹. 1 ºî™
10000 õ¬ó»œ÷ °¬øð´ â‡è¬÷‚ è‡ìPò å¼ C-Gó™
⿶è.
2 0 . å¼ êóˆF½œ÷ ⿈¶è¬÷ º¡H¡ù£è (reverse) ñ£Ÿø C-
Gó™ ⿶è. àœk†´„ êó‹ rama âQ™ ªõOf†´„ êó‹
amar âù Þ¼‚è«õ‡´‹.

2 1 . ªè£´‚èŠð†ì å¼ êó‹ ð£L‡†«ó£‹ êóñ£ (º¡H¡ù£è


â¿Fù£½‹ å¡ø£è«õ Þ¼Šð¶ - MèìèM, malayalam)
â¡ð¬î‚ è‡ìP‰¶ ªê£™ô å¼ C-Gó™ ⿶è.

302
2 2 . å¼ õK¬êJ½œ÷ 10 â‡è¬÷‚ °¬ø‰¶ ªê™½‹ õK¬ê
º¬øJ™ 心è¬ñ‚è C-Gó™ ⿶è.
2 3 . å¼ ªêò™Ã¬øŠ ðò¡ð´ˆF Þó‡´ â‡èO¡ ñFŠ¹è¬÷
Þì‹ñ£ŸP ܬñ‚è å¼ C-Gó™ ⿶è.
2 4 . 10 â‡èO¡ êó£êK¬ò‚ è‡ìPò å¼ C-Gó™ ⿶è.
25. a â¡Â‹ æ˜ ÜE n â‡è¬÷‚ ªè£‡´œ÷¶. â‡èœ
ãÁºèñ£è ܬñ‰F¼‚è «õ‡´‹. ãÁºè ÜE¬òŠ
ðK«ê£Fˆ¶, ã«î‹ æ˜ â‡ õK¬êñ£PŠ H¬öò£è Þì‹
ªðŸP¼ŠH¡ å¼ H¬ö²†´‹ ªêŒF¬ò‚ 裆ì«õ‡´‹.
õK¬êŠð® ܬñ‰F¼ŠH¡ ÜîŸè£ù ªêŒF¬ò‚ 裆´è.
2 6 . æ˜ ÜE‚ «è£¬õJ™ (Matrix) ͬôM†ì (diagonal) àÁŠ¹
èO¡ Æ´ˆ ªî£¬è¬ò‚ è‡ìPò å¼ C-Gó™ ⿶è.
2 7 . æ˜ ÜEJ¡ Þìñ£ŸÁ ÜE‚ «è£¬õ¬òŠ (Transpose) ªðø
å¼ C-Gó™ ⿶è.
2 8 . ÜE‚ «è£¬õŠ ªð¼‚è™ (Matrix Multiplication) ªêŒ¶ M¬ì
è£í C-Gó™ ⿶è.
2 9 . ªè£´‚èŠð†ì æ˜ ÜE‚ «è£¬õJ™ 嚪õ£¼ ªï´‚
¬èJ½‹ ªð¼ñ, CÁñ ñFŠ¹è¬÷‚ è‡ìPò å¼ C-Gó™
⿶è. ªð¼ñ, CÁñ ñFŠ¹è¬÷‚ è‡ìPò ªêò™ÃÁèœ
⿶è. 嚪õ£¼ ªêò™ÃÁ‹ å¼ º¿â‡ ²†®¬ù
(integer pointer) Ü÷¹¼õ£è‚ ªè£‡®¼‚è«õ‡´‹. (àîM‚
°PŠ¹: 嚪õ£¼ ªï´‚¬è»‹ æ˜ ÜEò£è„ ªêò™ÃP
‚° ÜŠH¬õ‚èŠðì «õ‡´‹. 嚪õ£¼ ªï´‚¬èJ¡
àÁŠ¹è¬÷»‹ å¼ îŸè£Lè õK¬êJ™ Þ¼ˆF¬õˆ¶,
ªêò™ÃP‚° ÜŠH¬õ‚辋).
30. 10 ªðò˜è¬÷ å¼ ÜEJ™ «êIˆ¶ ¬õˆ¶, 嚪õ£¼
ªðò¬ó»‹ å¼ õKJ™ 裆´ñ£Á, C-Gó™ ⿶è.

303

Оценить