មេរៀនទី៥: រង្វិលជុំ Loop

មេរៀនទី៥: រង្វិលជុំ Control Loop

I. រង្វិលជុំ For ( for……… Statement )

 syntax :

for ([ Expression 1]; [Expression 2]; [Expression 3])

{

Block Statements ;

} ឬ

 for (កន្សោម ១់ កន្សោម 2; កន្សោម 3)

បណ្ដា Statement;
រួមមានបីកន្សោម និងក្នុងតួខ នរបស់ for អាចមាន Statement មួយ ឬក បណ្ដុំ Statements ច្រើន ដែលសរសេរនៅខាង ក្រោយ សញ្ញា បិទរង្វង ្រ ់ កចករបស់ពាក្យគន្ល ះ for. ចំពោះកន្សោម ទាំងបី ខាង លើអាចគμានកន្សោមណាមួយក៏បាន តែត្រូវមានសញ្ញា 9់ប ដើម្បី ខណ្ឌចែកពីកន្សោមមួយទៅកន្សោមមួយទៀតជា ដាច់ ខាត។ ជាធមតា កន្សោម ១ គឺជាកន្សោមភ្ជាប់តំលៃដើម្បីបង្កេ តតំលៃដំបូងអោយអថេរ loop កន្សោម 2 ជាទំនាក់ទំនង logic ឬប្រៀបធៀបដើម្បីកំណត់ តំលៃ លក្ខខណ្ឌសំរាប់បន្ដរង្វិល ជុំ ទៀតឬយ៉ាងណាចំនែកឯកន្សោម 3 គឺជា កន្សោមភ្ជាប់តំលៃ មួយផ្សេងទៀតប្រើដើម្បី បង្កើតការផ្លាស់ប្ដូរតំលៃថ μីអោយ ទៅអថេរ loop. ដំណើរការរបស់ពាក្យគន្លឹះ for
for ធ្វើការ​ តាម បណ្ដាជំហានខាងក្រោមនេះ ³

1. កំណត់តំលៃកន្សោមទី 1
2. កំណត់តំលៃកន្សោមទី 2
3. អាស្រ័យលើលក្ខខណ្ឌពិត
រើសយកមួយក្នុងចំណោមពីរផ្លូវខាងក្រោម ³ ឬមិនពិតរបស់កន្សោមទី 2 នោះម៉ាស៊ីននឹងជ្រើស បើស នជាកន្សោមទី 2 មានតំលៃសូន្យ 9លក្ខខណ្ឌម នពិត ប នោះម៉ាស៊ីន នឹងចាកចេញពីរង្វិលជុំ for ហើយ បន្ដអនុវត្ដបណ្ដា statement នៅខាង ក្រោយតួខ្លួនរបស់ for.
b. បើសិនជាកន្សោមទី 2 មានតំលៃខុសពីសូន្យ (លក្ខខណ្ឌពិត ) នោះម៉ាស៊ីន នឹងអនុវត្ដបណ្ដា statements ក្នុងខ្លួនរបស់ for. នៅពេល ជួបសញ្ញាបញ្ចប់ } ក្រោយបង្អស់របស់ for ឬជួប ពាក្យ គន្លឹះ continueនោះម៉ាស៊ីននឹងរត់ទៅធ្វើការនៅជំហានទី 4 9ចាប់ផ្ដើមជុំថ μីប បន្ដទៀត។

4. គណនាកន្សោមទី 3 រួចហើយត្រលប់ទៅជំហានទី 2 វិញដើម្បី បន្ដរង្វ លជុំថ ។ដើម្បីស្វែងយល់អំព ដំណើរការរបស់ ថៀរ ថែម ទៀតនោះ យើងនឹងធ្វើការពិនិត្យទៅលើកម μវិធីខាងក្រោមនេះ ដែលកមμវិធីនេះនឹងបង្ហាញតំលៃរបស់អថេរ count ចាប់ពីពេល ដែល count =

១ រហូតដល់ពេល count ទទួលបានតំលៃ 10

Ex1:

/*កមμវិធី Prog4_7.C */

#include <stdio.h>

#include <conio.h>

void main( )

{

 }

int count;

clrscr( );

for(count = 1; count <= 10; ++count)

printf(“%d”, count);

 printf(“have finished.”);

getch();

 យើងអាចសំដែងអោយលំនាំនៃដំណើររបស់កម μវិធីខាងលើដោយ F

ជាមួយ Flow Chart ដែលបានបង្ហាញនេះ យើងអាចមើល ឃើញ ដោយងាយថា កមμវិធី Prog4_7.ជ ខាងលើនេះក្រោយពេល ប្រកាសអថេរ ចៀុនត មានប្រភេទ ទិន្នន័យជា int រួច វាក៏បានហៅ អនុគមន៍ clrscr() មកសំអាតអេក្រង់ បន្ទាប់មកទៀតគឺ ចូលដល់ ការប្រើរង្វិលជុំ for. នៅក្នុងរង្វ លជុំ for នោះ ជាដំប ងវាអនុវត្ដការ ភ្ជាប់ត ៃ ំ លអោយ អថេរ count =1 សិន រួចហើយទើបអនុវត្ដ បណ្ដាការងារដូចខាងក្រោម ³

a. ពិនិត្យមើលលក្ខខណ្ឌថាតើ count តូចជាងឬសេ μី 10 ដែរឬទេ?
b. ប្រសិនបើ count  តូចជាងឬសេ μី 10 9បានន័យថាកន្សោម លក្ខខណ្ឌពិត នោះកមμវិធីត្រូវចេញតាមច្រកសញ្ញាព្រួញពិត ដើម្បីអនុវត្ដការបង្ហាញតំលៃ count លើអេក្រង់រួចហើយទើបបន្ដទៅ អនុវត្ដការបង្កើនតំលៃ ១ ថែមអោយទៅអថេរ count ទៀត និងជាចុង ក្រោយនេះត្រូវត្រលប់ទៅចំណុច a. ខាងលើវិញ។ប្រសិន បើ count មិនតូចជាងឬសេ μី 10 ទេ 9បានន័យថាកន្សោមលក្ខខណ្ឌ មិនពិត ប

នោះកមμវិធីត្រូវចេញតាមច្រកសញ្ញាព្រួញមិនពិត ដើម្បីអនុវត្ដការ បង្ហាញ ឃ្លា “We have ​finished.”.

សន្និដ្ឋាន  កន្សោម ១ បានគណនា និងត្រូវបានប្រើនៅក្នុង ជុំដំបូង តែម្ដងគត់។ កន្សោម ២្ប កន្សោម ៣ និងខ្លួនរបស់ for អាចត្រូវបាន ធ្វើការច្រើនជុំ។

កំណត់សំគាល់

1. បើគ μានកន្សោម ២  ទេ ពេលនោះវា នឹងបាន កំណត់ថា “លក្ខខណ្ឌពិតជានិច្ច” ដែលក្នុងករណីនេះ ការចេញផុតពីរង្វ លរបស់ for គឺត្រូវពឹងផ្អែកទៅលើពាក្យគន្ល ះ break, goto ឬ returnដែលបានសរសេរក្នុងតួខ្លួនរបស់ for នោះ។

2. នៅក្នុងសញ្ញារង្វង ក្រចកក្រោយពាក្យគន្លឹះ ដែលកន្សោម នីមួយៗ បានចែកដាច់ព គ ា ្ន ដោយសញ្ញា (;). ក្នុងកន្សោម នីមួយៗអាច មានមួយ ឬច្រើនកន្សោមកូនដែលកន្សោមកូននីមួយៗ ត្រូវបានចែក ដាច់ពីគ្នាដោយសញ្ញា (,)

 ជាបន្ដ ទៀត ជាមួយនឹងការកំណត់តំលៃរបស់កន្សោម កូននីមួយៗ គឺត្រូវបានអនុវត្ដព ឆ្វេងទៅស្ដាំ។ឬម នពិតរបស់កន្សោមស៊េរី កន្សោម កូនដែលមានក្នុងកន្សោម 2 នេះ។

3. នៅក្នុងតួខ្លួនរបស់ពាក្យគន្លឹះ ថៀរ យើងអាចប្រើពាក្យគន្លឹះ for ផ្សេងទៀត បានដែលតាមរបៀបនេះយើងអាចបង្កេ តបណ្ដារង្វ លនៅក្នុងរង្វ លផ្សេងទៀត។ 9ចូរមើល កមμវិធី Prog4_14.C

នៅទំព័រទី 107).
4. ពេលជួបពាក្យគន្លឹះ break ក្នុងតួខ្លួនរបស់ for ណាមួយ នោះម៉ាស៊ីន នឹងចាកចេញពី for ដែលមានផ្ទុកពាក្យគន្លឹះ break នោះភ្លាម។
5. ក្នុងតួខ្លួនរបស់ for ណាមួយ យើងអាចប្រើ goto ដើម្បីលោតចេញ ពីតួ ខ្លួនរបស់ for នោះបាន 9អោយលោតទៅកន្លែងដែលយើង ចង់ បាន ប ឬក៏យើងអាចប្រើ return ក្នុងតួខ្លួន for ដើម្បីចាកចេញពី អនុគមន៍ ណាមួយក៏បានដែរ។
6. ក្នុងខ្លួន for អាចប្រើ continue ដើម្បីត្រលប់ទៅចាប់ផ្ដើមពីខាង ដើម នៃ loop វិញ មានន័យថាពេលជួប continue នោះម៉ាស៊ីននឹង ឈប់ អនុវត្ដបណ្ដា ្សtatements ដែលនៅសល់ក្នុងតួខ្លួនរបស់ for ហើយ ឈានទៅកំណត់តំលៃកន្សោមទី ៣ ក្នុងសញ្ញា រង្វង់ក្រចករបស់ for
ដើម្បីអនុវត្ដជុំថ μីបន្ដទៀត។

 Ex2:

/*—- កមμវិធី Prog4_8.C —–*/

#include <stdio.h>

#include <conio.h>

void main()

{ int count;

 clrscr();

printf(“******************** ”); /* គូសកំពូលរបស់ប្រអប់ ដែលមាន

 សញ្ញា 8 ចំនួន 20 */

for(count = 1; count<= 4; ++count)

* ”); /* គូសជ្រុងសងខាងរបស់

ប្រអប់ ដែលចន្លោះសញ្ញា 8 ទាំងពីមានចំនួន 18 SPACE */

printf(“******************** ”); /* គូសបាតរបស់ប្រអប់ ដែលមាន

សញ្ញា 8 ចំនួន 20 */

getch(); ,8 រងចាំចុច គយេ ណាមួយសិន 8/

}
ក្រោយពេលដំណើរការកម μវិធ រ ច លទ្ធផលលើអេក្រង់ន ងបង្ហាញរូបប្រអប់ដ ចខាងក្រោម ៖ ចូរសរសេរកម μវិធី print មកលើ screen output ដូចរូប ៖

# include <stdio.h >

A B C D…X Y

# include <conio.h >

main ( )

{ char ch;

for ( ch = ‘A’; ch <= ‘Z’; ch ++ ) printf (“%c”,ch);

printf (“ ”);

for (ch = ‘a’; ch <= ‘z’; ch ++) printf (“%c”, ch);

Printf (“”);

for (ch = ‘Z’; ch >= ‘A’; ch –) printf (“%c”, ch);

printf (“”);

for (ch = ‘z’; ch >= ‘a’; ch –) printf (“%c”, ch);

printf (“”);

getch ( ); return (0) ;

}

a b c d…x y

z

សរសេរកមμវិធី

 Ex4: Convert Character : Read

ជាអក្សរតូច ។ពី Keyboard នូវ ស្វីត character ចូរ Convert ទៅជា អក្សរពុម្ព, ហើយ print មកលើ screen output :

# include <stdio.h >
# include <conio.h >
# include <ctype.h >
# define EOL ‘’
main ( )
{
char ch [80];
int sum , count ;
for (count = 0 ; (ch [count ] = getchar ( ) ) != EOL ; ++count )
sum += count;
for ( count = 0 ; count <= sum ; ++count)
putchar (toupper (ch [count] ));

geth ( );

return 0;

}

ផ្ទុកនូវ Note : library < ctype.h> statement

ពីអក្សរតូចទៅអក្សរធំ (‘a’. ‘A’)

មាននាទីសំរាប់ toupper();Convert

 សរសេរកមμវិធី Read ពី Keyboard នូវ ន ចំនួន គណនាផលបូក និង មធ្យមភាគនៃចំនួនខាងលើ

# include <stdio.h>
# include <conio.h >
main ( )
{int n , count;

float x , average, sum = 0 ; clrscr ();

printf (“ Enter n =” ); scanf (“ %d”, &n ) ;

for ( count = 1 ; count <= n ; ++ count )

{

printf (“ x [%d] =”, count ); scanf (“%f”, &x );

sum + =x;

}

average = sum /n ;

printf (“ Average = %f”, average);

getch ( );

return 0; }

 រង្វិល

 នេះគឺជាប្រភេទមួយផ្សេងទៀតរបស់រង្វ លជុំ“តើហេតុអ្វីចាំបាច់ត្រូវ មានរង្វិល មួយនេះទៀត បើយើងបានមានរង្វិល For Loop រួចទៅ ហើយនោះ ?”។ តាមការពិតវាមានភាពខុសប្លែកគ្នាបន្ដ ចរវាងរង្វ ល

រង្វិលទាំងពីរដែលបានសិក្សារួចមកនេះនៅផ្នែកខាងក្រោម ៖ដែលភាព ខុសប្លែក គ្នានោះនឹងត្រូវបានបកស្រាយយើងបានដឹងហើយថា ពេល ចាប់ផ្ដេ មដំបូងរង្វ ល while ត្រូវធ្វេ ការពិន ត្យលក្ខខណ្ឌមុនពេល សកម μភាពការងារត្រូវកើតឡើង ប្រសិនបើលក្ខខណ្ឌពិតនោះ ទើប ការងារត្រូវបាន អនុវត្ដតែផ្ទុយទៅវិញការងារនឹង ពុំត្រូវបាន អនុវត្ដ ឡើយ។ ចូរពិនិត្យមើលកំណាត់កូដកម μវិធី ខាងក្រោមនេះ ៖

int number = 4;

while(number < 4)
{

printf(“= %d”, number);

++number;

}

កំណាត់កម μវិធីនេះយើងឃើញថាគ ានអ្វ ្រ ី តូវបាន បង្ហាញលើអេក្រង់ទេ ពីព្រោះកន្សោម លក្ខខណ្ឌ

number < ៤ បានមិនពិតតាំងតែពីពេលចាប់ផ្ដេ មដំបូង ដូច្នេះបណ្ដុំ Statement

ដែលថិតក្នុងតួខ្លួន while នៅពេលនេះពុំត្រូវបាន អនុវត្ដម្ដង ណាឡើយ។ ករណីដូចខាងលើនេះ ប្រសិនបើយើងប្រើរង្វិល ដៀ-ឹហិលេ វិញ នោះយ៉ាងតិចបំផ តក៏ការងារត្រូវបានអនុវត្ដច ន នមួយដងដែរ។ ចូរពិនិត្យមើលការកែប្រែរបស់ក ណាត់កម μវិធី ខាងលើ ៖

 int number = 4;

do

{

printf(“= %d”, number);

++number;

}while(number < 4);

 ពេលនេះយើងឃើញថាលើអេក្រង់បានបង្ហាញបន្ទាត់ “Number = 4” ដែលនេះ បានបញ្ជាក់អោយឃើញថា រង្វ ល do-while ពិន ត្យ កន្សោមលក្ខខណ្ឌ នុមបរ្ពេ៤ ក្រោយពេលដែល សកមμភាព ការងារ ត្រូវបានកើតឡើងរួច។ ទំរង់ទូទៅរបស់រង្វិល do-while គឺ ៖

do

{

បណ្ដាការងារដែលត្រូវអនុវត្ដ (Statement)

}while(កន្សោមលក្ខខណ្ឌ ?)

 ជាដំបូង មុនពេលពិនិត្យកន្សោមលក្ខខណ្ឌ រង្វិល do-while បាន អនុវត្ដការងារ (Statement ឬ Block

សិន Statement)  រួចហើយទើបពិនិត្យ មើលកន្សោម លក្ខខណ្ឌជា
eRkay

ប្រសិនបើកន្សោមលក្ខខណ្ឌមានតំលៃពិត 9ធំជាងសូន្យ ប នោះ ការងារដែលត្រូវ អនុវត្ដ នឹងត្រូវបានធ្វើឡើងវិញម្ដងទៀត តែបើមិនពិតទេនោះកុំព្យូទ័រនឹងចាកចេញពីរង្វិល តែម្ដង។

ចំណាំ ៖ ការចាកចេញពីរង្វិល do-whileមានតំលៃមិន ពិត 9តូចជាងឬសេ μីសូន្យ ប តែប៉ុណ្ណោះ។គឺនៅពេលណា ដែលកន្សោមលក្ខខណ្ឌ

គំនូសតាងខាងក្រោមនេះដំណើរការរបស់រង្វិល do-while :

នឹងបង្ហាញអោយអ្នកឃើញកាន់តែច្បាស់ថែមទៀតអំពី

 ដើម្បីជាឧទាហរណ៍សំរាប់រង្វិល do-while យើងសូមណែនាំកម μវិធីខាងក្រោមនេះសរសេរកមμវិ

 ធី Ex1: Read

គណនាផលបូកនៃចំនួននោះ

# include <stdio.h>

# include <conio.h >

main ( )

{ clrscr ( ) ;

int a, s = 0 ;

do

 

ពី Keyboard
នូវចំនួនគត់រហូតដល់ជួបលេខ ០ ទើបឈប់ .

{ printf (“Enter a = ”); scanf (“%d”, &a );

s = s + a;

} while (a != 0);

printf (“ the sum = %d , s);

getch ( ); return 0;

}

អនុវត្ដន៏ Statement do { … } រហូតដល់ ( while ) Expression Boolean ( a == 0 ) មានតំលៃ

True (1) គឺ (a = 0 ) .

 សរសេរកមμវីធី Read ពី Keyboard នូវបណ្ដា character, រហូតដល់ជួប character ‘*’ ទើបឈប់។ សរសេរបណ្ដា characters នោះមកលើ screen output :

# include <stdio.h>

# include <conio.h >

main ( )

{char c ;

clrscr ( );

do

{

c = getchar ( ); printf (“ %c”,c);

}

while ( c != ‘*’ ) ; /*do while (( c =getchar ( ) )! =’*’); */

getch ( );

return (0);

}

 បើបានរៀន Pascal នោះ Statement do … while (… ) សមមូលនឹង Statement repeat…until .

 III.រង្វិល While ក៏មានមុខងារដូច for ដែរ គឺវាត្រូវបានគេប្រើសំរាប់ បង្វ លបណ្ដុំ Statement ណាមួយនៅក្នុងកម μវិធី អោយធ្វើការឡើង វិញតាមទំរង់ដដែលៗ ដោយអាស្រ័យទៅតាម តំលៃ TRUE របស់ កន្សោម លក្ខខណ្ឌក្នុងសញ្ញារង្វង់ក្រចករបស់ while ដែលមានទំរង់ដូច ខាងក្រោម ៖

while (កន្សោមលក្ខខណ្ឌពិត ?)
អនុវត្ដបណ្ដា statements; /* តួខ្លួន while */
ពាក្យគន្លឹះ while រួមមានកន្សោមលក្ខខណ្ឌមួយ និងតួខ្លួន while. តួខ្លួន while Statement ទោល ឬអាចជាបណ្ដុំ Statements (Block statement).

 ដំណើរការរបស់ whileឋ
while (អ្នកឃ្លានទេ? )

ញ៉ាំបាយ

ផឹកទឹក

អាចជា

យើងឃើញថា ជាដំបូង while ធ្វើការកំណត់តំលៃរបស់ កន្សោមលក្ខខណ្ឌជាមុន សិនប្រសិនបើកន្សោម លក្ខខណ្ឌពិត នោះ while នឹងអនុញ្ញាតអោយអនុវត្ដបណ្ដា Statement នៅក្នុងតួខ្លួនវា

9ដែលករណីខាងលើនេះអនុវត្ដការងារ  “ញ៉ាំបាយ” ប
តែ បើ មិនពិតទេ នោះវានឹងអោយកុំព្យូទ័រចាកចេញពីតួខ្លួនរបស់វាទៅ អនុវត្ដការងារដែលនៅ ក្រោយបន្ទាប់ពីតួខ នរបស់វា ដែលករណីខាងលើនេះ
គឺបន្ដទៅអនុវត្ដការងារ “ផឹកទឹក” ប។ ប្រសិនបើពេលចាប់ផ្ដេ មដំបូង ី

កន្សោមលក្ខខណ្ឌមានតំលៃមិនពិតទេនោះ whileកុំព្យូទ័ររំលង ទៅ អនុវត្ដ ការងារខាងក្រោយបន្ទាប់តួខ្លួនរបស់វាតែម្ដង ដែលករណី ខាងលើនឹងអោយនេះគឺត្រូវរំលងទៅផឹកទឹក តែម្ដង ប្រសិនបើអ្នកបាន ឆ្លើយថា “មិនឃ្លានទេ” សំរាប់សំណួរ ដំបូងនោះ ប។ដូច្នេះ ពាក្យ គន្លឹះ while ធ្វើការតាមបណ្ដាជំហានដូចរៀបរាប់ខាងក្រោម ៖

១។ កំនត់តំលៃរបស់កន្សោមលក្ខខណ្ឌ 9ដែលសរសេរក្នុងសញ្ញារង្វង់ក្រចក ប

2. អាស្រ័យទៅលើតំលៃពិត ឬមិនពិតរបស់ កន្សោមលក្ខខណ្ឌ
កុំព្យូទ័រនឹងជ្រើស រើសយកផ្លូវដើរមួយក្នុងចំណោមផ្លូវដើរ ២ ខាងក្រោម ៖ប្រសិនបើកន្សោមលក្ខខណ្ឌមានតំលៃតូចជាងឬសេ μីសូន្យ ា។ មិនពិត ប នោះម៉ាស៊ីននឹងចាកចេញពីតួខ នរបស់ while ហើយទៅអនុវត្ដបន្ដជាមួយ សតាតមេនេតដែលស្ថិតនៅខាងក្រោយ បន្ទាប់ តួខ្លួនរបស់ while នោះ។

b. ប្រសិនបើកន្សោមលក្ខខណ្ឌមានតំលៃធំជាងសូន្យ (Bit ) នោះម៉ាស៊ីន នឹងអនុវត្ដបណ្ដា Statements ដែលថិតនៅក្នុងតួខ្លួនរបស់
while រហូតដល់ ពេលជួបសញ្ញា “”” ក្រោយបង្អស របស់តួខ ន while ទើបម៉ាស៊ីនត្រលប់ទៅជំហាន ា វិញ 9ករណីដែលក្នុងតួខ្លួន while មានតែមួយ Statement និងគ μានសញ្ញា ““” និង “”” នោះ កុំព្យូទ័រ នឹង អនុវត្ដ Statement នោះចប់ហើយត្រលប់ទៅ ជំហាន ា តែម្ដង ប។

សន្និដ្ឋាន

 តួខ្លួនរបស់ while អាចត្រូវបានអនុវត្ដតែមួយដង ឬច្រើនដង ឬក៏ពុំត្រូវបានអនុវត្ដទាល់តែសោះប្រសិនបើតំលៃរបស់កន្សោមលក្ខខណ្ឌ ម នពិតតាំងពីពេលចាប់ផ្ដេ មដំបូងភ្លាម។

 កំនត់សំគាល់

ជាមួយ while ក៏ដូចជា ថៀរ ដែរ គឺក្នុងសញ្ញារង្វង់ក្រចកក្រោយ while មិនត្រឹមតែអាចសរសេរបានតែមួយកន្សោមប៉ុណ្ណោះទេ ថែមទាំងអាច សរសេរបានច្រើនកន្សោម ទៀតផងស៊េរីនៃកន្សោម  ដែលកន្សោម នីមួយៗត្រូវបានចែកដាច់ពីគ្នា ហើយពេល នោះតំលៃពិតឬមិនពិត របស់ កន្សោមលក្ខខណ្ឌ while ត្រូវបានកំណត់ទៅលើតំលៃរបស់ កន្សោមខាងក្រោយគេបង្អស់នៃស៊េរីកន្សោមក្នុងសញ្ញា រង្វង់ក្រចក ខាងក្រោយ ពាក្យគន្លឹះwhile នោះ។

2. ក្នុងតួខ្លួនរបស់ while អនុញ្ញាតអោយយើងអាចប្រើរង្វិលជុំ ថៀរ ឬ while ផ្សេងទៀតបាន។

3. ពេលជួb break ក្នុងខ្លួនរបស់ while នោះម៉ាស៊ីននឹងចាកចេញពី while ដែលមានផ្ទុកពាក្យគន្លឹះ break នោះភ្លាម។

4. ក្នុងខ្លួនរបស់ while អាចអោយយើងប្រើ goto ដើម្បីលោតចេញ ពីរង្វិល while (ខ្លួនរបស់ while) ទៅកាន់ Label ណាមួយដែលស្ថិត នៅ ខាងក្រៅ while បាន។ ហើយយើងក៏អាចប្រើពាក្យគន្លឹះ

return ក្នុងខ្លួនរបស់ while ដើម្បីចាកចេញពីអនុគមន៍ ណាមួយ ក៏បានដែរ។

5. ក្នុងខ្លួនរបស់ while
អាចប្រើ continue ដើម្បីត្រលប់ទៅអនុវត្ដការងារជុំថ μី។មានន័យថាពេលជួប continue នេះម៉ាស៊ីននឹងរំលងបណ្ដា Statements ដែលនៅសល់ក្នុង ខ្លួនរបស់ while ហើយត្រលប់ ទៅពិនិត្យកន្សោមលក្ខខណ្ឌឡើងវិញភ្លាម ដើម្បីអនុវត្ដជុំថ μី។

កមμវិធី Prog4_15.C ខាងក្រោម ជាឧទាហរណ៍បង្ហាញ អំពីការ ប្រើរង្វិល while ដើម្បីីគណនាផលបូក count ចំនួនគត់វិជ្ជមានដំបូង ³ 1 + 2 + 3 + . . . + count.

 #include <stdio.h>
#include <conio.h>

void main()

ផលបូកចំនួនគត់វិជ្ជមាន */

/* លេខលំដាប់ចំនួនគត់ */

/* អថេររាប់ចំនួនគត់សំរាប់បូក */

/* លុបអេក្រង់ */

/* បញ្ចូលចំនួនលេខដែលត្រូវបូក */

printf(“Enter the number of integers you want to sum : “);

scanf(“%d”, &count); បូកចំនួនគត់វិជ្ជមានចាប់ពី ១ រហូតដល់ count */

while(i<=count)

{

 }

/*

sum = sum + i;

++i;

 បង្ហាញផលបូករបស់ ចំនួនគត់ធម μជាតិដំបូងលើអេក្រង់ count */

printf(“of the first %d numbers is %ld”, count, sum);

រង់ចាំការបញ្ចូលតំលៃ 1 Character ពី Keyboard */

}