Coding සිංහලෙන්: C programming

Showing posts with label C programming. Show all posts

Saturday, June 29, 2013

9. C නවවන පාඩම - C හි ශ්‍රිත භාවිතය (Functions/Methods in C)

ශ්‍රිත (Function) යනු කේත කොටසකි(Block of code). මෙය සෑම පරිගණක භාෂාවකදිම දැකිය හැකි තවත් වැදගත් අංගයකි. අනෙක් සැමගේ මෙන්ම C හිදීද Function ප්‍රධාන ආකාර දෙකක් පවති. ඒවා නම් C හි පවතින Built-in function සහ පරිශීලකයා විසින් හඳුන්වාදෙන ලද (User define) function ලෙසයි. අප function භාවිතා කරනු ලබන්නේ ක්‍රමාලේඛයක යම් කොටසක් නැවත නැවත යොදාගැනීම (re-usability) පහසු කරගැනීමට සහ programming structure එක ගොඩනගාගැනීමටය.

දැනටමත් අපි C භාවිතයේදි මෙවැනි function භාවිතා කර ඇත්තෙමු. ඔබ මෙතෙක් ලියූ සෑම කේතයකදීම main() ලෙස function එකක් ලියා ඇත. මෙම main() function එක පාඩම ආරම්භයේදි විස්තර කල ආකාරයටම functions කීපයක් ඇති ක්‍රමලේඛයකදි වුවත් මුලින්ම ධාවනය වන function එකයි.

අපි දැන් User define functions ගැන සලකා බලමු.

Function එකක් define කිරීමේදි පහත සඳහන් ව්‍යුහය එක අනුගමනය කල යුතුය.

return-type function_name ( arg_type arg1, ..., arg_type argN )
{
    //Function body
}

උදාහරණයක් මගින් එය පැහැදිලිකරගනිමු.

int calc(int a, int b){
  int result; 
  result = a + b; 
  return result;
}

ඉහත උදාහරණයක සලකන්න. එහිදි calc ලෙස user define function එකක් ඇති අතර එම function එක තුලට a සහ b ලෙස integer විචල්‍ය argument දෙකක් ලබාදී ඇත. Function එක තුලදී මෙම a සහ b අගයන් එකට එකතු වී පිළිතුර result යන විචල්‍ය තුල ගබඩා කරගෙන එය return කර ඇත. මෙහි return යන keyword එක භාවිතා කිරීමෙන් සිදුවන්නෙ මෙම function එක අමතන (call) තැනදී එහි අගය ලබාගැනීමයි. එනම් මෙහිදී, a හා b හි අගයන් එකතු වී ලැබෙන පිලිතුර මෙම function එක call කරන ස්ථානයේදි ලබාගත හැකියි. මෙහිදී සැලකිළිමත් විය යුතු කරුණ වන්නේ අප function එකක return කල හැක්කෙ එහි return type එකේම අගයක් පමණි. මෙම උදාහරණයේදී calc function එකෙහි return type එක int (Integer) ය. එනම් මෙම function එකෙන් integer අගයක් return කළ හැකිය.

දැන් මෙලෙස ක්‍රමලේඛ කල function එකක් යම් තැනක භාවිතා කරන්නේ කෙසේදැයි බලමු. එනම් අප මෙලෙස ක්‍රමලේඛ කරගත් function එකක ක්‍රියාවලියට ආමන්ත්‍රණය කල යුතුය. නොඑසේනම් call කළ යුතුය. පහත සරළ උදාහරණය මගින් එය පැහැදිලි කර ගනිමු.

void main(){
 int x;
 x = calc(2,3);
 printf("%d",x);
}

මෙහිදී කර ඇත්තෙ ඉහතදී හඳුන්වා දුන් calc() නම් function එකට main() function එක තුලදී ආමන්ත්‍රණය කර එයට 2 සහ 3 යන අගයන් ලබා දීමයි. එහිදී පිලිවෙලින් a හා b සඳහා 2 සහ 3 අගයන් ලැබේ එවිට calc() තුලදි එහි result හි පිළිතුර ලෙස 5 ලැබෙන අතර එය එහි return අගය බැවින් main() තුළ x = calc(2,3) ලෙස ඇති බැවින් x සඳහා calc() හි return අගය ලැබේ. එනම් x සඳහා 5 යන අගය ලැබේ. printf මගින් එම x අගය මුද්‍රණය කර දක්වා ඇත.

යම් function එකක් තුලින් return අගයක් නැත්නම් එය void යන return type එකෙන් හඳුන්වාදිය හැකිය. එවිට එම function එක මගින් අගයක් return නොවන අතර එවැනි අවස්ථාවක එවැනි function එකකට call කිරීමෙදි එහි නම සහ ඇත්නම් argument pass කිරීම ප්‍රමාණවත්ය.

functionName();

Built-in functions යනු ක්‍රමලේඛ භාෂාවේ ඇති function වන අතර අපට ඒවායේ නාමකරණ අපේ function නැතිනම් user define function සඳහා භාවිතා කළ නොහැක. මෙහි අප භාවිතා කළ printf(). scanf() යනාදිය මෙන්ම තවත් නොයේකුත් අවශ්‍යතාවයන් සඳහා ක්‍රමලේඛ භාෂාව මගින් ලබාදී ඇති functions බොහෝමයක් ඇත.

8. C අටවන පාඩම - Pointers (දර්ශකයන්)

මෙම ලිපියෙන් මම බලාපොරොත්තු වෙන්නෙ C භාෂාවේ භාවිතා වන වැදගත් යෙදුමක් වන දර්ශක (Pointers) පිළිබදව විස්තර කිරීමටයි.

Pointer (දර්ශක) යනු මතක ගබඩාවේ ලිපිනයන් (Memory location address) සමග ගනුදෙනු කිරීමට C හි භාවිතා වන යෙදුමයි. මෙය භාවිතයෙන් ඉතා පහසුවෙන් memory location වෙත ගමන් කල හැකි අතර ඒවායෙහි ගබඩා කර ඇති values කියවීම, වෙනස් කිරීම ආදිය pointers භාවිතයෙන් පහසුවෙන් සිදු කර ගත හැක.

දර්ශක භාවිතයේදී පෙරදී භාවිතා නොකල අලුත් කාරක රීති (Syntax) භාවිතා කිරීමට සිදුවේ. මන්ද මෙහිදි අපට මතක ගබඩාවේ ලිපිනයටත්, ගබඩා වී ඇති දත්ත අගයටත් (Memory location address and Value) යන දෙකම ලබාගත යුතු බැවින්.

දර්ශක හදුන්වාදීමේදී එය pointer ආකාරයේ විචල්‍යක් බවත් එහි ගබඩා කළ හැකි දත්ත ආකාරය (Data type) කුමක්ද යන වගත් compiler එකට දැන්විය යුතුය. පහත දැක්වෙන්නෙ pointer variable එකක් declare කරන ආකාරයයි.

<variable_type> *<name>;

උදාහරණයක් ලෙස Integer ආකාරයේ විචළ්‍ය දර්ශකයක් හදුන්වාදෙන ආකාරය සලකා බලමු.

int *Number;

මෙහි දැකිය හැකි * (තරු/star) ලකුණින් හැගවෙන්නේ මෙම විචල්‍ය දර්ශකයක් බවයි.

සාමාන්‍ය විචල්‍යකින් මතක ගබඩා ලිපිනය(Memory location address) එක ලබා ගැනීම.

සමාන්‍ය විචල්‍යකින් memory location address එක ලබාගැනීමට C ක්‍රමලේඛනයේදී '&' සංකේතය භාවිතා කරයි.

int Number= 5;
int *p = &Number;

ඉහත උදාහරණය සලකන්න එහි මුලින්ම Integer ආකාරයේ Number විචල්‍යට අගය 5ක් ලෙස යොදා ඇත. දෙවනිව Integer ආකාරයේ p නම් පොයින්ටර් විචල්‍යකට &Number අගය ඇතුලු කර ඇත. මෙහිදී සිදුවන්නේ p හි අගය ලෙස Number විදල්‍යයේ Memory location address එක assign වේ.

පොයින්ටර් විචල්‍යකින් එහි මතක ගබඩාවේ අගය ලබා ගැනීම.

පොයින්ටර් විචල්‍යක් භාවිතයෙන් එහි ගබඩා කර ඇති ලිපිනයේ අඩංගු අගය ලබාගන්නා ආකරය දැන් අපි බලමු.

printf("%d", *p);

ඉහත උදාහරණයේ ආකාරයට *p ලෙස භාවිතා කිරීමෙන් අපට පොයින්ටරයේ අඩංගු අගය කෙලින්ම ලබාගත හැක.

ඉහත සාකඡ්චාකල දෑ සැකෙවින් පහදා ගැනීමට පහත උදාහරණය උත්සාහ කරන්න.

#include <stdio.h>

void main(){
    int x;            /* A normal integer*/
    int *p;           /* A pointer to an integer ("*p" is an integer, so p
                       must be a pointer to an integer) */

    p = &x;           /* Read it, "assign the address of x to p" */
    printf("Enter value:");
    scanf( "%d", &x );          /* Put a value in x, we could also use p here */
    printf( "Value of pointer is %d\n", *p ); /* Note the use of the * to get the value */
    printf( "Memory address is %d\n", p ); /*Display memory address from pointer */
    printf( "Memory address of x is %d\n", &x ); /*Use of & to get memory address */
    printf( "Value of x is %d\n", x ); 
}

මෙමගින් Pointer (දර්ශක) විචල්‍ය ගැන අවබෝධයක් ලබාගන්නට හැකිවන්නට ඇතැයි සිතමි. දර්ශක විචල්‍යද C හි භාවිතා වන තවත් විචල්‍ය ආකාරයකි.C හිදී එමගින් Memory location එක සමග ගණුදෙනු කිරීමට ක්‍රමලේඛකයාට අවකාශය ලබාදෙයි.

7. C හත්වන පාඩම - Arrays in C (දත්ත වැල් )

අද අපි බලමු C හි භාවිතාවන දත්ත වැල් නැතිනම් arrays පිළිබඳව.

අප ඉහත පාඩම්වලදි දැනගත්තු විදියට C වලදි variable එහෙම නැතිනම් විචල්‍ය භාවතිකළා මතක ඇති. හිතන්න එකම data type එකෙන් variable 100ක් විතර හදාගන්න ඕන වුනොත් මොකද වෙන්නෙ. අපි මෙතෙක් දන්නව විදියට නම් එකින් එක variable 100ක් වෙන වෙනම declare කරන්න වෙනවා. නමුත් ඒක ප්‍රායෝගිකව ඉතාම අපහසු කාර්යයක් බව පැහැදිලියි. ඒවගේම ඒවිදියට හාදාගන්න variable භාවිතා කරන්න ගියාමත් කරදරයි. ඉතින් මේකට විසඳුමක් විදියට තමයි අපි arrays භාවිතා කරන්නෙ. මේක දත්ත වැලක්. අපි බලමු කොහොමද array එකක් declare කරන්නෙ කියල.

Syntax of array

datatype arrayName[index]; //Index එක අනිවාර්යෙන්ම integer එකක් විය යුතුයි.

array declare කරගන්නෙත් අපි variable declare කර ගනු ලැබූ ආකාරයටමයි. නමුත් මෙහි ඇති එකම විශේෂත්වය නම් variable name එකට පසු කොටු වරහන් තුල Integer අංකයක් ලබා දීමයි. එමගින් ඉටුවන්නෙ අදාල variable එක array එකක් බවත් එහි එම integer අගය තරම් වන variable වැලක් ඇති බවත්ය.

Example

char name[10];

ඉහත උදාහරණය බලන්න. මෙහි datatype එක char වේ. එනම් character datatype එකෙන් name ලෙස slots (කට්ට) 10 ක් array එකක් මෙලෙස හඳුන්වාදිය හැක.

දත්ත අතුලු කිරීම සහ පිටතට ගැනීම.(Data assigning and reading)

array එකකට දත්ත අතුලත් කරගත හැකි ක්‍රම දෙකක් තිබෙනවා.

හඳුන්වාදෙන අවස්තාවේදිම දත්ත අතුලත් කර ගැනීම.(data initialization)
අවශ්‍යතාවය පරිදි දත්ත අතුලු කර ගැනීම. (data assign)

1. හඳුන්වාදෙන විටම දත්ත අතුලු කරගන්නේ මේ ආකාරයටයි.

char name[10] = {'a','b','c','d','e','f','g','h','i','j'};

මෙහිදී සඟල වරහන් තුල අගයන් ලබාදීම සිදු කරයි. '' භාවිතා කර ඇත්තේ characters නිසායි.මෙම array හි slots 10ක් පමණක් ඇති නිසා අගයන් දහයක් හෝ ඊට අඩුවෙන් ලබාදිය හැකිය.

2. අවශ්‍යතාවය පරිදි අගය ඇතුලු කරගනීම.

char name[10];

name[0] = 'a';
name[1] = 'b';
name[2] = 'c';
name[3] = 'd';
.
.
.
name[9] = 'j';

array භාවිතයේදී මතක තබාගත යුතු වැදගත්ම කාරණය වන්නෙ අප array එකක් slots 10ක් ඇති ලෙස සදාගත්තොත් එවා index වන්නෙ 0 සිට 9 දක්වා බවයි. හැමවිටම array එකක පළමු index එක 0 වන අතර එතැන් සිට පිළිවෙලින් slots ගැනීම සිදුකළයුතුය.

එලෙසම සමාන්‍ය variable සඳහා අගයන් ඇතුලු කිරීමේදි පිළිපදින ඕනෑම ආකාරයක් මෙහිදි භාවිතා කළ හැක.

දත්ත කියවීමේදීද ඉහත index එක පිළිබඳව සැලකිළිමත් විය යුතු අතර index එක මගින් array එකෙහි slots වෙන වෙනම හඳුනාගැනීම සිදුකරනු ලබයි.

array සමග වැඩකරන විට නිතරම අපට loops භාවිතාකිරීමට සිදුවේ. මන්ද දත්ත වැලක් සමග කටයුතු කරන බැවින් අපට ඒවාට අගයන් ඇතුලු කිරීමත් කියවීමත් loop මගින් පහසුවෙන් ඉටුකරගත හැක. index එක loop එකක් මගින් ගණනය කරවාගෙන එය යොදාගැනීමෙන් array එකෙහි අගයන් යෙදීමත් කියවීමත් කළ හැක. index එක ලෙස අපට අවශ්‍ය නම් integer variable එකක් වුවද භාවිතා කළ හැක.

අපගේ loop සම්බන්ධ පාඩම මගින් ඒ පිළිබඳව අවබෝධයක් ලබාගත හැක.

නැවත ලිපියකින් හමුවන තුරු ඔබට ජය.

6. C හයවන පාඩම - නැවත නැවතත් සිදුකිරීම (Loop)

මේ පාඩමෙන් බලමු ක්‍රියාවලියක් නැවත නැවත සිදුකරගන්න අවශ්‍යවිටදි ක්‍රමලේඛණයේ භාවිතාවන තවත් වැදගත් භාවිතයක් වන loop ගැන. loop එකක් යනු අර්ථයෙන්ම නොනැවති සිදුවන ක්‍රියාදාමයක් හඟවයි. ක්‍රමලේඛනයේදි අපිට යම් කිසි ක්‍රියාවලියක් නැවත සිදුකරගැනීමට අවශ්‍ය නම් එම කේත කොටස යලි ලිවීමට සිදුවේ. නමුත් මේ loop භාවිතයෙන් එම යලි ලිවීම අවම කොට එකම කේත කොටසක් නැවත නැවත භාවිතයට ගැනෙන ආකාරයට සකසා ගැනීමටත් එහි සිදුවීම පාලනය කරගැනීමටත් අපට අවකාශය ලබා දෙයි. එනම් අවශ්‍ය විටෙකදි පටන් ගැනීමටත් අවශ්‍ය විටකදි නතරකර ගැනීමටත් ආදි වශයෙන් කේතනය කිරීමට හැකියාව ලැබේ.

ඉහත රූපයේ දැක්වෙන්නෙ සරලවම loop එකක් ක්‍රියාකරන අන්දමයි. එහි පෙන්වා ඇති පරිදි යම් කිසි අවසථාවකදි පරීක්ෂාකෙරෙන condition එකක් මගින් එය නැවත සිදුකළ යුතුද නැතිනම් ඉවත් විය යුතුදැයි තීරණය කෙරේ. මෙහිදී condition එක සත්‍ය වනතුරු loop එක ක්‍රියාත්මක වන අතර condition එක අසත්‍ය වූ සැනින් loop එකෙන් ඉවත් වේ.

C හිදි භාවිතා වන loop වර්ග තුනක් හඳුනාගත හැකිය.

While loop
Do while loop
For loop

1. while loop

while loop එක යනු ක්‍රමලේඛනයේදි භාවිතා වන සරලම loop එකයි. මෙහිදි loop එකට ඇතුළුවීම පිණිස condition එක true විය යුතුය. එසේ ඇතුලුවූ පසු අදාල කේත කොටස execute වී නැවත condition එක පරීක්ෂාකරයි. මේ ආකාරයෙන් නැවත නැවත සිදුවන අතර යම් අවස්ථාවකදි condition එක false වන්නේ නම් එවිට loop එකෙන් ඉවත් වේ.

Syntax

while (condition[true/false]) 
{
    statement;
}

Example

int counter = 0;
while (counter<10) 
{
    printf("%d",counter);
    counter++;
}

ඉහත උදාහරණයේදි ඔබට පිළිතුර ලෙස තිරයේ 0 සිට 9 දක්වා output එක ලබාගත හැකිය.

මෙහිදී සිදූවිම සවිස්තරව දැනගනිමු.
මෙහිදි මුලින්ම හදුන්වා දී ඇති int counter යනු loop එකෙහි ක්‍රියාත්මක වාරගණන ගැන ගැනීම සඳහා මාවිසින් හදුන්වාගත් Integer type counter variable එකයි. එය ආරම්භයේදී 0 ලෙස අගයක් යොදාගෙන ඇත.
දෙවනි පෙලෙන් while ලෙස සඳහන් කිරීමෙන් මෙය while loop එකක් බවත් ඒ ඉදිරියේ ඇති වරහන් තුල පරීක්ෂාවිය යුතු condition එකත් ලබා දී ඇත. මෙහි ආරම්භය ලෙස counter යන variable එක 10ට වඩා කුඩාද යන්න පරීක්ෂාවට ලක් කෙරෙන අතර මෙම condition කොටස සඳහා ඔබට අවශ්‍ය පරිදි ඕනෑම Boolean result එකක ලබාදෙන statement එකක් (එනම් සත්‍ය(true) හෝ අසත්‍ය(false) ලෙස ප්‍රථිපලය ලබාදෙන) භාවිතා කළ හැක. loop වලදි බහුලව යොදාගනුයේ counter variable එකක් විචලනය කර අවශ්‍ය තාව සකසා ගැනීමයි.
ඉන් පසු සඟලවරහන් ආරම්භකයක් ( { ) දැකිය හැකිය. එමෙන්ම කේත කොටස අවසානයේ එහි ( } ) වැසුම දැකිය හැකිය. එම සඟලවරහන් කොටසින් කියැවෙනුයේ ඒ තුල ඇති කේත කොටස loop එකට අදාල කොටස බවයි. අපි මීට පෙර ඉගෙනගත් if ආදී පාඩම් වලදීද මෙම සඟලවරහනේ උපයෝගිතාවය ඉගෙන ගත්තෙමු.
ඊලඟ පෙලෙන් printf විධානයක් දැකිය හැකිය. එනම් මෙහිදි සරලවම අපේ counter variable එකෙහි පවතින අගය print කරගැනීම පමණක් සිදුකර ඇත.
counter++ යන පෙලින් සිදුකරගනු ලබන්නෙ අපගේ counter variable හි පවතින අගය එකකින් ඉහල දැමීමයි.

දැන් මුලින්ම counter = 0 බැවින් condition එක සත්‍ය වේ (condition එක වනුයේ counter<10 බැවින්). එබැවින් loop එක තුලට ඇතුලු වන අතර අදාල statement සියල්ල execute වූ පසු අවසානයේදී නැවත මුලට යමින් condition එක පරීක්ෂාකරයි. එවිට counter එකෙහි අගය එකකින් වැඩි වී ඇති නිසා නව අගය ලෙස 1 ලැබේ. එවිටත් condition එක සත්‍ය වන නිසා loop එක තුලට ඇතුලු වේ. මේ ආකාරයට 9 දක්වාම ගිය පසු counter එක 10 ලෙස පැමිණීමෙන් condition එක false වේ. එවිට loop එකෙන් ඉවත් වේ.

මෙය loop එකක සරල ක්‍රියාදාමය ලෙස හඳුනාගත හැකිය.

2. do.. while loop

Do...while loop හිදී පෙර පරිදිම සිදුවන නමුත් මෙහිදි statement එක එකවරක් execute වීමෙන් අනතුරුව condition එක පරීක්ෂාවට ලක්වීම සුවිෂේශීවේ.

එනම් condition එක පළමු අවස්ථාවේදී සත්‍ය වුවත් නොවුවත් එක වරක් loop එක තුල ඇති code එක execute වේ.

ඉන් පසු පෙර පරිදිම condition එක පරීක්ෂා කෙරෙන අතර එය සත්‍ය නම් නැවත මුලට ගොස් code එක execute වෙමින් පැමිණේ. එලෙස condition එක අසත්‍ය වන තුරු loop එක ක්‍රියාත්මක වේ.

Syntax

do
{
   statement;
} while (condition[true/false]);

Example

int counter = 0;
do
{
    counter++;
    printf("%d",counter);
}while (counter < 10);

මෙහිදී ඔබට පිළිතුර ලෙස 1 සිට 10 දක්වා ප්‍රථිපලයක් ලැබෙනු ඇත.
ඒ මන්ද...
මෙහි ආරම්භයේදී counter = 0 වේ. නමුත් පළමු අවස්ථාවේදී code එක execute වන බැවින් counter++ හිදී counter හි අගය 1 ලෙස වෙනස් කර මුද්‍රණය කරයි. එවිට පළමු අවස්ථාවේදී condition එක පරීක්ෂාවට ලක්වද්දී counter එකෙහි අගය 1 වේ. එය සිදුවන්නේ do..while හි සුවිෂේශී වූ එක අවස්ථාවක් execute වීමේ ගුණාංගය නිසායි. මෙලෙස 9 දක්වා අගයන් මුද්‍රණය වූ පසු condition එක පරීක්ෂා කරද්දී counter එක 9 වේ. එය සත්‍ය බැවින් නැවත මුලට යන අතර එම අවස්ථාවෙ counter++ මගින් අගය 10 ලෙස වෙනස් කරයි. එම නිසා 10 මුද්‍රණය වීමෙන්ද පසු එම අවස්ථාවේ condition එක පරීක්ෂා කෙරේ. එවිට ප්‍රථිපලය false බැවින් loop එකෙන් ඉවත් වේ.

3. for loop

for loop එක පෙර කතා කල while loop එකෙහිම වැඩි දියුණු අවස්ථාවක් ලෙස හැදින්විය හැකිය. මෙහිදී ඇති විශේෂත්වය නම් loop එක සඳහා වෙනස් කරනු ලබන variable එක for ලූප් එක තුලදීම හසුරවා ගැනීමයි. මෙය වඩා පහසුවෙන් හැසිරවිය හැකි බැවින් ක්‍රමලේඛණයේදී බහුලවම භාවිතා වන්නේ මෙම loop එකයි.

එය උදාහරණයක් මගින්ම පැහැදිලි කරගනිමු.

Syntax

for ( variable initialization; condition; variable update ) {
  Code to execute while the condition is true
}

Example

int x;

for ( x = 0; x < 10; x++ ) 
{
   printf( "%d\n", x );   
}

for loop එකෙහි මුලින්ම පද තුනකින් යුත්වරහනක් දැකිය හැක. එතුල ඇති පළමු පදයෙන් variable initialization එක හැඳින්වේ. එමගින් සිදුවන්නෙ පෙර දි counter හි අගය 0 ලෙස මුලින් ම සිදු කළ කාර්‍යයි. දෙවනි පදයෙන් සුපුරුදු පරිදි condition එකද තුන් වන පදයෙන් අපි මෙතෙක් loop එක තුළ භාවිතා කළ ආකාරයේ එක එක අවස්ථාවේදී update (යාවත්කාල) වීමද හදුන්වා දී ඇත. එම නිසා මෙම loop එක භාවිතය වඩාත් පහසු වී ඇත.
statement කොටසේදී printf විධානය පමණක් මෙහිදි ලබා දී ඇත. එම නිසා මෙහි ප්‍රථිපලය ලෙස 0 සිට 9 දක්වා අගයන් තිරය මත මුද්‍රණය වීම සිදුවේ.

C හිදි හඳුනාගත හැකි මෙම loop වර්ග තුන අනෙකුත් බොහෝ පරිගණක ක්‍රමලේක භාෂා වලදීද එකම ආකාරයක් වේ.
loop පාඩම මෙතෙකින් අවසන් වේ. ඔබ සතු ගැටලු අප වෙත ඉදිරිපත් කරන්න.
email: ndp.mymail@gmail.com

5. C පස්වන පාඩම - Switch Case (මං මාරු ක්‍රමය)

මන් සන්ධියක්....

කලින් පාඩමේදි මෙන්ම මේ පාඩමේදීත් අපි C භාෂාවේ බාවිතා වන තවත් කොන්දේසිගත(Conditional) විදික්‍රමයක් ගැන කතා කරමු. මං මාරු ක්‍රමය හෙවත් switch case statement එක හරහාද අපිට කලින් if else හිදි මෙන්ම තෝරාගැනීමක්(Selection) සිදුකරගත හැකිය. නමුත් if else භාවිතයේදිට වඩා මෙහි භාවිතය වෙනස් වේ. එමනිසා ක්‍රමලේඛ සැකසීමේදි අවශ්‍ය විටදි අවශ්‍ය කුමන ක්‍රමයදැයි තීරණය කිරීම ක්‍රමලේඛකරු (Programmer) සතු කාර්යකි.

මූලික මංමාරු පදගැලපුම (Basic switch syntax)

switch ( <variable> ) {
case this-value:
  Code to execute if <variable> == this-value
  break;
case that-value:
  Code to execute if <variable> == that-value
  break;
...
default:
  Code to execute if <variable> does not equal the value following any of the cases
  break;
}

මෙහිදි සිදුවන්නෙ මුලදි (switch) ලබා දෙන <variable> අගයට අනුව සත්‍යවන අවස්ථාව (case) execute කිරීමයි. ඒ අනුව switch case මගින් අපට නිර්ණය කළ හැක්කෙ යම් කිසි අගයකට සමාන වන අවස්ථාවේදි සිදුවිය යුතු කාරණය ගැන පමණි.

මෙය පැහැදිලි කරගැනීම සඳහා පහත ඇති රූපය බලන්න.

තව දුරටත් පැහැදිලි කරගැනීම සඳහා සරල උදාහරණයක් මගින් සාකච්ඡා කරමු.

int a = 10;
int b = 10;
int c = 20;

switch ( a ) {
case b:
  printf("a is equal 10");
  break;
case c:
  printf("a is equal 20");
  break;
default:
  printf("a is not equal b or c");
  break; 
}

ඉහත උදාහරණයේ a සඳහා දෙන අගයන් වෙනස් කරමින් උත්සාහ කරන්න. a = 10 අවස්ථාවේදී ඔබට පිළිතුර ලෙස a is equal 10 ලෙස දිස්වෙනු ඇත.
එමෙන්ම a = 20 විට එය a is equal 20 ලෙසත්, a සඳහා වෙනත් ඕනෑම අගයක් දුන් විට පිළිතරු ලෙස a is not equal b or c ලෙසත් දිස්වනු ඇත.

එනම් මං මාරු ක්‍රමය ක්‍රමලේඛයේදි හංදියක් වැනිය. අපට යා යුතු මග තෝරා දුන් පසු ක්‍රමලේඛය විසින් ඒ මගේ ගමන් කරනු ඇත.

4. C හතරවන පාඩම - If statement (එහෙම උනොත් මෙහෙම වෙන්න)

“එහෙම වුනොත් මෙහෙම කරන්න. නැතිනම් මෙහෙම කරන්න...“

අපි බාවිතාකරන භාෂාවෙන් යමක් කරන්නට උපදෙස් දෙන ආකාරය මේ ආකාර නේද. ඉතින් පරිගණක ක්‍රමලේඛනයේදීද පරිගණකය වෙත යමක් කිරීමේදි උපදෙස් දීම සදහා භාවිතාකරන කොන්දේසිගත (conditional) විදික්‍රමය ලෙස If else statement දැක්විය හැකියි. මෙවැනි conditional statement රහිත වුවොත් ක්‍රමලේඛය එකම මගක් ඔස්සේ හැමවිටම ධාවනය වේ. එමගින් අපට අපේක්ෂිත ප්‍රථිපල ලබාගැනීම උගහටය. මෙම පාඩමෙන් If else statement හි භාවිතය ගැන සැකෙවින් හදාරමු.

යම්කිසි තත්වයක් තෘප්ත කිරීම/නොකිරීම හෙවත් true or false ලෙස ලබෙන ප්‍රථිපලය අනුව මින් ඉදිරියට ක්‍රයාකරන්න යැයි උපදෙස් දීම මෙහිදි සිදුවෙ. එසේ නම් condition එක පරීක්ෂාකරගත හැකි ආකාර මොනවාදැයි මුලින්ම සොයා බලමු.

>     greater than  (විශාලය)           
<     less than     (කුඩාය)            
>=    greater than or equal (විශාල හෝ සමානය)    
<=    less than or equal  (කුඩා හෝ සමානය)      
==    equal to (සමානය)                 
!=    not equal to (අසමානය)

ඉහත දක්වා ඇති ආකාර 6 භාවිතයෙන් අපට කන්ඩිෂන් එක පරීක්ෂාකරගත හැක. එසේ පරීක්ෂාකර ගැනීමෙන් අපට ලැබෙන්නෙ බූලියානු පිලිතුරකි. එනම් අදාල condition එක තෘප්ත වේ නම් true ලෙසත් එසේ නොවේ නම් false ලෙසත් ය.

මූලික if පදගැළපුම (basic if statement syntax)

if ( condition )
    Execute this line of code

මෙහි condition එක true වූවහොත් අදාල coding line එක execute කිරීම ඇරඹේ. false වුවහොත් එම coding line එක පසෙකලා (skip කොට) ඉන් එහාට වැඩසටහන execute වේ.

මෙම ක්‍රියාවලිය උදාහරණයක් මගින් පැහැදිලි කරගනිමු.

if ( 5 < 10 )  
  printf( "Five is less than ten" );

ඉහත උදාහරණයට අනුව condition එක වන්නෙ 5<10 යන්නය. එය සත්‍ය වේ. එම නිසා ඒ තුල ඇති printf statement එක execute වී තිරය මත “Five is less than ten“ ලෙස තිරයේ output එක දැකගත හැක.

එලෙසම, තනි line එකක් වෙනුවට code set එකක් execute කිරීමට අවශ්‍ය නම් පහත ලෙස syntax එක වෙනස්විය යුතුය.

if ( TRUE ) {
  printf ("line of code 1");
  printf ("line of code 2");
  printf ("Braces indicate the more than 1 statement should execute"); 
}

මෙහි සඟල වරහන් “{ }“ මගින් if statement එක සත්‍ය වන විට execute විය යුතු code block එක හදුන්වා දෙයි.

Else (එසේ නොවේ නම්)

ඉහතදි කතාකලේ condition එක true වන අවසාථාවේදි execute විය යුතු ආකාරය ගැනයි. යම් හෙයකින් condition එක false වන විටදීත් වෙනත් විශේෂිත දෙයක් සිදුකරගැනීමට අවශ්‍ය නම් එවැනි අවස්ථාවලදි අපට else කොටස යොදාගත හැක.

if ( TRUE ) {
   Execute these statements if TRUE 
}
else {
   Execute these statements if FALSE 
}

Else if (එසේ නොවේ නම් මෙසේ වේද)

if ( condition 1 ) 
  {                  
     Execute these statements if condition 1 TRUE    
  }
  else if ( condition 2 ) 
  {            
     Execute these statements if condition 1 FALSE and TRUE        
  }
  else 
  {
     Execute these statements if condition 1 and 2 both are false     
  }

එක අවස්ථාවකට වඩා condition එක පරීක්ෂාකිරීමට අවශ්‍ය විට මෙම multiple if statement එක යොදාගත හැකිය. එමගින් මුලින්ම if කොටසේ ඇති condition එක පරීක්ෂා කරයි (උදා: age<100) එය true නම් ඒ යටතේ ඇති statement එක execute වන අතර ඉතිරි else if හා else කොටස් අතහැර දමා වැඩසටහන ඉදිරියට යයි. if කොටසේ condition එක false වුවහොත් ඊලඟට ඇති else if කොටසේ condition එක පරීක්ෂා කරයි. ඒ ආකාරයට අපට අවශ්‍ය තරම් if statement එක දිගු කරගනිමින් භාවිතා කල හැකිය.

ඉහත උගත් දැ සම්පූර්ණ ක්‍රමලේඛ උදාහරණයක් මගින් දැක්වූවහොත් ඒ මෙසේය.

#include<stdio.h>
void main(){
 int age = 0;
 printf ("How old are you?");
 scanf ("%d", &age);
 
 if (age<16) {
  printf (" you are yung ");
 } else if ( age < 30) {
  printf (" you are teenager ");
 } else {
  printf (" you are a growned person ");
 }
}

3. C තුන්වන පාඩම - C හි කාරකයන් සහ දත්ත ප්‍රදානය (Operators and data Input method)

Conversion letters සහ ඒවායේ data types
අප ඉහත පාඩමේදි int type හි variable print කර ගැනීම සඳහා %d මෙලෙස සංඛේතයක් භාවිතා කලා මතක ඇති. මෙමගින් දැක්වෙනුයේ conversion latter එකයි. එනම්, ක්‍රමලේඛයේ යමක් ප්‍රදානය හෝ ප්‍රතිදානය කිරීමේදි variable හදුන්වාදීමට C හිදි භාවිතා වන එක් සුවිශේෂි ආකාරයකි. පහත වගුවේ C හි භාවිතා වන conversion letters කිහිපයක් සහ ඒවයේ data types දක්වා ඇත. conversion latter යොදාගැනිමේදි අනිවාර්යෙන්ම ඊට ඉදිරියෙන් ‘%‘ සංඛේතය භාවිතා කල යුතුය.

Letter	Type of Matching Argument	Example	Output
%	none	`printf( "%%" );`	`%`
d, i	`int`	`printf( "%i", 17 );`	`17`
u	`unsigned int` (Converts to decimal)	`printf( "%u", 17u );`	`17`
o	`unsigned int` (Converts to octal)	`printf( "%o", 17 );`	`21`
x	`unsigned int` (Converts to lower-case hex)	`printf( "%x", 26 );`	`1a`
X	`unsigned int` (Converts to upper-case hex)	`printf( "%X", 26 );`	`1A`
f, F	`double`	`printf( "%f", 3.14 );`	`3.140000`
e, E	`double`	`printf( "%e", 31.4 );`	`3.140000e+01`
g, G	`double`	`printf( "%g, %g", 3.14, 0.0000314 );`	`3.14, 3.14e-05`
a, A	`double`	`printf( "%a", 31.0 );`	`0x1.fp+0`
c	`int`	`printf( "%c", 65 );`	`A`
s	string	`printf( "%s", "Hello" );`	`Hello`
p	`void*` (convert a pointer)	`int a = 1; printf( "%p", &a );`	`0064FE00`
n	`int*` (Number of character output)	`int a; printf( "ABC%n", &a );`	`ABC` (a==3)

දත්ත ප්‍රදානය කිරිම (Input handling)

අප මෙතෙක් භාවිතා කලේ ප්‍රතිදානයක් තිරය මත මුද්‍රණය කරගන්නා printf statement එකයි. එමෙන්ම විචල්‍යන් සඳහා අගයන් යෙදීම සිදුකලේ source code එකේදි වන අතර compile කරන ලද programe එක ධාවනය වන අවස්ථාවේදි අගයන් ඇතුලු කිරීමට නොහැකි විය.
ධාවනය වන අවස්ථාවේදි ප්‍රධානයක් (input) ලබාදීමට C හිදි භාවිතා කරන්නේ scanf statement එකයි.

scanf ("%conversion latter..", &variable....); 

Example:
scanf("%d", i);

කාරක (Operators)

ක්‍රමලේඛයේදි අපට විවිධ අවස්තාවන්වලදි ගණිත කර්ම, සැසඳිම, වැනි කර්තව්‍යන් කරගැනීමට අවශ්‍ය වේ. එවැනි අවස්ථාවන් වලදි අප භාවිතා කරන සම්මත කාරක (Operators) ඇත. C හිදි භාවිතා වන එවැනි කාරක කිහිපයක් පහත දැක්වේ.

Arithmetic (ගණිත කර්ම)

+      එකතු කිරිම (plus)
-      අඩු කිරීම (decrease)
/      බෙදීම (Divide)
*      වැඩිකිරිම (Multiplex)
%      මාපාංකානුකූලකය-බෙදා ඉතිරිවන අගය (modulo)

--     පවතින අගයෙන් එකක් අඩුකිරිම (Decrement)

++     පවතින අගයට එකක් එකතුකිරිම (Increment)

Assignment (පැවරුම්)

 =      Assign 
*=      Multiply
/=      Divide.
%=      Modulus.
+=      add.
-=      Subtract.
<<=     left shift.
>>=     Right shift.
&=      Bitwise AND.
^=      bitwise exclusive OR (XOR).
|=      bitwise inclusive OR.

Logical/Relation (තාර්කික/සම්බන්ධතා)

==      Equal to
!=      Not equal to
>       Greater Than
<       Less than 
>=      Greater than or equal
<=      Less than or equal
&&      Logical AND
||      Logical OR
!       Logical NOT

Bitwise (බිටු අගයන් සම්බන්ධ කාරක)

&       AND (Binary operator)
|       inclusive OR
^       exclusive OR
<<      shift left.
>>      shift right. 
~       one's complement

C හි භාවිතා වන තවත් කාරක කීපයක්

sizeof() size of objects and data types.
&       Address of (Unary operator)
*       pointer (Unary operator)
?       Conditional expressions
:       Conditional expressions
,       Series operator.


මෙම එක් එක් කාරකයේ භාවිතාවන් හදුනාගැනීමට සරල වැඩසටහනක් භාවිතයෙන් පුලුවන. ඉදිරියේදි විවිධ අවස්ථාවලදිකාරක භාවිතාවන විට මේ පිළිබඳ වඩාත් හොදින් අවබෝධ කරගත හැකිවනු ඇත. 

මීලඟ පාඩමෙන් Selection (තොරා වෙන්කර ගැනිම) සම්බන්ධයෙන් කතා කරමු.

2. C දෙවන පාඩම - C භාෂාවේ මූලික යෙදීම් (Basic of C language)

C භාවිතයේදි අප විසින් දත යුතු යෙදීම් ඇත. මෙම ලිපියෙන් එවැනි මූලික යෙදීම් කිහිපයක් පිළිඹඳ දැනුම ඔබ වෙත ගෙන එන්නම්. එමගින් අපට ඉදිරියට පාඩම් ඉගෙන ගනීම වඩාත් පහසු කරවයි.

Comment
C භාෂාවෙදි Comment කිරිමේ පහසුකම සලසා ඇත. එමගින් සිදුවන්නෙ සරලව comment කර ඇති කොටස මග හැර ඉතිරු කොටස් පමණක් compile වීමයි.

C හි comment කල හැකි ආකාර දෙකක් පවතී.
1. තනි line එකක් comment කිරීම.

මෙහි දැක්වෙන ආකාරයට "//" සංඛේතයෙන් හැදින්වෙන්නෙ comment එකක ආරම්භය බවයි. ක්‍රමලේඛය compile වන අවස්ථාවේදි මෙලෙස ඇරඹී ඇති පද අතහැර ඉදිරියට යයි.

2. පේලි කිහිපයක් එකවර comment කිරීම.

මෙහි දැක්වෙන ආකාරයට "/*" ලෙස ඇරඹෙන code line එක comment එකෙහි ආරම්භය ලෙසත් "*/" ලෙස එහි අවසානය සනිටුහන් වන තුරු පේලි කිහිපයක් වුවත් commented කොටසක් ලෙස compiler එක විසින් හදුනාගනියි.

Variable (විචල්‍ය)
variable යනු නාමික අර්ථයක් දෙන ලද නිස්චිත memory location address (මතක පිහිටුම් ලිපිනයකි). විචල්‍ය යොදාගැනිමෙන් අපට පහසුවෙන් දත්ත තාවකාලිකව ගබඩාකරගනිමින් ක්‍රමලේඛය තුල ඒවා හැසිරවිය හැක. එමගින් දත්ත හැසිරවීම වඩාත් ඵලදායි වේ.
Variable එකක් හදුන්වා දෙන්නෙ මෙලෙසය.

data_type variable_name;

eg: 
int myVariable;

C හි භාවිතා වන මූලික data types පහත ආකාර වේ.

int
Integer(නිඛිල) සංඛ්‍ය සඳහා භාවිතා වේ. මෙහි -32768 සිට +32767 දක්වා වූ ඉලක්කම් ගබඩාකරගත හැක.

float
Floating point(දශමය) සංඛ්‍යා සඳහා භාවිතා වේ.

double
විශාල දශමය සංඛා සඳහා භාවිතා වේ.

char
Characters (අක්ෂර) සඳහා භාවිතා වේ.

මීට අමතරව ඉහත සඳහන් data type සඳහා modifier යොදාගත් අවස්ථා දැකිය හැක.

short
long
signed
unsigned

මේවා මගින් විචල්‍ය සඳහා වෙන්කල යුතු ඉඩ ප්‍රමාණය හදුන්වා දෙයි. මේ පිළඹදව දල අදහසක් පහත වගුව පිරික්සීමෙන් ලබාගත හැක.


   Type Bytes                            Range
---------------------------------------------------------------------


            short int  2          -32,768 -> +32,767          (32kb)
   unsigned short int  2                0 -> +65,535          (64Kb)
         unsigned int  4                0 -> +4,294,967,295   ( 4Gb)
                  int  4   -2,147,483,648 -> +2,147,483,647   ( 2Gb)
             long int  4   -2,147,483,648 -> +2,147,483,647   ( 2Gb)
          signed char  1             -128 -> +127
        unsigned char  1                0 -> +255
                float  4 
               double  8  
          long double 12

එමෙන්ම C භාෂාවෙ variable හදුන්වාදෙන ආකාර දෙකක් පවති.
1. Local Declaration
2. Global Declaration

Local variable Declaration

යම් කිසි Function එකක් තුලට පමණක් වලංගුවන ලෙස variable හදුන්වාදීම වේ. Function block එකෙහි ඉහලින්ම variable හදුන්වාදීම සිදු කෙරෙයි. මෙම විචල්‍ය භාවිතා කල හැක්කෙ එම function තුලදි පමණක් වේ. ඒවාට පිටත සිට දත්ත ඇතුලු කිරීම වෙනස් කිරීම ආදි කිසිවක් සිදුකල නොහැක.
Local variable අප විසින් initialize කල යුතුය.

Global Variable Declaration

ක්‍රමලේඛයේ සියලුම function ලිවීමට පෙර include විධානයට පසු variable declare කිරීම වේ.
මෙලෙස හදුන්වාදෙන විචල්‍ය ඊට පසු ඇති ඕනැම function එකකින් පහසුවෙන් ඇතුලු වී, දත්ත ඇතුලු කිරීම වෙනස් කිරීම ආදිය කල හැකිය.

දැන් අපි උගත් දෑ යෙදෙන සරල වැඩසටහනක් සකසා බලමු.

#include<stdio.h>

//global declaration
int a;

void main(){
 int x=4;
 
 a=2;
 printf("Global variable %d \n", a);
 
 printf("local variable %d \n", x);
}

මීලඟ පාඩමෙන් C හි operators(කාරක) හා ඒවායෙ භාවිතය ගැන සොයා බලමු.

1. C පළමු පාඩම - Say hello to C world.

පෙර පාඩමේදි මවිසින් විස්තරකල ආකාරයට C ක්‍රමලේඛණය සඳහා දැන් ඔබ සන්නද්ධව සිටිය යුතුය.

C ක්‍රමලේඛ භාෂාව Structured Programming Language (ව්‍යුහගත ක්‍රමලේඛ භාෂාව) කි. එනම් මෙමගින් ක්‍රමලේඛණයේදි යම් කිසි අනුපිළිවෙලකට ක්‍රමලේඛණය සිදුකල යුතුය.

එමෙන්ම C භාෂාව case sensitive ය. එනම් ක්‍රමලේඛණයේදි ඉංග්‍රිසි කැපිටල් සහ සිම්පල් අක්ෂර භේදය ගැන සැලකිලිමත් විය යුතුය.

හොදයි අපි දැන් සරල ක්‍රමලේඛයක් ඔස්සේ C භාෂාවට පිවිසෙමු.

ඉහත කේත කොටස ඔබේ compiler මෘදුකාංගයේ coding window හි type කරගන්න.

දැන් අපි මෙහි එක් එක් කොටස් පැහැදිලි කරගනිමු.

#include<stdio.h>

මෙම කේත කොටස මගින් සිදුවන්නෙ කලින් සැකසූ කේත කොටස් සහිත ගොනු අපේ program එකට import කර ගැනීමයි. එමගින් අපට වඩා පහසුවෙන් ක්‍රම‍ලේඛනය කිරීමට පහසුකම් සලසයි. එමෙන්ම මෙහි stdio.h නමැති header ගොනුව මගින් අපේ ක්‍රමලේඛනයට අවැසි මූලික ආදාන/ප්‍රතිදාන (Basic Input/Output) operation වලට ඉඩසලසා දෙයි.

int main()

මෙම කේත කොටසින් මූලික වශයෙන් C හි භාවිතාවන function එක නිරූපනය වේ.
Function යනු C හිදි භාවිතා වන වැදගත් යෙදුමකි. එමගින් අප ලියන සංකීර්ණ කේතයක් කොටස් වලට වෙන් කොට පහසුවෙන් පරිපාලනය කරගත හැකිය. මේ පිළිබඳව ඉදිරියේදි සවිස්තරාත්මකව කතාකරිමට බලාපොරොත්තු වෙමි. දැනට මෙහි භාවිතා වන main function එක ගැන අවබෝධයක් ලබාගනිමු.
C ක්‍රමලේඛන භාශාවේදි විවිධ Function සිය ගණනක් ලිව්වත් අනිවාර්යෙන්ම එහි එක main function එකක් පැවතිය යුතුය. මෙහිදි අප භාවිතා කර ඇත්තෙ main function එක පමණි. එමගින් කේතයේ මුලින්ම කියවිය යුත්තේ කුමන කොටසදැයි අවබෝධයක් පරිගණකයට ලබාදෙයි. මෙහි යොදා ඇති වරහන් “()“ මගින් main යනු function එකක් බව හදුන්වා දී ඇත.

මෙම කේතකොටසේ int ලෙස යොදා ඇත්තේ මෙම main function එක මගින් integer වර්ගයේ return (ඊම) ක් ඇති බව පෙන්වා දීමයි.

හැම විටම function එකක් හඳුන්වාදීමෙන් පසු සඟල වරහන් “{ }“ භාවිතයෙන් එම function එකට අදාල කේත කොටස වෙනම කේත කොටසක් ලෙස කොටස් කිරීම සිදු කෙරේ. එනම් { වරහනින් ඇරඹී } වරහනින් අවසන් වන තෙක් කොටස එම function එකට අදාල යයි හඳුන්වා දෙයි.

printf("hello world\n" );

මෙහිදි දක්වා ඇත්තෙ function එක මගින් අප කරගන්නට යෙදෙන කටයුත්තයි. මෙහි මූලික වශයෙන් ප්‍රථිපලයක් තිරය මත දිස්වීම සිදුකරගෙන ඇත. ඒ සඳහා output එක ලබාගැනීමට printf යෙදුම භාවිතා කරයි. එය C හි සම්මත output command එකකි.

printf යටතේ තිරය මත මුද්‍රනය විය යුතු කොටස වරහන් තුල “ “ ඇතුලත ලිවිය යුතුය. එමගින් ලියා ඇති කොටස වචන මාලාවක් ලෙස පරිගණකය හදුනාගනි.

\n යනු newline character එකයි. එමගින් අලුත් තීරුවකින් අරඹන ලෙස පරිගණකයට විධාන කෙරේ.

සෑම කේත පේලියකම අවසානයට තිත් කොමාව(semicolon) “ ; “ යෙදීමෙන් එම පේලියේ අවසානය බව පරිගණකයට දැනුම් දීම සිදු කෙරේ.

return 0;

ඉහත main function ගැන කල සටහනේදි int ලෙස යෙදීමෙන් main function එක මගින් integer return එකක ඇති බව පවසන ලදි. නමුත් මෙම කේතයේදි මූලික වශයෙන් තිරය මත මුද්‍රණයක් ලබාගත්තා විනා කිසිවක් පිටතට නොයවන ලදි. එම නිසා return 0; ලෙස යෙදිමෙන් 0 අගය return කරන බව දන්නා ඇත.

නිතරම int හෝ එවැනි data type එකක් යෙදු function එකක return එකක් අනිවාර්යෙන්ම පැවතිය යුතුය. data type ගැන ඉදිරියේදි සවිස්තරාත්මකව විස්තර කෙරේ.

යම් කිසි function එකකින් කිසිවක් return නොවේ නම් එය void ලෙස හඳුන්වා දිය හැකිය.

එනම් ඉහත කේතයම පහත ලෙසද ලිවිය හැක.

දැන් ඔබ සාර්ථකව කේතනය කර ඇති ක්‍රමලේඛයේ output එක ලබාගත යුතුය. එනම් මෙම කේතය compile කරගත යුතුය. ඒ සඳහා ඔබ භාවිතා කරන compiler ය අනුව කේතය build කරගත යුතුය. පහත C-free මෘදුකාංගය සඳහා එය සිදුකරන ආකාරය පෙන්වා දී ඇත.

Build -> Run

හෝ
මෙහි පෙන්වා ඇති ආකාරයට Run බොත්තම මත clik කිරිමෙන් හෝ යතුරු පුවරුවේ F5 යතුර මගින් අපට පහසුවෙන් කේතය compile කරගත හැක. එමෙන්ම නිවැරදිව compile වූයෙ නම් එමගින් output එකද දිස්වේ.

Output window

ක්‍රමලේඛය නිවැරදිව compile වී output එකක් ලබාගැනීමට හැකිවූයේ නම් ඔබේ source code එක save කල ස්ථානයේ එම නමින් .exe ෆයිල් එකක් දැක ගත හැකිවනු ඇත. එය ඔබ ලියු program එකෙහි සාර්ථකව නිපදවු application එකයි. එනම් ඔබ සාර්ථකව පළමු ක්‍රමලේඛය සකස්කරගෙන හමාරය. එය මත double click කිරීමෙන් සරලව ඔබේ ක්‍රමලේඛය run කල හැක. එය සැනෙන් දිස්වී නොපෙනි යනු ඇත.

මෙම ලිපියට අදාල source file එක මෙතනින් බාගත කරගන්න.

ඔබේ ප්‍රශ්න හා යෝජනා, චෝදනා, අදහස්, පහතින් comment කිරීමෙන් හෝ විද්‍යුත් තැපැල් මගින් යොමු කරන්න.
ndp.mymail@gmail.com

මීලඟ පාඩමින් හමුවන තෙක් ඔබට සැමට ජය...

C භාෂාව සමඟ ක්‍රමලේඛණය හඳුන්වාදීම- Programming with C language introduction

C භාෂාව පරිගණක භාෂාකරණයේ අත්පොත ලෙස හැඳින්වීම වරදක් නොවේ. ඉදිරියේදි මෙම ලිපි පෙලින් C පරිගණක භාෂාව සමග ක්‍රමලේඛනය කරන විදිය ගැන සරලව සිංහලෙන් ගෙන ඒමට බලාපොරොත්තු වෙමි.

ඉතිහාසය:
C භාෂාවේ නිර්මාතෘ වරුන් වන්නේ ඩෙනිස් රිචි සහ බ්‍රයන් කනිංහැම් යන පරිගණක විද්‍යාඥ්‍යවරුන් දෙපලයි. ඒ 1969-1973 කාලයේදි K&R දෙපල විසින් බෙල් දුරකතන විද්‍යාගාරයේදි UNIX පරිගණක මෙහෙයුම් පද්ධතිය සමඟ භාවිතය සඳහා C භාෂාව නිර්මාණය කරන ලදි.

අවශ්‍ය මෘදුකාංග සපයා ගන්න:
C ඉගෙන ගැනීමේදි මෙන්ම අප ලියන ක්‍රමලේඛ (Codes) compile කරගැනීම සඳහා Compiler එකක් තිබිය යුතුය.
ඒ සඳහා මා භාවිතා කරන්නෙ Borland Turbo C++ 4.51Compiler මෘදුකාංගයයි.
එය මෙතනින් බාගත කරගන්න.

එසේ නැතිනම් C-free 5 මෘදුකාංගය මෙතනින් බාගත කරගන්න.
C-free බාගත කොට ස්ථාපනය කරගත් ඔබ එය රෙජිස්ටර් කල යුතුය. එසේ නැතිනම් දින 30කින් එහි ක්‍රියාකාරීත්වය අහෝසිවනු ඇත.
ඒ සඳහා C-free Open කර එහි Help යටතේ ඇති Register වෙත යන්න.

එය පහත ආකාරයට පුරවා OK කරන්නCompany or Username: TEAM MESMERiZE E-mail Address: MESMERiZE@wejustdo.it Registration code: 5Onmluz+3IHs7MK+w9nGr83Dm7Ld+PCa5Iz4nvrh8InA9vDb

එසේත් නැතිනම් ඔබ කැමති ඕනෑම C compiler එකක් මේ සඳහා භාවිතා කල හැක.

ඉහත මෘදුකාංග දෙකෙන් ඕනෑම එකක් ස්ථාපනය කරගත් පසු ඔබ C programming සඳහා සන්නද්ධව සිටියි.

මීලඟ පාඩමෙන් C programming පළවන පාඩම ආරම්භ කරන තෙක් ඔබ සැමට ස්තූතියි.

මේ සම්බන්ධ ඕනැම ගැටලුවක් පහතින comment කරන්න.
නැතිනම් මගේ විද්‍යුත් තැපැල් ලිපිනයට එවන්න.
ndp.mymail@gmail.com

Pages

Saturday, June 29, 2013

9. C නවවන පාඩම - C හි ශ්‍රිත භාවිතය (Functions/Methods in C)

Wednesday, March 6, 2013

8. C අටවන පාඩම - Pointers (දර්ශකයන්)

Thursday, December 20, 2012

7. C හත්වන පාඩම - Arrays in C (දත්ත වැල් )

Monday, October 22, 2012

6. C හයවන පාඩම - නැවත නැවතත් සිදුකිරීම (Loop)

Sunday, September 23, 2012

5. C පස්වන පාඩම - Switch Case (මං මාරු ක්‍රමය)

Wednesday, July 25, 2012

4. C හතරවන පාඩම - If statement (එහෙම උනොත් මෙහෙම වෙන්න)

Tuesday, July 24, 2012

3. C තුන්වන පාඩම - C හි කාරකයන් සහ දත්ත ප්‍රදානය (Operators and data Input method)

Thursday, July 5, 2012

2. C දෙවන පාඩම - C භාෂාවේ මූලික යෙදීම් (Basic of C language)

Friday, June 22, 2012

1. C පළමු පාඩම - Say hello to C world.

Wednesday, June 20, 2012

C භාෂාව සමඟ ක්‍රමලේඛණය හඳුන්වාදීම- Programming with C language introduction

අපි යන එන තැන්

About