තවත් අපූරු ඡන්දයක් නිම විය. එය කරුණු රැසක් නිසා අපූර්ව වේ. සමහරු කියන පරිදි රදලයන්ගේ දේශපාලනයේ අවසානයක් (තාවකාලිකව හෝ) ඉන් සිදු විය. වැඩ කරන ජනයාගේ, නිර්ධන පංතියේ නායකයෙකු හා පක්ෂයක් බලයට පත් වීමද සුවිශේෂී වේ. රටේ මෙතෙක් සිදු වූ සකල විධ අපරාධ, දූෂන, භීෂන සොයා දඩුවම් කරනවා යැයි සමස්ථ රටවැසියා විශ්වාස කරන පාලනයක් ඇති විය. තවද, බහුතර කැමැත්ත නැති (එනම් 43%ක කැමැත්ත ඇති) ජනපතිවරයකු පත් විය. ජවිපෙ නායකයෙක් "තෙරුවන් සරණයි" කියා පැවසීමත් පුදුමය. මේ සියල්ල ලංකා ඉතිහාසයේ පලමු වරට සිදු වූ අපූරු දේශපාලන සංසිද්ධි වේ. මාද විවිධ හේතුන් මත අනුරට විරුද්ධව මෙවර තර්ක විතර්ක, සංවාද විවාද, හා "මඩ" යහමින් ගැසූ තත්වයක් මත වුවද, ඔහු දැන් රටේ ජනපති බැවින් ඔහුට පලමුව සුබ පතමි. ඔහුට විරුද්ධව වැඩ කලත්, මා (කිසිදා) කිසිදු පක්ෂයකට හෝ පුද්ගලයකුට කඩේ ගියේද නැති අතර අඩුම ගණනේ මාගේ ඡන්දය ප්රකාශ කිරීමටවත් ඡන්ද පොලට ගියෙ නැත (ජීවිතයේ පලමු වරට ඡන්ද වර්ජනයක). උපතේ සිටම වාමාංශික දේශපාලනය සක්රියව යෙදුනු පවුලක හැදී වැඩී, විප්ලවවාදි අදහස්වලින් මෙතෙක් කල් දක්වා සිටි මා පලමු වරට සාම්ප්රදායික (කන්සර්වටිව්
ඉහත
සාකච්ඡා කළ කරුණු ඉදිරියේදී
උදාහරණවලදී ප්රායෝගිකවම
ඔබට සිදුකර බලාගත හැකියි.
දැන් අප සලකා
බලමු උදාහරණවල නිතරම දක්නට
ලැබෙන printf() හා
scanf() යන
කමාන්ඩ් දෙක ගැන කෙටියෙන්.
ඇත්තටම මෙම
කමාන්ඩ් දෙක ප්රායෝගික
"සත්ය"
GUI ප්රෝග්රෑම්වලදී
එතරම්ම වැදගත් නොවුණත්,
කොන්සෝල්
ප්රෝග්රෑම්වලදී නැතිවම
බැරිය. මෙම
කමාන්ඩ් දෙක ෆන්ක්ෂන්
(function) ලෙසයි
හැඳින්විය යුත්තේ (තව
මොහොතකින් ෆන්ක්ෂන් ගැන කතා
සාකච්ඡා කෙරේ).
printf() යන
ෆන්ක්ෂන් එකෙන් කරන්නේ එහි
වරහන තුළ ලියා ඇති යමක් තිරයේ
දිස් කිරීම බව ඔබට දැනටමත්
අවබෝධවී ඇති. එහි
සරලතම ආකාරය නම්, ඔබ
යම් ප්රකාශනයක් වරහන තුළ
උදෘත ඇතුලේ ලිවීමයි (පහත
ස්ටේට්මන්ට් එක බලන්න).
printf(“This is
just a sample text.”);
නිකංම
ප්රකාශයක් සමග එස්කේප්
කෝඩ්/සීක්වන්ස්
අවශ්ය නම් ලිවිය හැකියි.
ඔබ මීට පෙර
දැක්කා \n යන
එස්කේප් කෝඩ් එක. ඊට
අමතරව තවත් එස්කේප් කෝඩ්
කිහිපයක් ඇති අතර ඒවා පහත
දැක්වේ.
එස්කේප්
කෝඩ් එක |
එහි තේරුම |
\f |
Form feed - ඊළඟ
පිටුවට යෑම |
\n |
New line - ඊළඟ
පේලියට යෑම |
\r |
Carriage return - ඉන්න
පේලියේම මුලට යෑම |
\t |
Tab - ටැබ්
ස්පේස් එකක් තැබීම |
\\ |
Backslash - බැක්ස්ලෑෂ්
අකුර දිස් කිරීම |
\’ |
Single quote - තනි
උඩුකොමාව දිස් කිරීම |
\” |
Double quote - ද්විත්ව
උඩුකොමාව දිස් කිරීම |
\b |
Backspace - බැක්ස්පේස්
එක ක්රියාත්මක කිරීම |
\nnn |
Octal number - ඔක්ටල්
නිරූපණ ක්රමයෙන් ඉලක්කමක්
පෙන්වීම |
උදාහරණයක්
ලෙස ඔබ මීට කලින් ලියපු
hello_world.c ප්රෝග්රෑම්
එකේ printf() ස්ටේමන්ට්
එක printf(“Hello \r you\n”); ලෙස
සකසා කම්පයිල් කර බලන්න.
ඔබට එය රන්
කරන විට තිරයේ පෙනේවි youlo
යන වචනය.
එසේ වීමට
හේතුව සිතාගත හැකියි නේද?
ප්රෝග්රෑම්
එක රන් වී printf() කමාන්ඩ්
එක රන් වන විට, පළමුව
Hello යන
වචනය ලියයි. ඉන්පසුව
\r යන්න
හමු වේ. එහි
ප්රතිපලයක් ලෙස ඊළඟ වචනය/අකුරු
ලියවෙන්නේ නැවතත් එම පේලියේම
මුල සිටයි. ඉතිං
\r ට
පසුව ඇති you යන
වචනය Hello යන්න
උඩින් ලියැවේ. එවිට
you යන්නෙහි
ඇති අකුරු 3 විසින්
Hello යන්නෙහි
මුල් අකුරු 3 ඉවත්
වේ. ඉතිරි
අකුරු වන lo එලෙසම
පවතීවි. එහෙත්
you වෙනුවට
දිගු වචනයක් තබුණේ නම්,
පරණ අකුරු
කිසිවක් නොපෙනෙනු ඇත (you
වෙනුවට දිගු
වචනයක් ලියා ප්රෝග්රෑම්
එක කම්පයිල් කර බලන්න).
ඉහත
hello_world ෆයිල්
එකේම \r වෙනුවට
\t, \f, \b යන
එස්කේප් කෝඩ් ආදේශකර බලන්න.
ඒවායෙන්
සිදුවන දේ ඔබටම බලා ගත හැකියි.
තවද,
\” යන්න ලියූ
විට ද්විත්ව උඩුකොමාවක් දිස්
වේවි. ඔබ
අසාවි ඉතිං අමුතුවෙන් බැක්ස්ලෑෂ්
එකක් මොකටද නිකංම ද්විත්ව
උඩුකොමාව ලිව්ව නම් හරිනෙ
කියා මොකද ? යන්න
දර්ශනය කිරීමට \? ලෙස
නොලියා නිකංම ? ලෙසනෙ
ලියන්නෙ. නැත.
නිකංම ද්විත්ව
උඩු කොමාවක් printf() තුල
ලිවිය නොහැකියි. ඊට
හේතුව දැනටමත් ද්විත්ව උඩුකොමාව
විශේෂ රාජකාරියක් වෙනුවෙන්
printf() භාවිතා
කරනවානෙ (එනම්
ඔබ ලියන සියලු දේ () තුළ
ලියන්නේ " “ තුලයි).
ඉතිං \
යන්නෙන්
තමයි එම විශේෂ රාජකාරිය ඉස්මතු
නොකර නිකංම එය දර්ශනය කරන ලෙස
කම්පයිලරයට කියා සිටින්නේ.
එලෙසමයි \\
යන්නත්.
දැනටමත් \
යන්න එස්කේප්
කෝඩ් ලිවීමේ රාජකාරිය කරන
නිසා, ඔබට
\ යන්න
සංඛේතයක් ලෙස තිරයේ දර්ශනය
කිරීමට අවශ්ය නම් \\ ලෙස
ලිවිය යුතු වෙනවා. එලෙසම
\’ ගැනත්
සිතන්න.
printf() ෆන්ක්ෂන්
එක තුළ ලිවිය හැක්කේ එක් "
“ පමණයි.
එම උදෘතය
තුළ ඔබට ඕනෑ තරම් දේවල් ලිවිය
හැකියි. ඒ
අනුව, printf(“one string”, “another
string”); ලෙස
කොමා යොදා ලිවිය නොහැකියි.
එහෙත් අවශ්ය
නම්, printf(“one string” “another string”);
ලෙස කොමා
නොයොදා " “ කිහිපයක්
ලිවිය හැකියි. තවද,
හැමවිටම
printf() අපේක්ෂා
කරන්නේ අක්ෂර (string) නම්
දත්ත වර්ගයයි (මෙය
සී හි සම්මත දත්ත වර්ගයක් නොවන
අතර ඒ ගැන අප තවම සලකා බලා නැති
බවද සිහි තබා ගන්න; එහෙත්
නමින්ම කියවෙන පරිදි මෙම දත්ත
වර්ගය අකුරු හා ඉලක්කම් නියෝජනය
කරන බව තේරුම් ගන්න).
එනිසා පහත
ආකාරයෙන් printf() ෆන්ක්ෂන්
එකක් ලිවිය නොහැකියි.
#include
<stdio.h>
int
main()
{
int myvar = 20;
printf(myvar);
return 0;
}
ඔබ
ඉහත ප්රෝග්රෑම් එක කම්පයිල්
කරන විට එරර් මතු වේවි (එනම්,
කම්පයිල්
නොවේවි). ඊට
හේතුව printf() තුල
අපේක්ෂා කරන්නේ ස්ට්රිං
දත්ත වර්ගය වුවත් ඔබ ඊට ලබා
දී තිබෙන්නේ char දත්ත
වර්ගයයි. එසේනම්,
කොහොමද ඔබේ
ප්රෝග්රෑම් එක තුල තිබෙන
වේරියබල් එකක ගබඩා වී තිබෙන
දත්තයක් තිරයේ දිස් කරන්නේ?
එය printf()
මඟින්ම සිදු
කිරීමට උපක්රමයක් සලසා දී
ඇත. උදාහරණයක්
ලෙස, ඉහත
කෝඩිං එක පහත ආකාරයට වෙනස්
කළ යුතු වේ.
#include
<stdio.h>
int
main()
{
int myvar = 20;
printf("%d", myvar);
return 0;
}
කුමක්ද
සිදු කළ වෙනස්කම? printf() එකේ
සුපුරුදු ලෙස " “ තුල
යමක් ලියා ඇත. ඊට
අමතරව කොමාවක් යොදා වේරියබල්
එකේ නම ලියා ඇත. මෙහිදී
" “ තුළ
ඔබට කැමති ප්රකාශයක් ලිවිය
හැකියි. එහෙත්
එම ප්රකාශය තුළ යම් තැනකට
ඔබේ වේරියබල් එකක ඇති දත්තයද
ඇතුලු කිරීමට අවශ්ය නම් %d
වැනි කොටසක්
අදාල තැන ලිවිය යුතුය.
ඉන්පසු එම
අදාල වේරියබල් එක තමයි කොමාවෙන්
පසුව ලියන්නෙත්. ඉහත
උදාහරණයේදී " “ තුළ
නිකංම %d යන්න
ලියා ඇත. එහි
තේරුම කොමාවෙන් පසුව ලියා
ඇති myvar යන
ඉන්ටීජර් ඩේටා ටයිප් වේරියබල්
එකේ දත්තය උකහා ගෙන %d
වෙනුටද
දර්ශනය කරන්න කියාය. මේ
ආකාරයට වේරියබල් එකක් නොව
ඕනෑම ගණනක් දර්ශනය කළ හැකියි.
උදාහරණයක්
ලෙස පහත ප්රෝග්රෑම් එක රන්
කර බලන්න.
#include
<stdio.h>
int
main()
{
int vwidth = 20, vheight = 30,
vdepth = 10;
printf("The height is %d, the
width is %d, the depth is %d", vheight, vwidth, vdepth);
return 0;
}
මෙහිදී
vwidth, vheight, vdepth ලෙස
ඉන්ටීජර් ටයිප් වේරියබල් 3ක්
සාදා ඊට යම් යම් අගයන්ද ලබා
දී ඇත. ඉන්පසු
printf() ෆන්ක්ෂන්
එක තුළ එම දත්තයන් 3 දර්ශනය
කරනවා දිගු ප්රකාශනයක් ලෙස.
මෙහිදී
පළමුවෙන්ම හමුවන %d යන්නට
පළමුවෙන්ම ඇති vheight යන්න
ආදේශ වේ. මේ
ආකාරයට පිළිවෙලින් ඇති %d
වලට පිළිවෙලින්
ඒ දක්වා ඇති වේරියබල් ආදේශ
වේ. එහි
ප්රතිපලයක් ලෙස, ඉහත
ප්රකාශය The height is 30, the width is
20, the depth is 10 ලෙස
දර්ශනය වේවි.
ඇත්තටම
%d ට
අමතරව %u, %f, %c ලෙස
තවත් ඒවා 3ක්
තිබෙනවා. මේවා
format specifiers හෝ
conversion specifier ලෙස
හැඳින්වෙනවා. දර්ශනය
කරන දත්ත වර්ගය අනුව යෙදිය
යුතු ස්පෙසිෆයර් එක වෙනස්
වෙනවා. short, int, long යන
ඒවා සඳහා %d යෙදිය
හැකිය. float හා
double සඳහා
%f යෙදිය
හැකියි. unsigned short, unsigned int,
unsigned long සඳහා
%u යෙදිය
හැකි අතර, char සඳහා
%c යෙදිය
හැකියි. පහත
උදාහරණය බලන්න.
#include
<stdio.h>
int
main()
{
int myvar = 20;
char mychar = ‘z’;
float myfloat = 200.13;
printf("The char is %c, the
integer is %d, and the float is %f", mychar, myvar, myfloat);
return 0;
}
scanf() ෆන්ක්ෂන්
එකෙන් කරන්නේ කීබෝඩ් එකෙන්
ඇතුලු කරන දත්ත වේරියබල්වලට
ගබඩා කර ගැනීමයි. පළමුව
අවශ්ය කරන වේරියබල් ටික
ඩික්ලෙයාර් කළ යුතුයි.
ඉන්පසුව
පහත දැක්වෙන පරිදි scanf()
ෆන්ක්ෂන්
එක ලිවිය යුතුයි. එනම්,
පළමුව සුදුසු
ස්පෙසිෆයර් එකක් " “
තුළ ලියා,
කොමාවකට
පසුව & සමග
අදාල වේරියබල් එකේ නම ලිවිය
යුතුය. එවිට,
ඔබට කීබෝඩ්
එකේ දත්තය ඇතුලු කිරීමට
අවස්ථාවක් ලැබෙන අතර,
එසේ ඇතුලු
කරන දත්තය අදාල වේරියබල් එකේ
ගබඩා වේ.
int myInt;
scanf(“%d”,
&myInt);
ඔබට
අවශ්ය නම්, එකවර
දත්තයන් කිහිපයක් ලබා ගෙන
වේරියබල් කිහිපයකට එකවර ඒවා
ගබඩා කරන ලෙසද ඉහත කෝඩිං එක
වෙනස් කළ හැකියි. පහත
උදාහරණය බලන්න. මෙවිට
කීබෝඩ් එකෙන් දත්තයන් ඇතුලු
කරන විට පළමුව පළමු දත්තය ලියා
හිස්තැනක් තියා (එනම්
ස්පේස් කී එක ප්රෙස්කර)
ඊළඟ දත්තය
ලියා ආදී ලෙස හිස් තැන් තිය
තියා අදාල දත්තයන් ටික ඇතුලු
කළ යුතුය. මෙවිට
ඔබ වැඩිපුර දත්තයන් ඇතුලු
කළත් ඉන් ගැටලුවක් වෙන්නේ
නැහැ මොකද ප්රෝග්රෑම් එක
විසින් උකහා ගන්නේ ඊට අවශ්ය
කරන දත්ත ටික පමණයි. ඔබට
ඇතුලු කරන්නට තිබෙන්නේ දත්තයන්
2ක්
නම් (පහත
උදාහරණයේදී මෙන්), එහෙත්
ඔබ දත්තයන් 10ක්
ඇතුලු කළත්, ප්රෝග්රෑම්
එක විසින් ලබා ගන්නේ මුල්ම
දත්තයන් දෙක පමණි (අනෙක්
වැඩිපුර දත්තයන් නිකංම නොසලකා
හැරේ).
#include
<stdio.h>
int
main() {
int
num1, num2;
printf("Enter
two numbers: ");
scanf("%d
\n %d",&num1,&num2);
printf("The
product of two numbers is %d \n", num1*num2);
}
ඊටත්
වඩා දත්තයන් ඇතුලු කිරීමට
හොඳම ක්රමය තමයි, එක්
එක් දත්තය ඇතුලු කර එන්ටර්
කී එක එබීම. එනම්,
පළමු දත්තය
ඇතුලු කර එන්ටර් කරන්න;
දෙවැනි දත්තය
ඇතුලු කර එනටර් කරන්න;
මේ ආදි ලෙස
දිගටම කරන්න. මෙහිදී
ප්රෝග්රෑම් එකට අවශ්ය
දත්ත ගණන ඇතුලු කරන තෙක් ඔබට
දත්ත ඇතුලු කිරීමට අවස්ථාව
ලබා දේ. ඊට
අවශ්ය අවසාන දත්තයද ලැබුණු
පසුව ඉබේම ඔබට දත්ත ඇතුලු
කිරීමට අවස්ථාව අවසාන කරනවා.
මෙහි ඇති
වාසිය එයයි (එනම්,
බොරුවට
ප්රෝග්රෑම් එකට අවශ්ය
ප්රමාණයට වඩා දත්ත ඇතුලු
කිරීමට ඇති අවස්ථාව අහිමි
වීම).