Pages

Download Android APK of Engineer for Myanmar blog

Sunday, November 23, 2014

OOP in C++ : အပိုင္း (၁၂) – Decision by If…Else

  ဒီအပတ္ သင္ခန္းစာမွာေတာ႔ if…else Statement အေၾကာင္းေလးေတြကို ဆက္လက္ ေဆြးေႏြးသြားမွာ ျဖစ္ပါတယ္။
The if...else Statement
    if statement ဟာ အေျခအေနတစ္ခု မွန္ကန္ရင္ ဘာလုပ္မယ္ဆိုတာကို ေရးသားဖို႔အတြက္ အသံုးျပဳရတာ ျဖစ္ပါတယ္။ ဒါေပမယ္႔ မွားသြားခဲ႔ရင္ေတာ႔ ဘာတစ္ခုမွ လုပ္ေပးမွာ မဟုတ္ပါဘူး။ အခ်ိဳ႕အေျခအေနေတြမွာ မွန္ရင္ တစ္ခုခုလုပ္ၿပီး မွားသြားရင္ေတာ႔ တျခားတစ္ခု လုပ္ေဆာင္ဖို႔ လိုအပ္တာတတ္ပါတယ္။ အဲဒီလို အေျခအေနမ်ိဳးအတြက္ေတာ႔ if…else statement ကို အသံုးျပဳရမွာ ျဖစ္ပါတယ္။ ေအာက္မွာျပထားသလိုပါပဲ if statement ေနာက္မွာ statement တစ္ခု ဒါမွမဟုတ္ တြန္႔ကြင္းနဲ႔ခတ္ထားတဲ႔ multiple statements ေတြ ရွိပါတယ္။ အဲဒီေနာက္မွာ else ကို ေရးၿပီး သူ႔ေနာက္ကလဲ statement တစ္ခု ဒါမွမဟုတ္ တြန္႔ကြင္းနဲ႔ခတ္ထားတဲ႔ multiple statements ေတြ ထည္႔ေရးေပးရမွာ ျဖစ္ပါတယ္။ if ေနာက္က test expression မွန္ခဲ႔မယ္ ဆိုရင္ အဲဒီေနာက္က statement(s) ေတြ အလုပ္လုပ္မွာ ျဖစ္ပါတယ္။ မွားခဲ႔ရင္ေတာ႔ else ေနာက္က statement(s) ေတြ အလုပ္လုပ္မွာ ျဖစ္ပါတယ္။
 အထက္က if example ေလးကို if…else နဲ႔ ျပန္ေရးျပထားပါတယ္။
// ifelse.cpp
// demonstrates IF...ELSE statememt
#include <iostream>
using namespace std;
int main()
{
int x;
cout << “\nEnter a number: “;
cin >> x;
if( x > 100 )
cout << “That number is greater than 100\n”;
else
cout << “That number is not greater than 100\n”;
return 0;
}
ဒီဥပမာေလးမွာ user ထည္႔သြင္းေပးလိုက္တဲ႔ x တန္ဖိုးဟာ 100 ထက္ႀကီးခဲ႔ရင္ cout<< “That number is greater than 100\n”; ဆိုတာကို လုပ္ေဆာင္မွာ ျဖစ္ၿပီး မွားခဲ႔ရင္ေတာ႔ cout << “That number is not greater than 100\n”; ဆိုတာကို လုပ္ေဆာင္ေပးမွာပါ။ နမူနာအေနနဲ႔ 300 နဲ႔ 3 တန္ဖိုးႏွစ္ခု ထည္႔သြင္းေပးလိုက္လို႔ ရလာတဲ႔ ရလာဒ္ေတြကို ေအာက္မွာ ေလ႔လာ ၾကည္႔ႏိုင္ပါတယ္။

Enter a number: 300
That number is greater than 100
Enter a number: 3
That number is not greater than 100
if…else အလုပ္လုပ္ပံုကို flow chat နဲ႔ ေအာက္ပါအတိုင္း ေလ႔လာႏိုင္ပါတယ္။

The getche() Library Function
    ေနာက္ထပ္ဥပမာ တစ္ခုအေနနဲ႔ if…else ကို while loop ထဲမွာ ထည္႔သြင္း အသံုးျပဳျပထားပါတယ္။ ေနာက္တစ္ခုက getche() ဆိုတဲ႔ library function အသစ္တစ္ခုကို သံုးျပထားပါတယ္။ အဲဒီ chcount.cpp ပရိုဂရမ္ေလးဟာ user ထည္႔သြင္းေပးလိုက္တဲ႔ စာလံုးေတြနဲ႔ အကၡရာ အေရအတြက္ေတြကို ေရတြက္ေပးမွာပါ။
// chcount.cpp
// counts characters and words typed in
#include <iostream>
using namespace std;
#include <conio.h> //for getche()
int main()
{
int chcount=0; //counts non-space characters
int wdcount=1; //counts spaces between words
char ch = ‘a’; //ensure it isn’t ‘\r’
cout << “Enter a phrase: “;
while( ch != ‘\r’ ) //loop until Enter typed
{
ch = getche(); //read one character
if( ch==’ ‘ ) //if it’s a space
wdcount++; //count a word
else //otherwise,
chcount++; //count a character
} //display results
cout << “\nWords=” << wdcount << endl
<< “Letters=” << (chcount-1) << endl;
return 0;
}
input ထည္႔သြင္းဖို႔အတြက္ cin နဲ႔ >> ကို အသံုးျပဳေလ႔ ရွိပါတယ္။ ဒီနည္းကို သံုးမယ္ဆိုရင္ user က input တစ္ခု ထည္႔သြင္းေပးလိုက္တိုင္း Enter ေခါက္ရမွာျဖစ္ပါတယ္။ ဒါေပမယ္႔ အခုလို ဥပမာ မ်ိဳးမွာ user က Enter မႏွိပ္ရဘဲ အကၡရာတိုင္းကို ဖတ္သြားဖုိ႔ လိုလာပါၿပီ။ ဒါေၾကာင္႔ getche() ဆိုတဲ႔ library function ကို အသံုးျပဳရမွာ ျဖစ္ပါတယ္။ ၄င္းကို အသံုးျပဳဖို႔ conio.h header file ကို ေၾကျငာေပးရမွာ ျဖစ္ပါတယ္။ input argument ထည္႔ေပးဖို႔ မလိုအပ္ဘဲ user ရိုက္ထည္႔လိုက္သမွ် အကၡရာေတြကို ခ်က္ခ်င္း return ျပန္ေပးမွာ ျဖစ္ပါတယ္။ chcount.cpp ထဲမွာေတာ႔ getche() နဲ႔ ဖတ္လို႔ ရလာတဲ႔ တန္ဖိုးေတြကို ch ထဲ ထည္႔ေပးလိုက္မွာျဖစ္ပါတယ္။ ေနာက္တစ္ခုက getche() function ဟာ user ရိုက္ထည္႔လိုက္သမွ် အကၡရာေတြကို ကြန္ပ်ဴတာမ်က္ႏွာျပင္ေပၚကို echo လုပ္ေပးမွာ ျဖစ္ပါတယ္။ (_getch() function ကေတာ႔ echo ျပန္လုပ္ေပးမွာ မဟုတ္ပါဘူး။ echo ျပန္လုပ္ေပးလို႔လဲ function name ရဲ႕ ေနာက္ဆံုး စကားလံုးမွာ e ထည္႔ထားၿပီး getche ျဖစ္ေနတာပါ။ if…else statement ကေတာ႔ စကားလံုး(word) ေရတြက္ဖို႔ သံုးထားတဲ႔ wdcount ကို space ဆိုတဲ႔ character ေတြ႔တာနဲ႔ တစ္တိုးေပးမွာ ျဖစ္ပါတယ္။ အကၡရာ (character) ေတြ ေရတြက္ဖို႔ သံုးတဲ႔ chcount ကေတာ႔ space ကလြဲခို႔ ဘယ္အကၡရာကိုပဲ ရိုက္ရိုက္ တစ္တိုးေပးမွာ ျဖစ္ပါတယ္။ ဆိုလိုတာက space ကလြဲလို႔ က်န္တဲ႔ အကၡရာေတြကို character လို႔ သတ္မွတ္လိုက္တာပါ။ (ဒီလို စစ္ေဆးတဲ႔ နည္းမွာ အားနည္းခ်က္ေတြ ရွိပါတယ္။ ဒါေပမယ္႔ ဒီေနရာမွာေတာ႔ ဒီဥပမာေလးဟာ လံုေလာက္တယ္လို႔ ယူဆပါတယ္) ။ ေအာက္မွာ နမူနာ ထည္႔သြင္းေပးလိုက္တဲ႔ စာေၾကာင္းေလးကို စကားလံုးနဲ႔ အကၡရာေတြ ေရတြက္ပံု ေလ႔လာၾကည္႔ၾကရေအာင္။

For while and do
Words=4
Letters=13
while statement မွာပါတဲ႔ test expression ကေတာ႔ ch ရဲ႕တန္ဖိုးဟာ ‘\r’ ျဖစ္မျဖစ္ စစ္ေဆးပါတယ္။ တကယ္ေတာ႔ အဲဒီ အကၡရာဟာ ကီးဘုတ္က Enter key ကို ကိုယ္စားျပဳထားတာပါ။ တကယ္လို႔ Enter ေခါက္ခဲ႔ရင္ while loop ကေန ထြက္သြားမွာ ျဖစ္ပါတယ္။

Assignment Expressions
       chcount.cpp ကို assignment expressions နဲ႔ precedence ေတြရဲ႕ အေရးပါပံုနဲ႔ ကုဒ္လိုင္းအခ်ိဳ႕ကို ခ်ံဳ႕ပစ္ႏိုင္တာကိုျပသဖို႔ အနည္းငယ္ ျပင္ေရးျပခ်င္ပါတယ္။ အဲဒီလို ျပင္ေရးလိုက္ျခင္းအားျဖင္႔ ကုဒ္ေတြကို ဖတ္ရတာ တစ္မ်ိဳး ျဖစ္ေနႏိုင္ေပမယ္႔ C နဲ႔ C++ မွာေတာ႔ ေရးရိုးေရးစဥ္ ေရးနည္းတစ္ခုပဲ ျဖစ္ပါတယ္။ ျပင္ေရးထားတဲ႔ chcnt2.cpp  ကို ေလ႔လာၾကည္႔ၾကရေအာင္။
// chcnt2.cpp
// counts characters and words typed in
#include <iostream>
using namespace std;
#include <conio.h> // for getche()
int main()
{
int chcount=0;
int wdcount=1; // space between two words
char ch;
while( (ch=getche()) != ‘\r’ ) // loop until Enter typed
{
if( ch==’ ‘ ) // if it’s a space
wdcount++; // count a word
else // otherwise,
chcount++; // count a character
} // display results
cout << “\nWords=” << wdcount << endl
<< “Letters=” << chcount << endl;
return 0;
}
getche() ကေန return ျပန္ေပးလိက္တဲ႔ တန္ဖိုးကို ch ထဲ ထည္႔ေပးတဲ႔ ကုဒ္ကို အျပင္မွာ သပ္သပ္ မေရးသားေတာ႔ဘဲ while loop ရဲ႕ test expression ထဲမွာ တစ္ခါတည္း ထည္႔သြင္း ေရးသားလိုက္ျခင္းပဲ ျဖစ္ပါတယ္။ ေနာက္ထပ္ၿပီး အဲဒီ တန္ဖိုးကို ‘\r’ ဟုတ္မဟုတ္ စစ္ေဆးေပးပါတယ္။
တကယ္ေတာ႔ (ch=getche()) ဆိုတဲ႔ ကုဒ္ တစ္ခုလံုးက ch ထဲမွာ ရွိတဲ႔ တန္ဖိုးကို ကိုယ္စားျပဳေနတာ ျဖစ္တဲ႔အတြက္ တစ္ခါတည္း မွန္မမွန္ စစ္ေဆးလို႔ ရသြားတာပဲ ျဖစ္ပါတယ္။ C++ မွာ x = y = z = 0; ဆိုၿပီး ေရးသားႏိုင္ပါတယ္။ အဲဒီလို ေရးနည္းမွာ ညာဘက္အစြန္ဆံုး assignment က အရင္ စအလုပ္လုပ္္ၿပီး 0 ကို z ထဲ၊ z တန္ဖိုးကို y ထဲ၊ y တန္ဖိုးကို x ထဲထည္႔မွာ ျဖစ္ပါတယ္။ ဒါေၾကာင္႔ တန္ဖိုးေတြအားလံုးက 0 ျဖစ္သြားပါလိမ္႔မယ္။ (ch=getche()) ဆိုတဲ႔ assignment expression ကို လက္သဲကြင္းနဲ႔ ခတ္ထားတာကို သတိထားမိပါလိမ္႔မယ္။ ဘာလို႔လဲဆိုေတာ႔ assignment operator ဟာ relational operator ထက္ precedence နိမ္႔တဲ႔အတြက္ အရင္အလုပ္လုပ္ေစခ်င္တဲ႔အခါ ကြင္းခတ္ေပးလိုက္ရတာပဲ ျဖစ္ပါတယ္။ တကယ္လို႔ လက္သဲကြင္းသာ မပါခဲ႔ဘူးဆိုရင္ while( ch = (getche() != ‘\r’) ) လို လုပ္ေဆာင္သြားမွာ ျဖစ္ၿပီး ကၽြန္ေတာ္တို႔ မေမွ်ာ္လင္႔ထားတဲ႔ အမွားေတြကို ရင္ဆိုင္ရမွာပါ။
အဲဒီ chcnt2.cpp ထဲမွာပါတဲ႔ while statement ဟာ ေနရာအနည္းငယ္ပဲ ယူေပမယ္႔ အသံုးတည္႔ပါတယ္။ တကယ္ေတာ႔ ၄င္းဟာ test expression တစ္ခုသာမကဘဲ keyboard က ရိုက္ထည္႔လိုက္တဲ႔ အကၡရာ တစ္လံုးကို ch ထဲကိုလည္း ထည္႔ေပးႏိုင္ခဲ႔ပါတယ္။ ဒါေပမယ္႔ ဒီလိုကုဒ္မ်ိဳးကို ပထမဆံုး ျမင္ဘူးကာစမွာေတာ႔ အဓိပၸါယ္ေဖာ္ဖို႔ ခက္ခဲႏိုင္ပါတယ္။
ေနာက္အပတ္ေတြမွာေတာ႔ က်န္ရွိေနေသးတဲ႔ Nested if...else Statements အေၾကာင္းကို ဆက္လက္ ေဆြးေႏြးသြားပါမယ္ခင္ဗ်ာ။ ဤအခန္းဆက္ ေဆာင္းပါးမ်ားဟာ IT ေက်ာင္းသားမ်ားအတြက္ အထူးရည္ရြယ္ၿပီး ေရးသားထားတာ ျဖစ္ပါတယ္။ သင္ရိုးကို ေရးသားျခင္း ျဖစ္တဲ႔အတြက္ တိုက္ရိုက္ ဘာသာျပန္ဆိုျခင္းနည္းကို ေနရာေတာ္ေတာ္မ်ားမ်ားမွာ သံုးထားပါတယ္။ သိလိုသည္မ်ားကို aungwh2013@gmail.com ကို ဆက္သြယ္ၿပီး ေမးျမန္းႏိုင္သလို YCC ေက်ာင္းသားမ်ား အတြက္လည္း ေအာက္ေဖာ္ျပပါ လိပ္စာရွိ ေတာ္ဝင္ ကြန္ပ်ဴတာ စင္တာ၌လည္း ေလ႔လာ စံုစမ္းႏိုင္ပါတယ္ခင္ဗ်ာ။
အကိုးအကား
Object-Oriented Programming in C++(4th edition), Robert Lafore, Copyright©2002 by Sams Publishing: ISBN 0-672-32308-7
Dr. ေအာင္ဝင္းထြဋ္ (bluephoenix)
ေတာ္ဝင္ ကြန္ပ်ဴတာ စင္တာ
၁၇၉ စ၊ သုမဂၤလာ၊ ေစ်းေလး အေနာက္ဘက္၊ ျပင္ဦးလြင္ၿမိဳ႕

Monday, November 17, 2014

OOP in C++ : အပိုင္း (၁၁) - do loop

    ဒီအပတ္ သင္ခန္းစာမွာေတာ႔ က်န္ရွိေနေသးတဲ႔ do loop နဲ႔ အတူ decision လုပ္တဲ႔ အေၾကာင္းေလးေတြကို ဆက္လက္ ေဆြးေႏြးသြားမွာ ျဖစ္ပါတယ္။
The do Loop
    While loop ကို နားလည္သြားၿပီဆိုရင္ do loop ကို သေဘာေပါက္ဖို႔ မခက္ေတာ႔ပါဘူး။ while loop မွာတုန္းက test expression မွန္မွန္ စစ္ေဆးျခင္းကို loop ရဲ႕ အစမွာ ျပဳလုပ္တာ ျဖစ္ပါတယ္။ ဒါေၾကာင္႔ အဲဒီအခ်က္ မွားသြားတာနဲ႔ looping တစ္ႀကိမ္မွ မပတ္ေတာ႔ဘဲ loop ကို ေက်ာ္သြားမွာ ျဖစ္ပါတယ္။ တစ္ခါတစ္ေလမွာ test expression ကို မစစ္ေသးဘဲ loop ကို အနည္းဆံုး တစ္ႀကိမ္ေတာ႔ ပတ္ေစခ်င္တဲ႔ အခါမ်ိဳးေတြ ရွိတတ္ပါတယ္။ အဲဒီအေျခအေနမ်ိဳးမွာဆို do loop ကို while loop အစား အသံုးျပဳရေလ႔ ရွိပါတယ္။ ဒါေၾကာင္႔ do loop မွာ test expression ကို loop အဆံုးမွာ ထားထားတာျဖစ္ၿပီး အနည္းဆံုး တစ္ေခါက္ ပတ္ၿပီးမွ test expression ကို စတင္ စစ္ေဆးတာ ျဖစ္ပါတယ္။ ေအာက္မွာ ေဖာ္ျပထားတဲ႔ divdo.cpp ပရိုဂရမ္ေလးမွာေတာ႔ တည္ကိန္းနဲ႔ စားကိန္း ႏွစ္ခုကို user အား ထည္႔သြင္းေစၿပီး စားလာဒ္နဲ႔ အၾကြင္းကို / နဲ႔ % operator ေတြသံုးကာ ရွာေဖြေပးမွာ ျဖစ္ပါတယ္။ do loop အသံုးျပဳထားပံုေလးကို ဂရုစိုက္ၿပီး ေလ႔လာေစခ်င္ပါတယ္။
// divdo.cpp
// demonstrates DO loop
#include <iostream>
using namespace std;
int main()
{
long dividend, divisor;
char ch;
do //start of do loop
{ //do some processing
cout << “Enter dividend: “; cin >> dividend;
cout << “Enter divisor: “; cin >> divisor;
cout << “Quotient is “ << dividend / divisor;
cout << “, remainder is “ << dividend % divisor;
cout << “\nDo another? (y/n): “; //do it again?
cin >> ch;
}
while( ch != ‘n’ ); //loop condition
return 0;
}

ပရိုဂရမ္ရဲ႕ ကုဒ္အမ်ားစုကို do loop ထဲမွာ ေရးသားထည္႔သြင္းထားတာကို သတိထားမိပါလိမ္႔မယ္။ do loop မွာ loop ရဲ႕ အစကို do ဆိုတဲ႔ keyword နဲ႔ သတ္မွတ္ေပးလိုက္တာ ျဖစ္ပါတယ္။ ေနာက္က တြန္႔ကြင္း အဖြင္႔ အပိတ္ၾကားမွာေတာ႔ loop body ကို ေရးသားထားတာ ျဖစ္ၿပီး အဆံုးသတ္မွာ test expression ထည္႔သြင္းထားကာ semicolon နဲ႔ ပိတ္ေပးရမွာ ျဖစ္ပါတယ္။ (semicolon ထည္႔ဖို႔ မၾကာခဏ ေမ႔တတ္တာကို သတိျပဳပါ)။ do loop ရဲ႕ syntax ကို ေအာက္မွာ ျပထားပါတယ္။


divdo.cpp ပရိုဂရမ္ေလးထဲမွာ တြက္ခ်က္မႈေတြ ၿပီးတဲ႔ ေနာက္မွာ user ကို ေနာက္ထပ္ ဆက္တြက္ခ်င္ေသးလားလို႔ ေမးပါတယ္။ တကယ္လို႔ user က ဆက္တြက္ခ်င္ေသးရင္ y ကို ရိုက္ထည္႔ရမွာ ျဖစ္ၿပီး loop ကို အၿပီးထြက္ခ်င္ရင္ေတာ႔ n ကို ရိုက္ထည္႔ရမွာပါ။ တကယ္တမ္းက test expression မွာ ch != ‘n’ လို႔ စစ္ထားတဲ႔ အတြက္ n မထည္႔သမွ် true ျဖစ္ေနၿပီး loop ကို ပတ္ေနမွာပါ။ n ထည္႔လိုက္ေတာ႔မွ false ျဖစ္သြားတဲ႔ အတြက္ loop ထဲက ထြက္သြားမွာ ျဖစ္ပါတယ္။ ေအာက္မွာ နမူနာ စမ္းသပ္ျပထားပါတယ္။
Enter dividend: 11
Enter divisor: 3
Quotient is 3, remainder is 2
Do another? (y/n): y
Enter dividend: 222
Enter divisor: 17
Quotient is 13, remainder is 1
Do another? (y/n): n
 
When to Use Which Loop
    ကၽြန္ေတာ္တို႔အေနျဖင္႔ မည္သည္႔ေနရာတြင္ မည္သည္႔ loop အမ်ိဳးအစားကို အသံုးျပဳသင္႔သည္ ဆိုသည္႔အခ်က္အား အၾကမ္းအားျဖင္႔ ခြဲျခားထားေလ႔လာႏိုင္ပါသည္။ ဥပမာအားျဖင္႔ loop ပတ္ရမည္႔ အႀကိမ္အေရအတြက္ကို ႀကိဳတင္သိေနခဲ႔ပါက for loop ကို အသံုးျပဳသင္႔ပါသည္။ while loop ႏွင္႔ do loop ကိုေတာ႔ အႀကိမ္အေရတြက္ကို ႀကိဳမသိႏိုင္ဘဲ အေျခအေနတစ္ခုခု (variable value တစ္ခုခု) ေပၚ မူတည္၍ loop မွ ထြက္ရသည္႔ အခါမ်ိဳးတြင္ test expression ျဖင္႔ စစ္ေဆးကာ အသံုးျပဳရသည္။ အဆိုပါ အေျခအေနကို စစခ်င္း စစ္ေဆးသင္႔ၿပီး မမွန္ကန္ပါက loop body အား လံုးလံုး ေက်ာ္သြားရန္ လိုအပ္သည္႔ အေျခအေနမ်ိဳးတြင္ while loop အား အသံုးျပဳရသည္။ Menu ေရးသားျခင္းကဲ႔သို႔ေသာ loop body အား အနည္းဆံုး တစ္ႀကိမ္ လုပ္ေဆာင္ၿပီးမွ လိုအပ္သည္႔ အေျခအေနအား စစ္ေဆးရသည္႔ အေျခအေနမ်ိဳးတြင္ do loop ကို အသံုးျပဳသင္႔သည္။ အထက္ပါ အခ်က္မ်ားသည္ အၾကမ္းဖ်င္း သတ္မွတ္ခ်က္မ်ားသာ ျဖစ္ၿပီး ေရးသားရာတြင္ လြယ္ကူျမန္ဆန္ေစရန္ ရည္ရြယ္သည္။ သို႔ရာတြင္ အဆိုပါ loop မ်ားအားလံုးကို အေျခအေန အားလံုးနီးပါးအတြက္ အသံုးျပဳႏိုင္ေပသည္။ ကၽြန္ေတာ္တို႔ အေနျဖင္႔ မိမိတို႔ ေရးသားေသာ ပရိုဂရမ္အား ရွင္းလင္း က်စ္လစ္ေစရန္ ဂရုျပဳ၍ loop မ်ားကို ေရြးခ်ယ္သြားၾကရမည္ ျဖစ္သည္။



Decisions
    loop မ်ားတြင္ ပါဝင္ေသာ decisions မ်ားသည္ loop body အား ဆက္လက္ လုပ္ေဆာင္သင္႔ မသင္႔ကို သတ္မွတ္ စစ္ေဆးျခင္းပင္ ျဖစ္သည္။ လက္ေတြ႔ဘဝတြင္လည္း ဒီေန႔ အျပင္ထြက္သင္႔ မသင္႔၊ အကၤ်ီဘာအေရာင္ ဝယ္မလဲ? အလည္အပတ္သြားသင္႔သလား? အစရွိေသာ ဆံုးျဖတ္စရာ ကိစၥရပ္မ်ား ၾကံဳေတြ႔ေနၾကရသည္သာျဖစ္သည္။ ပရိုဂရမ္အတြင္း၌လည္း ထိုကဲ႔သို႔ေသာ one-time decision မ်ား ျပဳလုပ္ရန္ လိုအပ္ေပသည္။ test expression ၏ တန္ဖိုးေပၚ မူတည္၍ ဆံုးျဖတ္ခ်က္ခ်ကာ ပရိုဂရမ္၏ အျခားေနရာမ်ားသို႔ ကုဒ္မ်ား jump ျပဳလုပ္ရမည္ ျဖစ္သည္။ C++ တြင္ decisions မ်ားကို နည္းလမ္း အမ်ိဳးမ်ိဳးျဖင္႔ ျပဳလုပ္ႏိုင္ေသာ္လည္း အေရးအႀကီးဆံုးမွာ မတူညီေသာ အေျခအေန ႏွစ္ခုထဲမွ တစ္ခုကို ေရြးခ်ယ္ေပးႏိုင္ေသာ if…else statement ပင္ ျဖစ္သည္။ ၄င္း statement ကို else မပါဘဲ if statement အျဖစ္ ရိုးစင္းစြာ အသံုျပဳႏိုင္သည္။ အေၾကာင္းအရာ အမ်ားအျပားမွ တစ္ခုကို ေရြးထုတ္ယူရန္အတြက္မူ switch statement ကို အသံုးျပဳႏိုင္သည္။ အခ်ိဳ႕ထူးျခားသည္႔ အေျခအေနမ်ိဳးတြင္ conditional operator ကို အသံုးျပဳႏိုင္သည္။ ၄င္းတို႔ အေၾကာင္းကို တစ္ဆင္႔ခ်င္း ေလ႔လာၾကရေအာင္။
The if Statement
    ဆံုးျဖတ္ခ်က္မ်ား ျပဳလုပ္ရာတြင္ if statement သည္ အရိုးရွင္းဆံုး ျဖစ္ပါသည္။ ၄င္းကို ifdemo.cpp တြင္ ေအာက္ပါအတိုင္ ေလ႔လာႏိုင္ပါသည္။
// ifdemo.cpp
// demonstrates IF statement
#include <iostream>
using namespace std;
int main()
{
int x;
cout << “Enter a number: “;
cin >> x;
if( x > 100 )
cout << “That number is greater than 100\n”;
return 0;
}
if statement ေရးတဲ႔ အခါမွာ if ဆိုတဲ႔ keyword ရဲ႕ေနာက္မွာ လက္သဲကြင္း အဖြင္႔အပိတ္နဲ႔ test expression ကို ေရးရပါတယ္။ ေအာက္ပါ if statement ရဲ႕ syntax ကို ပံုမွာ ျပထားပါတယ္။ if statement ဟာ while နဲ႔ အေတာ္ေလးတူတာကို သတိထားမိပါလိမ္႔မယ္။ ျခားနားခ်က္ကေတာ႔ if statement က while လို looping မပတ္ဘဲ test expression မွန္ခဲ႔ရင္ တစ္ႀကိမ္တည္း လုပ္ေဆာင္တာ ျဖစ္ပါတယ္။ while loop မွာေတာ႔ test expression မွန္ေနသမွ် ကာလပတ္လံုး loop ကို ပတ္ေနမွာပါ။ ေနာက္ပံုတစ္ခုမွာ if statement ရဲ႕ လုပ္ေဆာင္ပံုကို flow chat နဲ႔ ျပထားပါတယ္။


ifdemo.cpp ပရိုဂရမ္ေလးရဲ႕ ရလာဒ္ေတြကို ေအာက္မွာ ျပသထားပါတယ္။ ၁၀၀ ထက္ႀကီးတဲ႔ ဂဏန္းဆိုရင္ ပရင္႔ထုတ္ေပးေနမွာ ျဖစ္ၿပီး ၁၀၀ နဲ႔ တူသြားတာ သို႔မဟုတ္ ငယ္သြားခဲ႔ရင္ေတာ႔ ဘာမွ ထုတ္ေပးမွာ မဟုတ္ပါဘူး။
Enter a number: 2000
That number is greater than 100

Multiple Statements in the if Body
        Loop မ်ားကို ေလ႔လာစဥ္က single statement ကို တြန္႔ကြင္း မခတ္ဘဲ ေရးလို႔ ရသလို လိုအပ္ပါက ရွင္းလင္း လြယ္ကူေစရန္ တြန္႔ကြင္းအတြင္းေရးသင္႔ေၾကာင္းႏွင္႔ multiple statements မ်ားအတြက္မူ မျဖစ္မေန တြန္႔ကြင္းအတြင္း ေရးသားရမည္ ျဖစ္ေၾကာင္း သိရွိခဲ႔ပါတယ္။ ယခု if statement မွာလဲ ထိုနည္းတူ တြန္႔ကြင္းအား အသံုးျပဳရမည္ ျဖစ္ပါတယ္။ if2.cpp မွ ေအာက္ပါအတိုင္း ေလ႔လာၾကည္႔ႏိုင္ပါတယ္။

// if2.cpp
// demonstrates IF with multiline body
#include <iostream>
using namespace std;
int main()
{
int x;
cout << “Enter a number: “;
cin >> x;
if( x > 100 )
{
cout << “The number “ << x;
cout << “ is greater than 100\n”;
}
return 0;
}

Enter a number: 12345
The number 12345 is greater than 100
Nesting ifs Inside Loops

        Loop ေတြနဲ႔ decision ေတြဟာ တစ္ခုနဲ႔တစ္ခု nested လုပ္ၿပီး ေရးႏိုင္ၾကပါတယ္။ loop ထဲမွာ decision ေတြကို ငံုထားလို႔ ရသလို decision ေတြထဲမွာလည္း loop ေတြ ထည္႔သြင္း ထားႏိုင္ပါတယ္။ ထိုနည္းတူ loop ေတြထဲမွာ loop ေတြထပ္ငံုလို႔ရၿပီး decision ေတြထဲမွာလည္း decision ေတြ ထပ္ငံုလို႔ ရပါတယ္။ အခု သင္ခန္းစာမွာေတာ႔ for loop အတြင္းမွာ if ကို ငံုထားတဲ႔ prime.cp ဆိုတဲ႔ ပရိုဂရမ္ေလးကို ေလ႔လာၾကည္႔ၾကရေအာင္။ ဒီ ပရိုဂရမ္ေလးက prime number ေတြကို ရွာတဲ႔ ပရိုဂရမ္ေလးပါ။ prime number ဆိုတာ သူကိုယ္တိုင္ရယ္ ၁ ရယ္ကလြဲရင္ က်န္တဲ႔ ဂဏန္းနဲ႔ စားလို႔မျပတ္တဲ႔ တနည္း သုဒၶကိန္း ခြဲလို႔ မရတဲ႔ ကိန္းပဲ ျဖစ္ပါတယ္။ ဥပမာ -2, 3, 5, 7, 11, 13, 17 စတာေတြပဲ ျဖစ္ပါတယ္။

// prime.cpp
// demonstrates IF statement with prime numbers
#include <iostream>
using namespace std;
#include <process.h> //for exit()
int main()
{
unsigned long n, j;
cout << “Enter a number: “;
cin >> n; //get number to test
for(j=2; j <= n/2; j++) //divide by every integer from
if(n%j == 0) //2 on up; if remainder is 0,
{ //it’s divisible by j
cout << “It’s not prime; divisible by “ << j << endl;
exit(0); //exit from the program
}
cout << “It’s prime\n”;
return 0;
}

ဒီဥပမာေလးမွာ user ထည္႔ေပးလိုက္တဲ႔ ဂဏန္းကို n ထဲ ထည္႔လိုက္ပါတယ္။ အဲဒီေနာက္ n ကို for loop ကို အသံုးျပဳၿပီး 2 ကေန  အထိ ဂဏန္းေတြနဲ႔ စားပစ္ပါတယ for(j=2; j <= n/2; j++) ္။ စားကိန္းက loop variable j ျဖစ္ပါတယ္။ အဲဒီ တန္ဖိုးထဲက တစ္ခုခုက n ကိုျပတ္ေအာင္ စားႏိုင္ခဲ႔ရင္ (တနည္း အၾကြင္း သုညျဖစ္ခဲ႔ရင္) n က prime မဟုတ္ေတာ႔ပါဘူး။ အဲဒီလို ဆံုးျဖတ္တဲ႔ အပိုင္းကို if နဲ႔ % operator သံုးၿပီး တြက္ခ်က္ ဆံုးျဖတ္ပါတယ္ if(n%j == 0)။ အကယ္၍ ထည္႔ေပးလိုက္တဲ႔ ဂဏန္းက prime number မဟုတ္ခဲ႔ရင္ user ကို ပရင္႔ထုတ္ၿပီး ျပန္အသိေပးမွာ ျဖစ္ပါတယ္။ စမ္းသပ္ျပထားပါတယ္-

Enter a number: 13
It’s prime
Enter a number: 22229
It’s prime
Enter a number: 22231
It’s not prime; divisible by 11

ေလာေလာဆယ္ ဥပမာမွာေတာ႔ for loop ကို တြန္႔ကြင္းနဲ႔ မခတ္ျပထားပါဘူး။ ဒါကလဲ if statement ကို statement တစ္ခုအျဖစ္သာ ယူဆေၾကာင္း ျပသခ်င္လို႔ပါ။ အရင္က ေျပာခဲ႔သလိုပဲ တြန္႔ကြင္းေတြ ထည္႔သြင္းေရးသားျခင္းက ဖတ္ရႈရလြယ္ကူေစပါတယ္။

Library Function exit()
        Prime မဟုတ္မွန္းသိလို႔ program ကေန ခ်က္ျခင္း ထြက္ခ်င္တဲ႔ အခါမွာ exit() ဆိုတဲ႔ library function ကို အသံုးျပဳသင္႔ပါတယ္။ ဘယ္ေနရာကေနပဲ ျဖစ္ျဖစ္ ပရိုဂရမ္ကို ရပ္ပစ္ၿပီး ထြက္သြားမွာ ျဖစ္ပါတယ္။ သူက return value ျပန္မေပးပါဘူး။ ကြင္းထဲမွာ ထည္႔ေပးလိုက္ရတဲ႔ 0 ကေတာ႔ operating system ကို argument အေနနဲ႔ ပို႔ေပးလိုက္တာပါ။ သာမာန္အားျဖင္႔ successful termination ဆိုတဲ႔ သေဘာကို ေဆာင္ပါတယ္။ အျခားဂဏန္းေတြကေတာ႔ error ရွိေၾကာင္း ေျပာခ်င္တဲ႔ အခါ အသံုးျပဳရပါတယ္။
    ေနာက္အပတ္ေတြမွာေတာ႔ က်န္ရွိေနေသးတဲ႔ if-else အေၾကာင္းကို ဆက္လက္ ေဆြးေႏြးသြားပါမယ္ခင္ဗ်ာ။ ဤအခန္းဆက္ ေဆာင္းပါးမ်ားဟာ IT ေက်ာင္းသားမ်ားအတြက္ အထူးရည္ရြယ္ၿပီး ေရးသားထားတာ ျဖစ္ပါတယ္။ သင္ရိုးကို ေရးသားျခင္း ျဖစ္တဲ႔အတြက္ တိုက္ရိုက္ ဘာသာျပန္ဆိုျခင္းနည္းကို ေနရာေတာ္ေတာ္မ်ားမ်ားမွာ သံုးထားပါတယ္။ သိလိုသည္မ်ားကို aungwh2013@gmail.com ကို ဆက္သြယ္ၿပီး ေမးျမန္းႏိုင္သလို YCC ေက်ာင္းသားမ်ား အတြက္လည္း ေအာက္ေဖာ္ျပပါ လိပ္စာရွိ ေတာ္ဝင္ ကြန္ပ်ဴတာ စင္တာ၌လည္း ေလ႔လာ စံုစမ္းႏိုင္ပါတယ္ခင္ဗ်ာ။

အကိုးအကား
Object-Oriented Programming in C++(4th edition), Robert Lafore, Copyright©2002 by Sams Publishing: ISBN 0-672-32308-7

Dr. ေအာင္ဝင္းထြဋ္ (bluephoenix)
ေတာ္ဝင္ ကြန္ပ်ဴတာ စင္တာ
၁၇၉ စ၊ သုမဂၤလာ၊ ေစ်းေလး အေနာက္ဘက္၊ ျပင္ဦးလြင္ၿမိဳ႕

OOP in C++ : အပိုင္း (၁၀) - while loop

The while Loop
အရင္အပတ္တုန္းက တိက်တဲ႔ အႀကိမ္အေရအတြက္ အတိုင္း looping ပတ္ဖို႔အတြက္ for loop ကို အသံုးနည္းမ်ားကို ေလ႔လာခဲ႔ၿပီးပါၿပီ။ ဒါေပမယ္႔ တကယ္လို႔ ကၽြန္ေတာ္တို႔ ပတ္မယ္႔ loop အေရအတြက္ကို ႀကိဳမသိႏိုင္ခဲ႔ဘူးဆိုရင္ အျခားနည္းကို သံုးရပါလိမ္႔မယ္။ အဲဒါကေတာ႔ while loop ပဲ ျဖစ္ပါတယ္။ ဥပမာအေနနဲ႔ endon0.cpp ပရိုဂရမ္ကို ေရးျပထားပါတယ္။ အဲဒီ မွာ user ကို ဂဏန္းေတြ တစ္ခုၿပီး တစ္ခု ေတာင္းပါမယ္။ တကယ္လို႔ user က 0 ကို ထည္႔သြင္းလိုက္တဲ႔ အခါမွသာ ပရိုဂရမ္ ၿပီးဆံုးသြားမွာ ျဖစ္ပါတယ္။ ဒီေနရာမွာ ပရိုဂရမ္ အေနနဲ႔ user က 0 မထည္႔သြင္းခင္ ဘယ္ႏွစ္ႀကိမ္ ဂဏန္းေတြ ထည္႔ေပးမယ္ဆိုတာကို ႀကိဳမသိပါဘူး။ user စိတ္ႀကိဳက္ ထည္႔သြင္းႏိုင္ပါလိမ္႔မယ္။
// endon0.cpp
// demonstrates WHILE loop
#include <iostream>
using namespace std;
int main()
{
int n = 99; // make sure n isn’t initialized to 0
while( n != 0 ) // loop until n is 0
cin >> n; // read a number into n
cout << endl;
return 0;
}
ေအာက္မွာေတာ႔ နမူနာအေနနဲ႔ ပရိုဂရမ္ထဲကို ဂဏန္းေတြ ထည္႔သြင္းျပထားပါတယ္။ 0 ကို ထည္႔သြင္းလိုက္တဲ႔ အခါမွာေတာ႔ loop ကေနထြက္ၿပီး ပရိုဂရမ္ ၿပီးဆံုးသြားမွာ ျဖစ္ပါတယ္။
1
27
33
144
9
0
while loop ဟာ for loop ကို ပိုမိုရိုးရွင္းေအာင္ ျပဳလုပ္ထားတာနဲ႔ တူေနပါတယ္။ သူ႔မွာ test expression သာပါရွိၿပီး initialization နဲ႔ increment expression ေတြ မပါဝင္ပါဘူး။ ေအာက္က ပံုေလးမွာ while loop ရဲ႕ syntax ကို ျပထားပါတယ္။



while loop မွာ test expression မွန္ေနသမွ် ကာလပတ္လံုး loop ကို ပတ္ေနမွာ ျဖစ္ပါတယ္။ endon0.cpp မွာပါရွိတဲ႔ n!=0 (n note equal to 0) ဆိုတဲ႔ test expression ေၾကာင္႔ n တန္ဖိုး 0 မျဖစ္မခ်င္း test result မွန္ကန္ေနၿပီး loop ကို ပတ္ေနမွာ ျဖစ္ပါတယ္။ while loop မွာ initialization expression မပါေပမယ္႔ loop variable (ဒီဥပမာမွာေတာ႔ n) ကို loop မစခင္မွာ initialize လုပ္ေပးထားဖို႔ လိုအပ္မွာ ျဖစ္ပါတယ္။ ေနာက္တစ္ခုက loop body ထဲမွာ အဲဒီ loop variable ကို ေျပာင္းလဲေပးတဲ႔ statement ပါဖို႔လိုအပ္ပါတယ္။ မပါခဲ႔ရင္ loop က ထြက္ဖို႔ မျဖစ္ႏိုင္ေတာ႔ပါဘူး။ endon0.cpp မွာေတာ႔ cin<<n; ဆိုတဲ႔ ကုဒ္က n တန္ဖိုးကို ေျပာင္းလဲေစပါတယ္။

Multiple Statements in a while Loop
ေနာက္ထပ္ နမူနာ ပရိုဂရမ္ တစ္ခုကို ေရးျပပါဦးမယ္။ while4.cpp မွာ while loop အတြင္း multiple statements ေတြ ေရးျပထားပါတယ္။ တကယ္ေတာ႔ ဒီလို multiple statements ေတြ ေရးတဲ႔ အေၾကာင္းကို cubelist.cpp မွာတုန္းက foor loop ထဲမွာ ေရးျပခဲ႔ၿပီးပါၿပီ။  ဒီပရိုဂရမ္မွာေတာ႔ ေလးထပ္ကိန္းေတြကို ရွာျပထားပါတယ္။ ေလးထပ္ကိန္းရဲ႕ တန္ဖိုးေတြကို ဂဏန္းေလးလံုး အထိပဲ ရွာဖို႔ ဆံုးျဖတ္ထားတယ္ ဆိုၾကပါစို႔။ ဒါဆိုရင္ အမ်ားဆံုး တန္ဖိုးက 9999 ထက္ မႀကီးရပါဘူး။ အဲဒီလို အေျခအေနမ်ိဳးကို ကန္႔သတ္ဖို႔ အတြက္ဆိုရင္ တြက္မၾကည္႔ရေသးပဲနဲ႔ ဘယ္ဂဏန္းရဲ႕ ေလးထပ္ကိန္းက အဲဒီ limit ကို ေက်ာ္သြားမယ္ဆိုတာကို မသိႏိုင္ပါဘူး။ ဒါေၾကာင္႔ test expression မွာ အဲဒီ အခ်က္ကို စစ္ေဆးခိုင္းၿပီး limit ေက်ာ္သြားတာနဲ႔ loop ကို ရပ္လိုက္မွာ ျဖစ္ပါတယ္။

// while4.cpp
// prints numbers raised to fourth power
#include <iostream>
#include <iomanip> //for setw
using namespace std;
int main()
{
int pow=1; //power initially 1
int numb=1; //numb goes from 1 to ???
while( pow<10000 ) //loop while power <= 4 digits
{
cout << setw(2) << numb; //display number
cout << setw(5) << pow << endl; //display fourth power
++numb; //get ready for next power
pow = numb*numb*numb*numb; //calculate fourth power
}
cout << endl;
return 0;
}

ေလးထပ္ကိန္းကို ရွာဖို႔အတြက္ကေတာ႔ အဲဒီဂဏန္းကို ေလးခါ ေျမွာက္ေပးလိုက္တာပါ။ loop တစ္ခါပတ္တိုင္း numb ဆိုတဲ႔ variable ကို 1 တိုးေပးသြားမွာပါ။ ဒါေပမယ္႔ test expression မွာေတာ႔ numb ကို မစစ္ဘဲ ေလးထပ္ကိန္းတန္ဖိုး pow ကိုပဲ စစ္ေဆးၿပီး loop ကို ဘယ္အခ်ိန္မွာ ထြက္ရမယ္ဆိုတာကို ဆံုးျဖတ္သြားမွာပါ။ ေအာက္မွာ မူရင္းဂဏန္းေတြနဲ႔ သူတို႔ရဲ႕ ေလးထပ္ကိန္းေတြကို တြက္ျပထားပါတယ္။ ေလးထပ္ကိန္းတန္ဖိုး 9999 ထက္ႀကီးသြားတာနဲ႔ ပရိုဂရမ္ၿပီးဆံုးသြားမွာ ျဖစ္ပါတယ္။
1 1
2 16
3 81
4 256
5 625
6 1296
7 2401
8 4096
9 6561
Precedence: Arithmetic and Relational Operators
ေနာက္ပရိုဂရမ္ တစ္ပုဒ္ကေတာ႔ Fibonacci series ကို တြက္ထုတ္ေပးမယ္႔ fibo.ccp ပဲ ျဖစ္ပါတယ္။ Fibonacci series ဆိုတာဟာ ေရွ႕ဂဏန္း ႏွစ္လံုးေပါင္းျခင္းျဖင္႔ ေနာက္ဂဏန္း ကို ရွာယူထားတဲ႔ ဂဏန္းတြဲေတြ ျဖစ္ပါတယ္။ ၄င္းရဲ႕ အစပိုင္း ဂဏန္းတစ္ခ်ိဳ႕ကေတာ႔ 1 1 2 3 5 8 13 21 34 55 တို႔ပဲ ျဖစ္ပါတယ္။ တကယ္ေတာ႔ ဒီ series ကို လက္ေတြ႔ အသံုးခ်မႈေပါင္းမ်ားစြာ ရွိပါတယ္။ ၄င္းဟာ ဗိသုကာပညာနဲ႔ အႏုပညာမွာ သံုးေလ႔ရွိတဲ႔ golden ratio နဲ႔လဲ ဆက္စပ္ေနပါေသးတယ္။ ဒီေနရာမွာေတာ႔ အဲဒီအေၾကာင္းေတြကို အက်ယ္ရွင္းမျပေတာ႔ပါဘူး။
// fibo.cpp
// demonstrates WHILE loops using fibonacci series
#include <iostream>
using namespace std;
int main()
{ //largest unsigned long
const unsigned long limit = 4294967295;
unsigned long next=0; //next-to-last term
unsigned long last=1; //last term
while( next < limit / 2 ) //don’t let results get too big
{
cout << last << “ “; //display last term
long sum = next + last; //add last two terms
next = last; //variables move forward
last = sum; // in the series
}
cout << endl;
return 0;
}
ရလာဒ္ေတြကေတာ႔ ေအာက္ပါအတိုင္းပဲ ျဖစ္ပါတယ္။
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
1597 2584 4181 6765 10946 17711 28657 46368 75025 121393
196418 317811 514229 832040 1346269 2178309 3524578
5702887 9227465 14930352 24157817 39088169 63245986
102334155 165580141 267914296 433494437 701408733 1134903170
1836311903 2971215073
    အဲဒီရလာဒ္ေတြထဲက ေနာက္ဆံုး ဂဏန္းႏွစ္လံုးကို အခ်ိဳးခ်လိုက္မယ္ဆိုရင္ 0.618033988 ကို ရရွိမယ္ျဖစ္ၿပီး ၄င္းဟာ golden ratio ပဲျဖစ္ပါတယ္။ fibo.cpp ပရိုဂရမ္မွာ အႀကီးဆံုး positive integers ေတြ ထည္႔ထားႏိုင္ဖို႔ unsigned long data type ကို အသံုးျပဳထားပါတယ္။
Test expression မွာ အဲဒီ data type ရဲ႕ ကန္႔သတ္ခ်က္ကို ေက်ာ္မသြားတဲ႔ အခ်ိန္အထိ loop ကို ပတ္ေနေအာင္ ေရးသားထားပါတယ္။ limit တန္ဖိုးကိုေတာ႔ const သတ္မွတ္ေပးထားၿပီး မေတာ္တဆ ေျပာင္းလဲေရးသားမိျခင္းကေန ကာကြယ္ထားပါသည္။ loop ကို limit တန္ဖိုးရဲ႕ တစ္ဝက္ေရာက္လာရင္ ထြက္ဖို႔ ေရးသားရပါတယ္။ ဒါမွလဲ sum တန္ဖိုးက limit ကို ေက်ာ္မသြားမွာ ျဖစ္ပါသည္။ test expression မွာ operators ႏွစ္ခု သံုးထားပါတယ္။ (next < limit / 2)။ ကၽြန္ေတာ္တို႔ရဲ႕ ရည္ရြယ္ခ်က္က next ကို limit/2 နဲ႔ ႏိႈင္းယွဥ္ဖို႔ ျဖစ္ပါတယ္။ division ကို comparison မတိုင္မီ လုပ္ေဆာင္ဖို႔ လိုပါတယ္။ အဲဒီအခ်က္ကို ေသခ်ာေစဖို႔ လက္သဲကြင္းထဲ ထည္႔ေရးလို႔ရပါတယ္။ (next < (limit/2) )။ ဒါေပမယ္႔ လက္သဲကြင္းကို ထည္႔ေရးဖို႔ မလိုပါဘူး။ arithmetic operators ေတြဟာ relational operators ေတြထက္ precedence ပိုျမင္႔လို႔ပဲ ျဖစ္ပါတယ္။
ေနာက္အပတ္ေတြမွာေတာ႔ do loop အေၾကာင္းကို ဆက္လက္ ေဆြးေႏြးသြားပါမယ္ခင္ဗ်ာ။        ဤအခန္းဆက္ ေဆာင္းပါးမ်ားဟာ IT ေက်ာင္းသားမ်ားအတြက္ အထူးရည္ရြယ္ၿပီး ေရးသားထားတာ ျဖစ္ပါတယ္။ သိလိုသည္မ်ားကို aungwh2013@gmail.com ကို ဆက္သြယ္ၿပီး ေမးျမန္းႏိုင္သလို YCC ေက်ာင္းသားမ်ား အတြက္လည္း ေအာက္ေဖာ္ျပပါ လိပ္စာရွိ ေတာ္ဝင္ ကြန္ပ်ဴတာ စင္တာ၌လည္း ေလ႔လာ စံုစမ္းႏိုင္ပါတယ္ခင္ဗ်ာ။
အကိုးအကား
Object-Oriented Programming in C++(4th edition), Robert Lafore, Copyright©2002 by Sams Publishing: ISBN 0-672-32308-7
Dr. ေအာင္ဝင္းထြဋ္ (bluephoenix)
ေတာ္ဝင္ ကြန္ပ်ဴတာ စင္တာ
၁၇၉ စ၊ သုမဂၤလာ၊ ေစ်းေလး အေနာက္ဘက္၊ ျပင္ဦးလြင္ၿမိဳ႕

Tuesday, November 11, 2014

OOP in C++ : အပိုင္း (၉) – for loop

Loops ဆိုသည္မွာ ပရိုဂရမ္၏ အစိတ္အပိုင္းအခ်ိဳ႕ကို အႀကိမ္အေရအတြက္ တစ္ခုအထိ အႀကိမ္ႀကိမ္ လုပ္ေဆာင္ျခင္းပင္ ျဖစ္သည္။ ထိုသို႔ ထပ္ခါတလဲလဲ လုပ္ေဆာင္ျခင္းသည္ condition အေျခအေန မွန္ကန္ေနသမွ်ပင္ ျဖစ္သည္။ အဆိုပါ condition မွားယြင္းသြားသည္ႏွင္႔တၿပိဳင္နက္ Loop ၿပီးဆံုးသြားၿပီး Loop ေနာက္က statements မ်ားကို ဆက္လက္ လုပ္ေဆာင္သြားမည္ ျဖစ္သည္။ C++ တြင္ for loop, while loop ႏွင္႔ do loop ဟူ၍ loops သံုးမ်ိဳး ရွိသည္။
The for Loop
    for loop သည္ လူအမ်ားအတြက္ ေလ႔လာရာတြင္ အလြယ္ဆံုး loop ျဖစ္ေလ႔ ရွိသည္။ for loop တြင္ control elements မ်ားသည္ တစ္ေနရာထဲ၌ စုစည္းထားေလ႔ရွိၿပီး အျခား loop မ်ားတြင္မူ control မ်ားသည္ ျပန္႔က်ဲတည္ရွိသျဖင္႔ သေဘာေပါက္ရန္ ခက္ခဲတတ္ျခင္း ျဖစ္သည္။ ၄င္းသည္ ကုဒ္အစိတ္အပိုင္းမ်ားကို တိက်ေသာ အႀကိမ္အေရအတြက္အတြင္း လုပ္ေဆာင္ေလ႔ ရွိသည္။ မ်ားေသာအားျဖင္႔ for loop ကို အႀကိမ္မည္မွ် လုပ္ေဆာင္မည္ဆိုသည္႔ အခ်က္အား ႀကိဳတင္ တြက္ဆထားႏိုင္သည္႔ အေျခအေနမ်ိဳးတြင္ အသံုးျပဳေလ႔ ရွိသည္။ ေအာက္ပါ fordemo.cpp ပရိုဂရမ္တြင္ for loop ကို အသံုးျပဳ၍ 0 မွ 14 အတြင္းရွိ ဂဏန္းမ်ား၏ ႏွစ္ထပ္ကိန္းကို ရွာျပထားသည္။
// fordemo.cpp
// demonstrates simple FOR loop
#include <iostream>
using namespace std;
int main()
{
int j; //define a loop variable
for(j=0; j<15; j++) //loop from 0 to 14,
cout << j * j << “ “; //displaying the square of j
cout << endl;
return 0;
}
ပရိုဂရမ္ကို RUN ၾကည္႔လွ်င္ ေအာက္ပါ အေျဖမ်ားကို ရရွိမည္ ျဖစ္သည္။
0 1 4 9 16 25 36 49 64 81 100 121 144 169 196
ဒီ အေျဖေတြ ဘယ္လိုရလာသလဲ ေလ႔လာၾကည္႔ၾကရေအာင္။ for loop မွာ for ဆိုတဲ႔ keyword ေနာက္က လက္သဲ ကြင္းစ၊ ကြင္းပိတ္ထဲမွာ expression သံုးခုကို semicolons ေတြနဲ႔ ျခားထားပါတယ္ - for(j=0; j<15; j++)။ အဲဒီ expression သံုးခုကေတာ႔ initialization expression, test expression နဲ႔ increment expression တို႔ပဲ ျဖစ္ပါတယ္။
အဆိုပါ expression မ်ားတြင္ (ျခြင္းခ်က္အခ်ိဳ႕မွအပ) loop variable သို႔မဟုတ္ looping counter ဟုေခၚေသာ variable တစ္ခုတည္းကိုသာ အသံုးျပဳေလ႔ ရွိသည္။ fordemo.cpp တြင္ အသံုးျပဳခဲ႔ေသာ loop variable မွာ j ျဖစ္သည္။ ၄င္းကို for loop မစမီ defined ျပဳလုပ္ေပးထားရန္ လိုအပ္သည္။
    Loop ၏ အတြင္းရွိ statements မ်ားသည္ loop ပတ္ေနသမွ် လုပ္ေဆာင္ေနရမည္႔ ကုဒ္မ်ားပင္ ျဖစ္သည္။ fordemo.cpp တြင္မူ cout << j * j << “ “; ကုဒ္တစ္ေၾကာင္းတည္းသာ အသံုးျပဳထားသည္။
     အထက္ပါ statement သည္ j တန္ဖိုး၏ ႏွစ္ထပ္ကိန္းႏွင္႔ ေနာက္တြင္ ေနရာလြတ္ (spaces) ႏွစ္ေနရာ ကို print လုပ္ေပးပါမည္။ ႏွစ္ထပ္ကိန္းရရွိရန္ j ကို j ျဖင္႔ပင္ ေျမွာက္ေပးလိုက္မည္ ျဖစ္သည္။ loop ကို ပတ္ေနသမွ် j တန္ဖိုးသည္ 0,1,2,3, မွ 14 အထိ ေျပာင္းလဲလာမည္ ျဖစ္သည္။ ထို႔ေၾကာင္႔ ႏွစ္ထပ္ကိန္းမ်ားျဖစ္ေသာ 0, 1, 4, 9, မွ 196 အထိ ကို ရရွိမည္ ျဖစ္သည္။ မွတ္သားရမည္႔ အခ်က္တစ္ခုမွာ for statement ၏ အဆံုးတြင္ semicolon မထည္႔ရျခင္းပင္ ျဖစ္သည္။ အဘယ္ေၾကာင္႔ဆိုေသာ္ for statement ႏွင္႔ loop body အားလံုးကို ေပါင္း၍ statement တစ္ေၾကာင္းအျဖစ္ သတ္မွတ္ထားေသာေၾကာင္႔ ျဖစ္သည္။ အကယ္၍ for statement အဆံုးတြင္ semicolon ထည္႔ေပးလိုက္ပါက compiler က loop body မရွိဟု ယူဆသြားမည္ ျဖစ္ၿပီး ေမွ်ာ္လင္႔ မထားသည္႔ ရလာဒ္မ်ား ထြက္ေပၚလာမည္ ျဖစ္သည္။ ၄င္း expressions သံုးခုက loop ကို ဘယ္လို ထိန္းခ်ဳပ္သြားသည္ကို ေလ႔လာၾကရေအာင္။
The Initialization Expression
Initialization expression ကို loop စစခ်င္း တစ္ႀကိမ္သာ လုပ္ေဆာင္ပါသည္။ ၄င္းက loop variable ကို initial value သတ္မွတ္ေပးသည္။ fordemo.cpp တြင္မူ ၄င္းက j ၏ အစ တန္ဖိုးကို 0 သတ္မွတ္ေပးပါသည္။
The Test Expression
Test expression တြင္ relational operator ပါဝင္ေလ႔ ရွိသည္။ Loop ပတ္သည္႔ အႀကိမ္တိုင္း မပတ္ခင္ ၄င္းကို မွန္မမွန္ စစ္ေဆးသည္။ မွန္လွ်င္ loop ပတ္၍ မွားခဲ႔လွ်င္ loop မွ ထြက္သြားမည္ ျဖစ္သည္။
The Increment Expression
Increment expression ကေတာ႔ loop variable ကို loop တစ္ပတ္ ပတ္ၿပီးတိုင္း ေျပာင္းလဲေပးပါတယ္။ မ်ားေသာအားျဖင္႔ increment (တိုးေပး) လုပ္ေပးတာပါ။ ဥပမာ j++ ဆိုရင္ loop တစ္ပတ္ ပတ္ၿပီးတိုင္း j တန္ဖိုးကို 1 တိုးေပးတာပါ။ ေအာက္ကပံုမွာ for loop ရဲ႕ flowchart ကို ျပထားပါတယ္။
How Many Times?
    fordemo.cpp ပရိုဂရမ္ေလးမွာ ပါတဲ႔ for loop ဟာ ၁၅ ႀကိမ္တိတိ အလုပ္လုပ္ပါတယ္။ ပထမဦးဆံုးမ်ာ j တန္ဖိုးက 0 ျဖစ္ပါတယ္။ ဒါကို initialization expression မွာ သတ္မွတ္ေပးပါတယ္။

ေနာက္ဆံုး ျဖစ္ရမယ္႔ j တန္ဖိုးက 14 ပါ။ ဒါကို test expression j<15 က သတ္မွတ္ေပးထားတာပါ။ တကယ္လို႔ j တန္ဖိုး  15 ျဖစ္သြားၿပီး 14 ထက္ ႀကီးသြားမယ္ဆိုရင္ အဲဒီ expression မွားသြားလို႔ for loop ကေန ထြက္သြားမွာ ျဖစ္ပါတယ္။ မ်ားေသာအားျဖင္႔ loop variable ကို 0 ထားပါတယ္။ test expression ကို less-than < operator ကိုသံုးၿပီး ေနာက္က တန္ဖိုးကို ကၽြန္ေတာ္တို႔ ပတ္ခ်င္တဲ႔ အႀကိမ္အေရအတြက္အတိုင္းထားပါတယ္။ (ဒီ ဥပမာမွာက ၁၅ ျဖစ္ပါတယ္)။ တစ္ပတ္ ပတ္ၿပီးတိုင္း  increment လုပ္ပါတယ္။ fordemo.cpp မွာေတာ႔ loop body မွာ အလုပ္လုပ္ဖို႔ ကုဒ္ တစ္ေၾကာင္းသာ ေရးထားပါတယ္။ cout << j * j << “ “;

ေနာက္ထပ္ ဥပမာေလး တစ္ခု ေရးျပပါ႔မယ္။
For(count=0;count<100;count++)
          //loop body
အထက္ပါ ပရိုဂရမ္ေလးဟာ အႀကိမ္ ၁၀၀ အတိအက် လုပ္ပါလိမ္႔မယ္။ count တန္ဖိုး 0 ကေန 99 အထိ for loop ကို ပတ္ေနမွာေၾကာင္႔ပဲ ျဖစ္ပါတယ္။
Multiple Statements in the Loop Body
        ကၽြန္ေတာ္တို႔ အေနနဲ႔ loop body ထဲမွာ statement တစ္ေၾကာင္းမက ေရးဖို႔ လိုအပ္ေလ႔ ရွိပါတယ္။
အဲဒီလို အေျခအေနမ်ိဳးမွာ function ေတြ ေရးသလိုမ်ိဳး တြန္႔ကြင္း{} အဖြင္႔အပိတ္ ၾကားမွာ ေရးေပးရမွာ ျဖစ္ပါတယ္။ ကြင္းထဲက statement တစ္ေၾကာင္းခ်င္းရဲ႕ အဆံုးမွာ semicolon ခံေပးရမွာ ျဖစ္ေပမယ္႔ ကြင္းပိတ္ေနာက္မွာေတာ႔ demicolon ထည္႔မေပးရပါဘူး။ cubelist.cpp ဆိုတဲ႔ ေနာက္ နမူနာေလး ေရးျပထားပါတယ္။ ၄င္းက ကေန ၁၀ၾကား ဂဏန္းေတြရဲ႕ သံုးထပ္ကိန္းေတြကို ေကာ္လံ ႏွစ္ခု နဲ႔ တြက္ထုတ္ေပးမွာ ျဖစ္ပါတယ္။ ေလ႔လာၾကည္႔ၾကရေအာင္..
// cubelist.cpp
// lists cubes from 1 to 10
#include <iostream>
#include <iomanip> //for setw
using namespace std;
int main()
{
int numb; //define loop variable
for(numb=1; numb<=10; numb++) //loop from 1 to 10
{
cout << setw(4) << numb; //display 1st column
int cube = numb*numb*numb; //calculate cube
cout << setw(6) << cube << endl; //display 2nd column
}
return 0;
}
အေျဖေတြကေတာ႔ ေအာက္ပါအတိုင္း ျဖစ္ပါတယ္-
1 1
2 8
3 27
4 64
5 125
6 216
7 343
8 512
9 729
10 1000
ဒီပရိုဂရမ္ေလးမွာ ေနာက္ထပ္ ေျပာင္းလဲမႈ အနည္းငယ္ကို ျဖည္႔စြက္ထားပါတယ္။ အရင္က loop variable ကို 0 နဲ႔ initialized လုပ္ခဲ႔ေပမယ္႔ အခုေတာ႔ 1 နဲ႔ လုပ္ထားပါတယ္။ test expression မွာလဲ 9 မသံုးဘဲ 10 ကိုသံုးထားပါတယ္။ အဲဒီလို သံုးႏိုင္ဖို႔ relational operator ကို < အစား <= (less-than-or-equal-to operator) ကို ေျပာင္းသံုးထားပါတယ္။ ရလာဒ္က loop ကို ဆယ္ပတ္ ပတ္တာပါ။ 0-9 အစား 1-10 ေျပာင္းေပးလိုက္တာပါပဲ။
          ေနာက္တစ္ခုက loop body ေတြမွာ statement တစ္ေၾကာင္းတည္း ရွိေနခဲ႔မယ္ဆိုရင္ တြန္႔ကြင္းမခတ္ဘဲ ေရးေလ႔ ရွိသလို ကြင္းခတ္ၿပီးလည္း ေရးႏိုင္ပါတယ္။ တြန္႔ကြင္းကို မျဖစ္မေန မလိုအပ္ေပမယ္႔ ပရိုဂရမ္မာ အမ်ားစုကေတာ႔ ဖတ္ရတာ ရွင္းလင္းလြယ္ကူေအာင္ loop body ေရးတိုင္း ထည္႔ေပးတတ္ၾကပါတယ္။
Blocks and Variable Visibility
        အဲဒီလို statements ေတြ အမ်ားႀကီးကို တြန္႔ကြင္းနဲ႔ ခတ္ထားတာကို block of code လို႔ ေခၚပါတယ္။ အေရးႀကီးတဲ႔ အခ်က္တစ္ခုက အဲဒီ block ထဲမွာ defined လုပ္ထားတဲ႔ variable ဟာ block အျပင္က မျမင္ႏိုင္( ယူမသံုးႏိုင္ ) တာပဲ ျဖစ္ပါတယ္။ cubelist.cpp မွာ ကၽြန္ေတာ္တို႔ အေနနဲ႔ variable cube ကို block အတြင္းမွာ define လုပ္ထားခဲ႔ပါတယ္။
int cube = numb*numb*numb;
ဒါေၾကာင္႔ သူ႔ကို block အျပင္ကေန access မလုပ္ႏိုင္ပါဘူး။ ဒါေၾကာင္႔ တကယ္လို႔ ကၽြန္ေတာ္တို႔အေနနဲ႔ cube = 10; ဆိုတဲ႔ ကုဒ္ေလးကို block အျပင္ကေန ေရးသားခဲ႔မယ္ဆိုရင္ compiler ကေန error message ေပးမွာျဖစ္ပါတယ္။ ဘာလို႔လဲဆိုေတာ႔ cube ဆိုတဲ႔ variable ဟာ block အျပင္ဘက္မွာ undefined ျဖစ္ေနလို႔ပဲ ျဖစ္ပါတယ္။
အဲဒီလို ကန္႔သတ္ခ်က္ ရွိေနျခင္းရဲ႕ အားသာခ်က္တစ္ခုကေတာ႔ မတူညီတဲ႔ block ေတြ အတြင္းမွာ နာမည္တူၿပီး တကယ္တမ္း မတူညီတဲ႔ variable ေတြ သံုးလို႔ ရတာပဲ ျဖစ္ပါတယ္။ (ဒါေပမယ္႔ စာေရးသူကေတာ႔ အဲဒီလို သံုးတာကို အားမေပးပါဘူး။ မွားသြားရင္ ေသခ်ာေပါက္ ရြာလည္သြားႏိုင္ပါတယ္။ variable ေတြကို နာမည္ သီးသန္႔စီ ေသေသခ်ာခ်ာေပးတာဟာ မျဖစ္မေန လုပ္သင္႔ပါတယ္။)
Indentation and Loop Style
          ကၽြန္ေတာ္တို႔ ပရိုဂရမ္ေရးသားတဲ႔ ေနရာမွာ ျပန္လည္ ဖတ္ရႈရလြယ္ကူၿပီး ရွင္းလင္းတဲ႔ ေရးဟန္ ရွိဖို႔ လိုအပ္ပါတယ္။ loop ေတြကို ေရးသားတဲ႔ ေနရာမွာလဲ ဖတ္ရလြယ္ၿပီး ရွင္းေနေအာင္ ညာဘက္ကို indented လုပ္ေပးဖို႔ လိုအပ္ပါတယ္။ ဆိုလိုတာက tab ခံၿပီး ေရးသားဖို႔ကို ေျပာတာ ျဖစ္ပါတယ္။ ဒီလို ေရးသားျခင္းေၾကာင္႔ loop အစနဲ႔ အဆံုးကို အလြယ္တကူ ျမင္ႏိုင္မွာ ျဖစ္ပါတယ္။ ကြန္ပိုင္လာ ကေတာ႔ indent လုပ္၊ မလုပ္ မသိပါဘူး။ ဒါေပမယ္႔ ကၽြန္ေတာ္တို႔ ပရိုဂရမ္မာေတြ ဖတ္ရ၊ ျပင္ဆင္ရ လြယ္ေအာင္ေတာ႔ လုပ္ေပးသင္႔ပါတယ္။
There is a common variation on the style we use for loops in this book. We show the braces aligned vertically, but some programmers prefer to place the opening brace just after the loop statement, like this:
ကၽြန္ေတာ္တို႔ တြန္႔ကြင္းအစကို ေရးသားတဲ႔ ေနရာမွာ တြန္႔ကြင္းအဆံုးနဲ႔ တစ္တန္းတည္း ေရးသားေလ႔ ရွိပါတယ္။ ဒါေပမယ္႔ အခ်ိဳ႕ပရိုဂရမ္မာေတြကေတာ႔ ေအာက္ပါပံုစံမ်ိဳးနဲ႔ loop statement အဆံုးမွာ တြန္႔ကြင္း အစကို ေရးတတ္ၾကပါတယ္ -
for(numb=1; numb<=10; numb++) {
cout << setw(4) << numb;
int cube = numb*numb*numb;
cout << setw(6) << cube << endl;
}
This saves a line in the listing but makes it more difficult to read, since the opening brace isharder to see and harder to match with the corresponding closing brace. Another style is to indent the body but not the braces:
ဒီလိုေရးသားျခင္းအားျဖင္႔ ကုဒ္တစ္လိုင္း ပိုတိုသြားေစပါတယ္။ ဒါေပမယ္႔ တြန္႔ကြင္းအစကို မ်က္စိရွမ္းသြားတတ္ၿပီး ဖတ္ရ ပိုခက္သြားေစပါတယ္။ ဖတ္ရရွင္းလင္း လြယ္ကူတဲ႔ ေရးနည္းကေတာ႔ တြန္႔ကြင္း အဖြင္႔နဲ႔ အပိတ္ကို တစ္တန္းတည္းထားၿပီး loop body ကိုေတာ႔ indent ျပဳလုပ္ထားတဲ႔ style ပဲျဖစ္ပါတယ္။
for(numb=1; numb<=10; numb++)
{
cout << setw(4) << numb;
int cube = numb*numb*numb;
cout << setw(6) << cube << endl;
}
          ဘယ္ style ပဲသံုးသံုး ဖတ္ေနက်မဟုတ္တဲ႔ သူအတြက္ေတာ႔ အခက္အခဲ အနည္းငယ္ ျဖစ္ႏိုင္ပါတယ္။ ဒါေၾကာင္႔ style တစ္ခုတည္းကိုပဲ စြဲစြဲျမဲျမဲ အသံုးျပဳၾကဖို႔ အၾကံျပဳလုိပါတယ္။

Debugging Animation
Loop operation ေတြ ဘယ္လို လုပ္ေဆာင္တယ္ဆိုတာကို အေသးစိတ္ ေလ႔လာႏိုင္ဖို႔အတြက္ compiler ေတြမွာ ပါေလ႔ရွိတဲ႔ debugging features ေတြကို အသံုးျပဳသင္႔ပါတယ္။ single-stepping ကိုသံုးၿပီး ကုဒ္တစ္ေၾကာင္းခ်င္း ဘယ္လို အလုပ္လုပ္တယ္၊ variable ေတြ ဘယ္လို ေျပာင္းလဲသြားတယ္ ဆိုတာေတြကို ေလ႔လာႏိုင္ပါတယ္။ အဲဒီအေၾကာင္းကို ေနာက္ပိုင္းမွာ အေသးစိတ္ ေရးပါဦးမယ္။
for Loop Variations
The increment expression doesn’t need to increment the loop variable; it can perform any operation it likes. In the next example it decrements the loop variable. This program, FACTOR, asks the user to type in a number, and then calculates the factorial of this number. (The factorial is calculated by multiplying the original number by all the positive integers smaller than itself. Thus the factorial of 5 is 5*4*3*2*1, or 120.)
ကၽြန္ေတာ္တို႔ အေနနဲ႔ increment expression ကို loop variable ေတြကို increment လုပ္ဖို႔သာမက အျခား သင္႔ေတာ္ရာ operation မ်ားကိုလည္း လုပ္ေဆာင္ဖို႔ အသံုးျပဳႏိုင္ပါတယ္။ ေနာက္ ဥပမာ တစ္ခုမွာ ၄င္းကို loop variable တန္ဖိုး decrement လုပ္ဖို႔ အသံုးျပဳထားပါတယ္။ factor.cpp ဆိုတဲ႔ ပရိုဂရမ္ေလးမွာ user ထည္႔ေပးလိုက္တဲ႔ ဂဏန္း တစ္ခုရဲ႕ factorial ကို ရွာျပထားပါတယ္။ (factorial ဆိုတာကေတာ႔ မူလဂဏန္းကို သူ႔ထက္ငယ္တဲ႔ positive integers ေတြ အားလံုးနဲ႔ ေျမွာက္ထားတာပါ။ ဒါေၾကာင္႔ 5 ရဲ႕ factorial ဟာ 5*4*3*2*1 = 210 ျဖစ္ပါတယ္)
// factor.cpp
// calculates factorials, demonstrates FOR loop
#include <iostream>
using namespace std;
int main()
{
unsigned int numb;
unsigned long fact=1; //long for larger numbers
cout << “Enter a number: “;
cin >> numb; //get number
for(int j=numb; j>0; j--) //multiply 1 by
fact *= j; //numb, numb-1, ..., 2, 1
cout << “Factorial is “ << fact << endl;
return 0;
}
ဒီဥပမာေလးမွာ j တန္ဖိုးကို initialization expression သံုးၿပီး user ထည္႔ေပးတဲ႔ တန္ဖိုးကို ေပးလိုက္ပါတယ္။ test expression ကေတာ႔ j တန္ဖိုးထက္ ႀကီးေနသမွ် loop ပတ္ေနေစပါတယ္။ Increment expression ကေတာပ j တန္ဖိုးကို loop တစ္ႀကိမ္ ပတ္ၿပီးတိုင္း တစ္ ေလွ်ာ႔ေပးပါတယ္။ ဒီေနရာမွာ unsigned long ကို factorial တန္ဖိုး ထည္႔သြင္းဖို႔ အသံုးျပဳထားတာ ျဖစ္ပါတယ္။ factorial တန္ဖိုးေတြက ႀကီးမားတတ္လို႔ပဲ ျဖစ္ပါတယ္။ ေအာက္မွာ ျပထားတဲ႔ factorial တန္ဖိုးေတြကို ၾကည္႔ျခင္းအားျဖင္႔ ခန္႔မွန္းႏိုင္ၾကပါတယ္။
Enter a number: 10
Factorial is 3628800
ဒီ ပရိုဂရမ္မွာ ကၽြန္ေတာ္တို႔ အႀကီးဆံုး ရွာႏိုင္တဲ႔ factorial ကေတာ႔ 12 အတြက္ပဲ ျဖစ္ပါတယ္။ အဲဒီထက္ ႀကီးတဲ႔ တန္ဖိုးေတြကို ထည္႔သြင္းခဲ႔မယ္ ဆိုရင္ေတာ႔ error message မျပဘဲ မွားယြင္းတဲ႔ ရလာဒ္ေတြ ထြက္လာမွာပဲ ျဖစ္ပါတယ္။ ဒါေၾကာင္႔ variable ေတြကို define လုပ္တဲ႔ ေနရာမွာ data type မွန္ကန္ေအာင္ သတ္မွတ္ေပးႏိုင္ဖို႔ အေရးႀကီးတာပဲ ျဖစ္ပါတယ္။
Variables Defined in for Statements
ေနာက္နည္းတစ္ခုကေတာ႔ loop variable (ဒီဥပမာမွာ j)ကို loop statement ထဲမွာပဲ define ျပဳလုပ္ေပးျခင္းပဲ ျဖစ္ပါတယ္။
for(int j=numb; j>0; j--)
အသံုးမ်ားသလို ေကာင္းမြန္တဲ႔ loop variable define ျပဳလုပ္နည္းပဲ ျဖစ္ပါတယ္။
အဲဒီလို define ျပဳလုပ္လိုက္တဲ႔ variable ကို loop body ကပဲ ျမင္ႏိုင္ (အသံုးျပဳႏိုင္) ပါတယ္။ (ကြန္ပိုင္လာ ေပၚမူတည္ၿပီး ျခြင္းခ်က္ေတာ႔ ရွိႏိုင္ပါတယ္။ ဒါေပမယ္႔ Standard C++ မွာေတာ႔ မျမင္ႏိုင္ပါဘူး)

Multiple Initialization and Test Expressions
ကၽြန္ေတာ္တို႔ အေနနဲ႔ for statement ေရးသားတဲ႔ ေနရာမွာ initialization ကို expression တစ္ခုထက္ ပိုၿပီး ေရးလို႔ ရပါတယ္။ comma နဲ႔ ျခားေပးရပါတယ္။ အဲဒီလိုပဲ increment expression ကို လဲ ေရးလို႔ရပါတယ္။ ဒါေပမယ္႔ test expression ကိုေတာ႔ တစ္ခုပဲ ေရးသားလို႔ ရပါတယ္။
for( j=0, alpha=100; j<50; j++, beta-- )
{
// body of loop
}
အထက္ပါ ဥပမာမွာေတာ႔ normal loop variable j ကို သံုးထားပါတယ္။ ေနာက္ထပ္ အျခား variable တစ္ခုျဖစ္တဲ႔ alpha ကိုလည္း initialize လုပ္ေပးထားပါတယ္။ incremental expression မွာေတာ႔ j ကို ပံုမွန္ increment လုပ္ေပးထားၿပီး တတိယ variable ျဖစ္တဲ႔ beta ကိုေတာ႔ decrement လုပ္ထားပါတယ္။
တကယ္ေတာ႔ ကၽြန္ေတာ္တို႔ လိုအပ္လာရင္ အဲဒီ expression အခ်ိဳ႕၊ သို႔မဟုတ္ အားလံုးကို မေရးဘဲ ခ်န္လွပ္ထားခဲ႔ႏိုင္ပါတယ္။ ဥပမာ for(;;) ဟာ while loop ကို test expression true ထည္႔ေပးထားတာနဲ႔ တူညီပါတယ္။ ေနာက္ပိုင္းမွာ while loop ေတြ အေၾကာင္းကို ေရးသြားေပးသြားမွာပါ။ အဲဒီလို ေရးနည္းမ်ိဳးကို အတတ္ႏိုင္ဆံုး ေရွာင္ရမွ ျဖစ္ပါတယ္။ ဖတ္ရခက္ခဲ ေစတာေၾကာင္႔ရယ္ ရလာဒ္ အတူတူရေအာင္ အျခားနည္းလမ္းေတြနဲ႔ ပိုမိုရိုးရွင္းစြာ ေရးသားႏိုင္ေသးတာေၾကာင္႔ပဲ ျဖစ္ပါတယ္။
ေနာက္အပတ္ေတြမွာေတာ႔ က်န္ရွိေနေသးတဲ႔ looping ေတြအေၾကာင္းကို ဆက္လက္ ေဆြးေႏြးသြားပါမယ္ခင္ဗ်ာ။ ဤအခန္းဆက္ ေဆာင္းပါးမ်ားဟာ IT ေက်ာင္းသားမ်ားအတြက္ အထူးရည္ရြယ္ၿပီး ေရးသားထားတာ ျဖစ္ပါတယ္။ သိလိုသည္မ်ားကို aungwh2013@gmail.com ကို ဆက္သြယ္ၿပီး ေမးျမန္းႏိုင္သလို YCC ေက်ာင္းသားမ်ား အတြက္လည္း ေအာက္ေဖာ္ျပပါ လိပ္စာရွိ ေတာ္ဝင္ ကြန္ပ်ဴတာ စင္တာ၌လည္း ေလ႔လာ စံုစမ္းႏိုင္ပါတယ္ခင္ဗ်ာ။
အကိုးအကား
Object-Oriented Programming in C++(4th edition), Robert Lafore, Copyright©2002 by Sams Publishing: ISBN 0-672-32308-7
Dr. ေအာင္ဝင္းထြဋ္ (bluephoenix)
http://www.tech4mm.com
ေတာ္ဝင္ ကြန္ပ်ဴတာ စင္တာ
၁၇၉ စ၊ သုမဂၤလာ၊ ေစ်းေလး အေနာက္ဘက္၊ ျပင္ဦးလြင္ၿမိဳ႕


သင္ေသသြားေသာ္ သင္ဖြားေသာေျမ၊သင္တို႔ ေျမသည္၊ အေျခတိုးျမင္႔၊ က်န္ေကာင္းသင္႔၏...(ေဇာ္ဂ်ီ)