មេរៀនទី១: អំពីភាសា C/C++

មេរៀនទី១អំពី​ភាសា C/C++
2
C C++
C
C++ ជា Programming Language ដែលសរសេរ សំរាប់បង្កើត កម្មវិធីដំណើរការលើកុំព្រូទ័រ​ដ៏មានប្រសិទ្ធិភាព​ ដែលអនុញ្ញាតអោយ កុំព្រូទ័រ ធ្វើមួយជាក់លាក់និងត្រឹមត្រូវ ។​

1.  ប្រវត្តិសង្ខេប

-1960​ គេបានបង្កើតភាសាសរសេរកម្មវិធីមួយឈ្មោះ ALGOL​ដែលជា មូលដ្ឋានគ្រឹះនៃរចនាសម្ព័ន្ធរបស់​កម្មវិធី​។-
-1967​ លោក Martin Rechards បានបង្កើតភាសាសរសេរកម្មវិធី CPL បន្ទាប់មកលោក Martin Rechart បានបង្កើតភាសាមួយទៀតឈ្មោះ BCPL ដែលជា Version ថ្មីរបស់ CPL
1970​ លោក​ Ken Tomson ជាបុគ្គលិកម្នាក់នៅមន្ទីរពិសោធន៍ Bell បានរកវិធីវឌ្ឍន៍ពីភាសា BCPL មក​បង្កើតភាសា B ដែលជា Version ថ្មីរបស់ BCPL ដែលមានលក្ខណះច្បាស់លាស់ដើម្បីប្រើប្រាស់ក្នុង System Programming
-1972 មានបុគ្គលិករួមការងារម្នាក់របស់លោក Ken Tomson ឈ្មោះ​ Dennis Ritchie បានយកការងារជាក់​ស្តែងជាច្រើនក្នុងការវិវឌ្ឍន៍ភាសា BCPL ទៅ B មកបង្កើតភាសាមួយ ដែលយើងបានស្គាល់មកដល់​បច្ចុន្បន្ន គឺភាសា C
1983 វិទ្យាស្ថាន ANSI បានបង្កើតគណះកម្មាធិការមួយ ដើម្បីកំណត់ ភាសា C អោយមានលក្ខណះស្តង់ដា រួចកំណត់ឈ្មោះថា ANSI C
C / C++  ជាភាសាសរសេរកម្មវិធីមួយ ដែលមានភាពល្បី ល្បាញ ដូចដែលយើងបានដឹង ក៏ព្រោះតែ​ប្រពន្ធ័ដំណើរការ UNIX គឺបង្កើត ឡើងដោយភាសា Assembly ហើយស្ទើរតែទាំងអស់ ត្រូវបាន សរសេរ​ ឡើងដោយភាសា C / C++ ។​ ក្នុងអំឡុងចុងទសវត្ស 1970 នៅប្រទេសជឿនលឿនមួយចំនួន ភាសា​ C / C++ ត្រូវបានគេ ផ្សព្វ ផ្សាយនិងបញ្ចូោក្នុងកម្មវិធីសិក្សានៅតាមអនុវិទ្យាល័យ វិទ្យាល័យ និង មហាវិទ្យាល័យ ព្រោះវាជាភាសាមួយដែលនៅកៀក UNIX និងមាន C Compiler ដែលអាចអោយយើង Compile កូដដែលយើងបានសរសេរ ។

​​​2.  ការបង្កើតកម្មវិធីនៃភាសា C/C++

      *Editing
               ក្នុងដំណាក់កាលនេះគឺជាការបង្កើត Source Code របស់ C/C++ និងការដាក់ឈ្មោះអោយ Source Code ដែលបានសរសេររួច ។​ ជាទូទៅឈ្មោះរបស់ Source Code ដែលបានដាក់ឈ្មោះអោយ
មានលក្ខណះសំគាល់ ( xxxxxxx.c ) សំរាប់ C និង ( xxxxxx.cpp )​ សំរាប់ C++ ។
​​​​​​​               ក្នុងការសរសេរតំរូវអោយមានកម្មសរសេរកូដដូចជា Turbo C++/C , Code Block , Dev C++ …..
      *Compiling
               ក្នុងដំណាក់កាលនេះ Compiling បំលែង Source Code ទៅជា Machine Code ដែលកុំព្យូទ័រអាច​យល់បាន ព្រមទាំងស្វែងរក រួចបង្ហាញនូវភាព Error (ប្រសិនបើមាន) ។ ប្រសិបបើគ្មានភាព Error កើត​មានទេ នោះវានឹងបង្កើតបាន Object Code ដែលត្រូវផ្ទុកក្នុង File មួយផ្សេងទៀតគឺ Object File ដែលមានសំគាល់ ( xxxxxx.obj )
      *Linking
               ក្នុងដំណាក់កាលនេះ Linker បានផ្សំបញ្ចូលទៅ Object Code ជាមួយនិង​ Module Code ដែល​អានមកពី Program Library (ផ្នែកគាំ ទ្ររបស់ CPL) រួចបង្កើតជា Execut_able File ដែលមានលក្ខណះ​សំគាល់ ( xxxxxx.exe ) ។ ម្យ៉ាងវិញទៀត Linker ក៏អាចស្វែងរក និង បង្ហាញនូវភាព Error ផងដែរ​ ។
      *Execution
               ក្នុងដំណាក់កាលនេះ គឺជាដំណាក់កាលចុងក្រោយ នៃការ ដំណើរការកម្មវិធី ដែលដំណាក់កាលទាំងបីខាងលើ ដំណើរកាល បាន ដោយជោគជ័យ ។ ក៏ប៉ុន្តែក្នុងដំណាក់កាលនេះ ក៏មានភាព Error កើតមាន ផងដែរ ប្រសិនបើមានការខុសពីលក្ខខ័ណ្ឌកំណត់ណាមួយ ដូចជាការអោយតំលៃខុងពីលក្ខខ័ណ្ឌរបស់វា នេះគេហៅថា Logic Error ។

​​​​3.  ទំរង់ទូទៅនៃភាសា C/C++

ឧទាហរណ៍
​​​#include<stdio.h>  ជា Library Function សំរាប់ភាសា C
#include<iostream> ជា Library Function សំរាប់ភាសា C++
using namespace std;

int x = 10;     ជាការប្រកាសអញ្ញាតិប្រភេទ Global Declarations
int y = 15;

int main(){
int a = 50; ជាការប្រកាសអញ្ញាតិប្រភេទ Local Declarations
int b = 80;
printf(“value of x = %d\n”,x);
cout<<“value of x =”<<x<<endl;
……….
     return 0;
}

4.Data Type 
គឺជា Standard Type ដែលត្រូវបានគេប្រើសំរាប់ សំណត់ដែន តំលៃរបស់អថេរ ប្ញ ចំនួនថេរនោះនៅពេល​ដែលយើងប្រកាស់ ដើម្បី ប្រើប្រាស់ ។​ Standard Type សំខាន់ៗនៅក្នុងភាសា C++ មានដូចជា


ប្រភេទ

ការប្រើប្រាស់

ទំហំ

ដែនកំណត់

char

តាងអោយតួអក្សរ1តួអក្សរ

1byte

(signed)-128 to 127
short int

តាងអោយចំនួនគត់

2byte

(signed) -32768 to 32767
(unsigned) 0 to 65535
int

តាងអោយចំនួនគត់

4byte

(signed)-2147483648 to 2147483647
(unsigned)            0       to 4294967295
long int

 តាងអោយចំនួនគត់

4byte

(signed)-2147483648 to 2147483647
(unsigned)           0        to 4294967295
bool

តាងអោយតំលៃពី គឺ
True/False

1byte

true  or  false

float តាងអោយចំនួសទស្សភាគ

4byte

+/-3.4e +/-38(~7 digits)
double តាងអោយចំនួសទស្សភាគ

8byte

+/-1.7e +/-308(~15 digits)
long double តាងអោយចំនួសទស្សភាគ

8byte

+/-1.7e +/-308(~15 digits)
wchar_t តាងអោយតួរអក្សរច្រើនតួ

2 or 4byte

1 wild charater

5.Variable

អថេរគឺជាទំហំដែលអាចប្រែប្រួលតំលៃ ​ អថេររបស់កម្មវិធី​គឺជាឈ្មោះនៃតំបន់​ Memory រក្សារទិន្នន័យ​។​បណ្តាលអថេរត្រូវបានប្រកាស់ដោយរបៀបដាក់ឈ្មោះអថេរនៅផ្នែក​ Variable Declarition ។

​ ​​   ឈ្មោះអថេរ / Identifiers(Variable Name) : អថេរដែលត្រូវបាន ប្រកាស់សំរាប់ប្រើប្រាស់ក្នុងភាសាសរ​សេរកម្មវិធី ។​ យើងអាចកំណត់ ឈ្មោះអោយអថេរ បានតាមសេចក្តីត្រូវការ​ហើយឈ្មោះដែលប្រកាស់​រួចត្រូវបានរក្សាទុកក្នុងMemory ដែលមានទំហំ អាស្រ័យទៅ តាមប្រភេទ ទិន្នន័យរបស់អថេរនោះ។

  Identifiers ឈ្មោះដែលប្រើសំរាប់តាងអោយអញ្ញាតិណាមួយ ហើយការតាងឈ្មោះនេះ​មាន​លក្ខខ័ណ្ឌដូចតទៅ

​​​​​​​​                   -A,B,C….a,b,c…ជាតួអក្សរអង់គ្លេស រឺ underscore ” _ ” នាំមុខជានិច្ច
​​​​​​​​​​​​​​​                   -ហាមដកឃ្លា
-1,2,3,4,…9 អាចមានតួលេខតែមិនអាចនៅខាងមុខគេទេ
​                   -ហាមប្រើឈ្មោះជាន់នឹង Keyword
-ហាមប្រើ Symbol as  & % + – / ^ . \ | ……
-អាចប្រើ underscore ” _ ” ចំនួសការដកឃ្លា
ឧទាហរណ៍          int score_st1;  ត្រឹមត្រូវ
char 1s;​​​​​​​​​​​​​​​​​​​        មិនត្រឹមត្រូវ
float love-ss;​​​  មិនត្រឹមត្រូវ
int ss ee;       មិនត្រឹមត្រូវ      
   Keyword គឺជាពាក្យគន្លឹះដែលគេប្រើប្រាស់ញឹកញាប់ក្នុងការសរសេរកូដ ហើយមានអត្ថន័យ នៃការ​ប្រើប្រាស់ខុសប្លែកពីគ្នា ម្យ៉ាងទៀត Keyword ដែលមាននៅក្នុងភាសា C / C++ សុទ្ធសឹងតែជាអក្សរតូច​ទាំងអស់​ ដូចជា asm , auto , bool ,break , case , catch , char , class , const , const_cast , continue , default , delete , do , double , dynamic_cast , else , enum , explicit , export , extern , false , float , for , friend , goto , reinterpret_cast , return , short , signed , sizeof , static , static_cast , struct , switch , template , this , throw , true , try , typedef , typeid , typename , union , unsigned , using , virtual , void , volatile , wchar_t , while …..

  Declare Variable :    DataType Name_Variable ;
ឧទាហរណ៍
 int score ;              // ការប្រកាសអថេរដោយមិនកំណត់តំលៃតំបូង
int score = 0;           // កំណត់តំលៃតំបូងរបស់អថេរ ជាតួលេខចំនួនគត់ int
char charater;
char charater = ‘A’;     // កំណត់តួអក្សរ១តួតំបូង ដោយប្រើ ”
string name;
string name = “Jack”;    // កំណត់អក្សរតំបូង​ ដោយប្រើ “”
int score1,score2;       // ការប្រកាសអថេរលើសពីរក្នុងពេលតែមួយ
Variable Declaration គឺជាការប្រកាសអអថេរ
ការប្រកាសអថេរមួយត្រូវមាន DataType Identifier ដែលបព្ចាប់ដោយ ; ។
អថេរមាន 2 ប្រភេទធំៗ គឹ Global variable និង Local variable .
Global Variable : 
គឺជាអថេរដែលគេប្រកាសនៅក្រៅ Function សំរាប់អោយ Functions នានាយកទៅប្រើ ។
Local Variable :
គឺជាអថេរដែលគេប្រកាសនៅក្នុង Function សំរាប់អោយបានតែ Function
នោះយកទៅប្រើប៉ុណ្ណោះ ។
Initialization គឺជាការប្រកាសអថេរដោយផ្តល់តំលៃមួយទៅអោយអថេរដោយផ្ទាល់ នៅពេលគេប្រកាស់អថេរនោះ ។
ឧ.int x = 100;

6.Operator

Operator ក្នុងភាសា C / C++ គេបែងជាច្រើនផ្នែកដូចជា​ :

Arithmetic Operators  ពិជណិត

សញ្ញា

អត្តន័យ

ឧទាហរណ៍

+

បូក

c = a + b ;

ដក

d = e – d ;

*

គុណ

a = b * c ;

/

ចែក

a = b / c ;

%

សំណល់នៃការចែក

k = m % n ;

Compound Assignment :

សញ្ញា

ឧទាហរណ៍

អត្តន័យ

+=

 c += b;

c = c + b ;

-=

d -= e;

d = d -e ;

*=

a *= c;

a = a * c ;

/=

a /= c;

a = a / c ;

%=

k %= n;

k = k % n ;

Increase and decrease (++ , –)

 

ឧទាហរណ៍

អត្តន័យ

n++; ដំណើរការនូវតំលៃ n រួចហើយទើបបានបូក 1 បន្ថែមទៅលើតំលៃ n
++n; បូក 1 បន្ថែមទៅលើតំលៃ n ​រួចហើយទើបដំណើរការនូវតំលៃ n
n–; ដំណើរការនូវតំលៃ n រួចហើយទើបបានដក 1 ពីលើតំលៃ n
–n; ដក 1 ពីលើតំលៃ n​រួចហើយទើបដំណើរការនូវតំលៃ n

Relational and Equality Operators (==,!=,>,<,>=,<=)

ប្រើក្នុងលក្ខខ័ណ្ឌពិចារណា conditional

សញ្ញា

អត្ថន័យ

ឧទាហរណ៍

== ស្មើ if(a==5)..
!= មិនស្មើ if(a!=5)..
> ធំជាង if(a>5)..
< តូចជាង if(a<5)..
>= ធំជាងរឺស្មើ if(a>=5)..
<= តូចជាងរឺស្មើ if(a<=5)..

Logical Operators (!,&&,||)

a

b

a&&b

a||b

!a

True True True True False
True False False True False
False True False True True
False False False False True

 


ឧទាហរណ៍

!(5==5) // evaluates to false because the expression at its right (5==5) is true.
!(6<=4) // evaluates to true because (6<=4) is false.
!true // evaluates to false.
!false // evaluates to true.

Conditional Operator (?)

បើ​condition នេះ true នោះវានឹងមានតំលៃ result1 តែបើ false នោះវានឹងមានតំលៃ result2

Example

a = (7==5?4:3); // a = 3 cause 7==5 is false

 

Code

លទ្ធផល

//conditional operator#include <iostream>using namespace std;

int main(){
int a,b,c;
a=2;
b=7;
c=(a>b)?a:b;
cout<<c;
return 0;
}

7

Comma Operator (,)

Example

a = ( b =​ 3 , b+2 );

ការតំណើរការនៃកម្មវិធីគឺកំណត់ b = 3 ហើយក៏ធ្វើការបូកបន្ថែម​2​ទៅលើ b បន្ទាប់មកទៀតបញ្ចូលតំលៃចុងក្រោយទៅក្នុង a លទ្ធផល​គឺ a = 5


7.Comment

Example

int number; // declare variable number as integer
char name; /* declare variable name
as charactor
*/
//………….​​​               ប្រើបានតែ១បន្ទាប់/*…………​​​       ប្រើបានច្រើនបន្ទាប់…………….

………*/


8.Input / Output

For C++

Key word Meaning Example
cin បញ្ចូលទិន្នន័យ cin>>n;
cout បង្ហាញទិន្នន័យ cout<<n;

 

For C

Key word Meaning Example
scanf បញ្ចូលទិន្នន័យ scanf(“%d”,n);
printf បង្ហាញទិន្នន័យ printf(“%d”,n);

 

មេរៀនទី៣: បញ្ចូល និង បញ្ចេញទិន្នន័យ

មេរៀនទី៣: បញ្ចូល និង បញ្ចេញទិន្នន័យ DATA Input & Output

I. អនុគមន៍   printf ( ) and putchar ( ) :

+  printf ( ) : ជា Function សំរាប់  Print ទិន្នន័យដែលនៅក្នុងសញ្ញា “ … ” មកលើ  Screen output ។ ពិនិត្យឧទាហរណ៍ខាងក្រោម ៖

# include < stdio.h >

# include < conio.h >

main ( )

{

int  n; float  x; char ch;

n = 5; x = 8.2; ch = ‘A’ ;
C C++

Note :  + %d ដែល % ជា Format code និង d ជា Conversion code  ។

+        បើចង់   print    Expression        (Variable    )    នោះយើងត្រូវកំណត់ Format អោយតំលៃនៃកន្សោមនោះ ។

តារាង Format Code :

 

Format Code

អត្ថន័យ

%c Print បណ្ដាចំនួនជា characters short, int
%d Print បណ្ដាចំនួន int ,  short
%u Print បណ្ដាចំនួន គμានសឭាា,  unsigned int,
%ld Print បណ្ដាចំនួន long
%X, %x Print បណ្ដាចំនួនគត់ខាងក្រោមរាង hexa
%o Print បណ្ដាចំនួនគត់ខាងក្រោមរាង Octab ( គោល 8)
%f     %lf Print  float,   double
%s Print string

C C++

* បើចង់  print % ត្រូវសរសេរ

printf (“ 50 %%” );  Æ  50%

+ print សំលេង Beep :

printf (“ \a\a Enter Value :”);

+putchar ( c) : ជា Function សំរាប់ print character មួយមកលើ  screen  ។

ch = ‘a’;  putchar (ch); Æ a

+ puts : សំរាប់ Print string មកលើ screen, ហើយ Cursor និងចុះបន្ទាត់,

puts (“this is a character”) ;

II. Print Data into printer :

fprintf (stdprn, “ Print Data on printer!”); និង print ទិន្នន័យទៅក្នុង printer ។ stdprn :សំរាប់បញ្ជាកុំព្យូទ័រអោយ print ទៅ printer ។

III.   scanf( ) function :

ជា Function សំរាប់ Read data from keyboard

Ex1:  int n,p;

scanf (“%d%d”, &n, &p);

Ex2:  char c;

int n;

scanf (“%c%d”,&c,&n);

បើ ៖ Enter a25

Result

c = ‘a’ , n = 25

a^^25 c = ‘a’ , n = 25
តែបើ ៖ Ex3: char c;
int n;scanf (“ %d %c”, &n, &c);
Enter Result
12^a Æ n = 12; c = ‘^’; (មិនមែន = ‘a’ ទេ )

Ex4: char c;

int n;

scanf (“ %d %c”, &n, &c);

Enter Result
12^a Æ n = 12; c = ‘a’;
12^^a Æ n = 12; c = ‘a’;

* Macro     getchar( ); សំរាប់ Read character មួយពី Keyboard ។

Ex:     c = getchar ( );

Ex:    # include <stdio.h>

# include <conio.h>

main ( )

{ clrscr ();

int n,p;

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

while (getchar ( )! = ‘\n’);

printf (“ thank you for your Enter Value %d \n”, n) ;

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

while (getchar ( ) ! = ‘\n’) ;

printf (“thank you for your Enter Value %d \n”, p) ;

getch();  }

Statement : while (getchar ( ) != ‘n\’); មានន័យថា ៖ Read character រហូតដល់  Enter ទើបឈប់

Note :        scanf (“%d”,&n);     Readln (n) ក្នុង Pascal ។

<=>

while (getchar( ) ! = ‘\n’);   (Read តំលៃហើយចុះបន្ទាត់តែម្ដង )

យើងអាចជំនួស while (getchar ( ) ! = ‘\n’); ដោយ gets (ss);

scanf (“%d”, &n);

gets (ss);

ដើម្បី chear stdin យើងប្រើ  Statemenut fflush(stdin);

* Control តើមាន character Read បញ្ចូល ឬអត់ ៖ kbhit ( ):

Function នេះនឹងត្រួតពិនិត្យមើល,មាន Read character ណាពី  Keyboard ឬអត់, ហើយដែល Character កំពុងស្ថិតនៅក្នុង memory   ។   kbhit ( ) សមមូល  និង  keypressed ក្នុង  Pascal   ។ វាផ្ទុកក្នុង  <conio.h>

Ex:

 Note :


# include <conio.h>

# include <stdio.h>

int main (void )

{ clrscr () ;

cprintf (“\r\npress any key to continue :”); while(!kbhit ( ) );    /* No action */ cprintf (“\r\n you have press a key ! \r\n”);

getch ( );

return (0);

}

-cprintf() :ជា  Function <=> printf, ក្នុង cprintf => អត់ស្គាល់  \n ជាសញ្ញាចុះដើមបន្ទាត់ទេ, ត្រូវប្រើ\r\n  ទើបស្គាល់ថា ចុះដើមបន្ទាត់ ។

* getch ( ) Function (សមមូលនឹង Readkey ក្នុង Pascal )

getche ( ) Function ប្រភេទ  Macro Read character នីមួយៗពី  keyboard ។     character

Read ពី keyboard ត្រូវបានសំដែងមកពី screen ។

ចំណែក Function getch ( ) ក៏ជាប្រភេទ  Macro Read character ពី keyboard ដែរ តែ ,Character

ដែល Read ពី keyboard នោះមិនសំដែងមកលើ screen ទេ  ។ ( សមមូល  និង Readkey ក្នុង Pascal )

។ ដូច្នេះយើងអនុវត្ដន៏ Function getch( ) ក្នុងកមμវិធី  Password   ។ ម្យ៉ាងទៀតយើងប្រើ   Functionនេះនៅ  ចុងនៃគ្រប់កមμវិធីទាំង អស់ដើម្បីទប់  screen output ។

+ Function getche( ) និង getch( ) ដូចគ្នាត្រង់ Read មួយ character ពី keyboard ដោយមិនចាំ

Enter, តែខុសគ្នាត្រង់ Function getche (   )និងសំដែង character ដែល  Read ពី keyboard មកលើ screen ។

+   Function getche( ) និង  getche( ) : Read ត្រង់ពី  keyboard   តែម្ដង,  ដោយមិនឆ្លងកាត់ stdin ទេ  ។

ដើម្បី Read password, សូមពិនិត្យ Example ខាងក្រោមដែលមានប្រើ Function get pass( ):

Ex:     Read password :

# include < stdio.h>

# include <conio.h>

int main (void)

{

char    *password; clrscr ();

password = getpass (“Enter password :”);

cprintf (“ password is : %s \r\n”, password);

getch( );

return (0);

}

* gets ( ) Function : ( សមមូល Readln(st) ក្នុង Pascal )

gets ( ) សំរាប់ Read string ពី keyboard រហូតដល់ Enter ទើបឈប់  ។ បន្ទាប់ពី  Read រួចវាថែម

សញ្ញា  បញ្ចប់ បន្ទាត់ (\0) នៅខាងចុង String ។

Ex:

# include < stdio.h>

# include <  conio.h>

main ( )

{  clrscr ():

char  name[80];

printf (“\n Enter your name :”);

gets (name);

printf (“\n your name is %s”, name );

getch ( );

return (0);

}

 

Note  :  Programmer  បើចង់ភ្ជាប់ការងារក្នុងការ  Readnumber  និង   String  គប្បីប្រើប្រាស់

ដំណាក់ ការ ខាងក្រោម  ៖

+ Read ចំនួនគត់ ៖ បន្ទាប់ពី  Enter;

gets (str );

i = atoi (str); /* a to int */

+ Read ចំនួនពិត ៖ បន្ទាប់ពីចុច Enter;

j = atof (str); /* a to float */

Total Function input / output Data ក្នុង language :

+ getchar ( )and putchar( ): (macro) Read និង write character មួយពី keyboard ។

+ gets ( ) and puts ( ): Read និង write string ( គិតទាំងសញ្ញា space ) ។

+ scanf ( ): Read តាម format Code ( %), តាម Conversion code (d)

+ printf ( ): write Data តាម format code, Conversion code ។

+ getche()  និង getch( ): Read character ត្រង់ពី Keyboard ដោយមិនចាំ Enter, មិនឆ្លងកាត់ stdin ។

* gotoxy (int x, int y );

នាំ Cursor ទៅទីតាំង x, y នៃ screen output ។ x = 1 ដល់ 80 , y = 1 ដល់ 25 ។

Ex:     # include < stdio.h>

# include <conio.h>

int main (void)

{

clrsrcr( )

gotoxy (35,12); cprintf (“Hello world !!!”);

getch ( );

return (0);

}

™         clrscr ( ); (clear screen )

ជា Function សំរាប់លុបសំអាត screen output, បន្ទាប់មកវានាំ Cursor ទៅទីតាំង (1, 1) ។

clreol ( ): (Clear end of line )

ជា Function លុបបណ្ដា character ពីចំនុច Current cursor ទៅចុងបន្ទាត់ ។

textcolor (n) និង textbackground (n): ដាក់ពណ៏ text និងពណ៏ Background

តារាង Colors :

Const

Value

BLACK

0

BLUE

1

GREEN

2

CYAN

3

RED

4

MAGENTA

5

BROWN

6

LIGHT GRAY

7

DARKGRAY

8

LIGHT BLUE

9

LIGHT GREEN

10

LIGHT CYAN

11

LIGHT RED

12

LIGHT MAGENTA

13

YELLOW

14

WHITE

15

BLINK

128

Note: ចំពោះ textbackground តំលៃ n គិតពី ( 0Æ 8 ) ។

Function lowvideo ( ) និង normvideo( ) : បញ្ជាពន្លឺ Text, lowvideo( ) ធ្វើអោយពន្លឺរបស់ text ខ្សោយៗទៅ normvideo( ) ធ្វើអោយពន្លឺរបស់ text ធមμតាឡើងវិញ  ។

Ex:     សរសេរពាក្យ WELCOME ( នោះអក្សរ W E មានពន្លឺ ភ្លឺ )

# include < stdio.h>

# include <conio.h>

main( );

{ clrscr () ;

highvideo( ); cprintf (“W”); lowvideo( );  cprintf (“ ELCOM”); highvideo( ); cprintf (“E”);

getch( );

return(0);

}

wherex និង wherey : បញ្ជាក់ប្រាប់ កូអរដោនេរបស់ Current cursor ។

Ex:     # include < stdio.h>

# include <conio.h>

 

int main (void)

{

clrscr ( );

gotoxy (10,10);

printf (“coordinate x :%d y :%d \n”, wherex, wherey);

getch( ); return(0);

}

 window (int x1, int y1, int x2, int y2 );

ជា Function បង្កើត text window ដែលមានកូអរដោនេ មុំកែងខាង លើផ្នែកខាងឆ្វេង ជាចំនុច (x1,y1) និង មុំកែងខាងក្រោមផ្នែកខាងស្ដាំ (x2, y2) ហើយ statement print data on screen និង print data មកលើ Text window ដែលទើបនឹងបង្កើតនេះ ។

Ex:     # include <stdio.h>

# include <conio.h>

int  main(void)

{

window (10, 10, 40, 11); textcolor (YELLOW);

textbackground (BLUE); clrscr ();

cprintf(“This is a test \n”);

getch( );

return(0);

}

លំហាត់អនុវត្ដន៍

 1.   ចូរសរសេរ Screen output នៃ program ខាងក្រោម ៖

# include <stdio.h>

# include <conio.h>

main ( )

{

int        n = 345;

int        p = 5;

float     x = 34.5678 ;

printf (“A :%d %f \n”, n,x ); printf (“B :%4d %10f \n”, n,x ); printf (“C :%2d %3f \n”, n,x );

printf (“D :%10.3f %10.3ef \n”, x,x );

printf (“E :%*d \n”, p,n ); printf (“F :%*.*f \n”, 12,5,x ); getch ( );

return (0);

}

2.   ចូរប្រាប់ពីតំលៃនៃ Variable ប្រភេទ int គឺ n និង p ក្រោយពីអនុវត្ដន៏ Statement ខាងក្រោមៈ

scanf (“%4d %2d”, &n, &p );  ជាមួយទិន្នន័យដែលវាយបញ្ចូលដូចខាងក្រោម ៖

(សញ្ញា ^ ជាសញ្ញាដកឃ្លា )

a)   12^ 45 b)   123456

c)   123456^7 d)   1^458

e)   ^^^4567^^891

3. ចូរសរសេរ screen output នៃកមμវិធីខាងក្រោម ៖

# include <stdio.h>

# include <conio.h>

main ( )

{

char firstname [ ]= “ Chan ” ; char lastname [ ] = “ Dara” ; float money = 5000 ;

clrscr ( ) ; gotoxy(10,10);

printf (“ %s %s, you will get $ %6.2f \n ”, firstname, lastname, money) ;

getch ( ) ;

return (0 ) ;

}

4. ចូរសរសេរ screen output នៃកមμវិធីខាងក្រោម ៖

# include <stdio.h>

# include <conio.h>

main ( )

{ int letter ;

/* print Value of code ASCII of characters */

letter = ‘e’ ;

printf (“Code ASCII of %c is %d \n” , letter , letter );

getch ( );

return (0);

}

5. ហេតុអ្វីគេនិយមប្រើ Function gets ( ) ជាង Function scanf ( )?

6. ចូររកកន្លែងខុសនៃ កមμវិធីខាងក្រោម ៖

main ( )

{

char str [ ] = {‘H’ , ‘e’ , ‘l’ , ‘l’ , ‘o’ };

puts (str);

getch ( );

return (0);

}

មេរៀនទី២: Expression,Statement

មេរៀនទី២: Expression,Statement

I. ប្រភេទទិន្នន័យ
I.1. និយមន័យ ទិន្នន័យ (Data) គឺជាបណ្ដាពត៌មានដែលមានពិតដូច ជា អត្ថបទ តំលៃលេខ  សំលេង និង រូបភាព សំដែងក្រោមទំរង់មួយ ដែលកុំព្យូទ័រ អាចធ្វើការប្រាស្រ័យទាក់ទង ឬអនុវត្ដន៍ ការងារ ណាមួយជាមួយវាបាន។ I.2. ប្រភេទទិន្ន័យ   (Data Type) ក្នុងភាសា  C មានប្រភេទទិន្នន័យមួយចំនួនដូចបាន បង្ហាញ ខាងក្រោមនេះ ៖
C C++

ប្រភេទទិន្នន័យត្រូវបានគេអោយនិយមន័យដោយពីរចំនុចខាងក្រោមគឺ ៖
+       ជាប្រភេទ និងដែនកំណត់នៃតំលៃ  ដែលក្រោយពេល អថេរ មួយ បានប្រកាសជាមួយប្រភេទទិន្នន័យនោះរួច វាអាចទទួលយក តំលៃ នោះ បាន។

+       ក្នុងប្រភេទទិន្នន័យនីមួយៗអាចមានកំណត់ប្រមាណវិធីមួយ ចំនួនជាក់លាក់។

I.3. ប្រភេទចំនួនគត់  ( Integer ) យើងដឹងហើយថា ក្នងុ

គណិតវិទ្យា ចំនួនគត់ធមμជាតិមានតំលៃចាប់ពី –N រហូតដល់ N

និងធាតុទាំងអស់រួមចូលគ្នាបង្កើតបានជាសំនុំចំនួនគត់។  នៅក្នុង កុំព្យូទ័រវាពុំមានលទ្ធភាព សំដែងតំលៃលេខ បានតាំង ពី រហូតដល់ +∞ នោះទេ  គឺវាអាចសំដែងបានតែនៅចន្លោះ កំណត់ណាមួយនៃ (-∞, +∞)ប៉ុណ្ណោះ។      ដូច្នេះចំនួនគត់       (Integer)      នៅក្នុងកុំព្យូទ័រគឺមាន        ការបែងចែកជាប្រភេទចំនួនគត់ ផ្សេងៗពីគ្នា ទៀត អាស្រ័យទៅតាមដែនតំលៃរបស់វាដូច ខាងក្រោម  ៖

 ប្រភេទទិន្នន័យ                             ពាក្យគន្លឹះ                  ចំនួន  ពយតេ                     ដែនតំលៃ

Character                                char                  1              -128 ដល់ 127

Integer                                     int                    2                -32768 ដល់

32767

Short integer                          short                  2                -32768 ដល់

32767

Long integer                           long                  4           -2147483648 ដល់

2147483647

Unsigned character             unsigned char

1                 0 ដល់ 255

Unsigned intger                unsigned int            2               0 ដល់ 65535

Unsigned short intger         unsigned short

 Unsigned long intger          unsigned long


2               0 ដល់ 65535

4                    0 ដល់

4294967295

 

ចំណាំ  ៖ ប្រភេទទិន្នន័យ char ភាពពិតជាប្រភេទអក្សរ ក៏ប៉ុន្ដែក្នុងភាសា C បានអនុញ្ញាតអោយប្រើប្រភេទ

char    នេះជាចំនួនគត់មួយដែលមានតំលៃអាចសំដែងបាន   ដូច ក្នុងតារាងខាងលើ។ នេះគឺជាភាពរស់រវីករបស់ C ដែល នៅ ពេល ធ្វើប្រមាណវិធីនព្វន្ដ នោះប្រភេទទិន្នន័យ char ត្រូវ បានចាត់ ទុក ជាចំនួនគត់     តែដល់ពេលធ្វើប្រមាណវិធីជាមួយ តួអក្សរ នោះវា ចាត់ទុក char ជាប្រភេទតួអក្សរវិញ។

I.3.1. សំដែងចំនួនគត់ដោយលេខគោល  16 និងគោល 8

នៅក្នុងការសរសេកមμវិធីដោយភាសា  C  ក្រៅអំពីការសរសេរលេខ ក្រោមទំរង់ Decimal (លេខគោល 10) វាបានផ្ដល់លទ្ធភាពអោយ យើងអាចសរសេរលេខក្រោមទំរង់ គោល  16 (hexa) ថែមទៀត។ ប្រព័ន្ធលេខគោល 16 រួមមាន  16 តួលេខគឺ  ៖ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F ដែលក្នុងនោះ A, B, C, D, E, F តំណាងអោយ 10, 11, 12, 13, 14, 15។

ក្នុងភាសា  C ដើម្បីសរសេរលេខក្រោមទំរង់ Hexa នោះត្រូវសរសេរ តាមលំនាំ ខាងក្រោម  ៖

Ox41មានន័យថា 41 hexa ដែលសើμនឹង 65 decimal
OxFមានន័យថា F hexa ដែលសើμនឹង 15 decimalក្រៅពីការ សរសេរលេខក្រោមទំរង់ជាប្រព័ន្ធ   Hexa         នោះក្នុង ភាសា    C   នៅ អនុញ្ញាតអោយយើងអាចប្រើប្រាស់ លេខក្រោមទំរង់   Octal   បានថែមទៀតផង។   ប្រព័ន្ធលេខ    Octal

(ប្រព័ន្ធលេខគោល   8)   រួមមាន    8   តួលេខសំរាប់ប្រើគឺ   0,   1,   2,   3,   4,   5,   6,   7។ ដើម្បីសំដែងលេខណាមួយក្រោមទំរង់  Octal  នោះក្នុងភាសា  C  ត្រូវសរសេរចាប់ផ្ដើម ឡើងដោយលេខសូន្យ 0 (លេខសូន្យ  )។

]TahrN_ ៖        013 មានន័យថា 13 Octal ដែលសើμនឹង 11 decimal 07 មានន័យថា 7 Octal ដែលសើμនឹង 7 decimal

I.3.2. ភា្ជប់តំលៃចាប់ផ្ដើមអោយអថេរប្រភេទចំនួនគត់ ឧបមាថាយើងភ្ជាប់តំលៃ 5 អោយអថេរ x នោះយើងអាចសរសេរបានពីររបៀប ដូចខាងក្រោម ៖

int x;

x = 5;

ឬសរសេរ ៖

int x = 5;

I.3.3. ចំនួនថេរប្រភេទចំនួនគត់

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

ឧទាហរណ៍   ៖

1000U បានន័យថាជាចំនួនថេរចំនួនគត់ unsigned int ដែលមានតំលៃ 1000

1000L បានន័យថាជាចំនួនថេរចំនួនគត់ប្រភេទ  long ដែលមានតំលៃ 1000

1000UL ជាចំនួនថេរចំនួនគត់ប្រភេទ unsigned long ដែលមានតំលៃ 1000

0100L ជាចំនួនថេរចំនួនគត់ប្រភេទ long សរសេរក្រោមទំរង់លេខប្រព័ន្ធគោល 8

0x1000U      ជាចំនួនថេរចំនួនគត់ប្រភេទ        unsigned       int       ដែលសរសេរក្រោមទំរង់

ប្រព័ន្ធលេខគោល 16។

I.4. ចំនួនពិត   (Real )

ដូចគ្នាជាមួយនឹងប្រភេទ ទិន្នន័យចំនួនគត់ដែរ   ក្នុងកុំព្យូទ័រវាពុំមាន លទ្ធភាពសំដែង   តៃំ លលេខរបស់ សំនុំចំនួនពិតបានទាំងអស់នោះទេ គឺបានតែផ្នែកណាមួយនៃសំនុំតែប៉ុណ្ណោះ។ ក្នុងភាសា  C ប្រភេទចំនួន ពិតត្រូវបានចែកចេញជាបីប្រភេទផ្សេងៗទៀតគឺ ៖ ប្រភេទ float, double និង long dougle។ នៅពេលដែលអ្នកសរសេរ តំលៃលេខ សំដែងក្រោមទំរង់ប្រព័ន្ធ លេខគោល 16 ឬគោល  8 នោះក្នុងភាសា C ពុំអនុញ្ញាតអោយអ្នកប្រើសញ្ញាក្បៀស (.) បានឡើយ។ការសរសេ លេខដូចខាងក្រោមនេះមានកំហុស ៖

0x5.5   ខុស

05.5              ពេលនេះកុំព្យូទ័រពុំបានយល់ថាលេខនេះជាលេខគោល      8     ទេ     វាបែជាយល់

ថានេះជាលេខគោល 10 ដែលមានតំលៃសេμី 5.5។

នុងស្ទើរគ្រប់ភាសាសរសេរកមμវិធីទាំងអស់    ពេលសរសេរ ក្បៀសទសភាគ

នោះតែងត្រូវបានគេប្រើសញ្ញា (.) ពុំមែនសញ្ញា (,) ទេ។

I.4.1. របៀបសរសេរតំលៃនៃចំនួនពិតក្នុងភាសា  C

3.1416      ត្រូវ 3.      ត្រូវ 5 ខុស
3.0            ត្រូវ 0.5    ត្រូវ 5E-2 ត្រូវ
-12.345     ត្រូវ .50    ត្រូវ 5,00 ខុស
+0.00050 ត្រូវ

ជាមួយគ្នានេះ យើងក៏អាចសរសេរចំនួនទសភាគ តាមទំរង់ ដូចខាងក្រោម ៖

ឧទាហរណ៍

2

512.34567 = 5.1234567.10

ក្នុងភាសា  C យើងអាចសរសេរ ៖

3
= 0.51234567.10

 +2

5.1234567E+02 (ត្រូវសរសេរជាប់គ្នាទាំងអស់) មានន័យថា 5.1234567*10 ដូចគ្នានេះដែរ តំលៃ -0.001234 យើងអាច សរសេរបានថា ៖ -12.34E-4

I.4.3. ចំនួនថេរប្រភេទចំនួនគត់

ដើម្បីសរសេរតំលៃចំនួនថេរប្រភេទចំនួនពិតអោយមានភាពសុក្រិតខ្ពស់                            នោះយើង ត្រូវភ្ជាប់ពីខាងក្រោយតំលៃចំនួនពិតនោះនូវតួអក្សរបញ្ជាក់ F (float) ឬ L (long)។

ទាហរណ៍   0.12345E-33L ជាចំនួនថេរប្រភេទ long double

5.50123E+10F ជាចំនួនថេរប្រភេទ float.12345Fជាចំនួនថេរប្រភេទ float

I.4.4. ភ្ជាប់តំលៃចាប់ផ្ដើមអោយអថេរប្រភេទចំនួនគត់

យើងអាចភ្ជាប់តំលៃចាប់ផ្ដើមអោយអថេរប្រភេទចំនួនពិត តាមលំនាំដូចខាងក្រោម ៖

ឧទាហរណ៍

float   x; x = .50; ឬក៏អាចសរសេរ ៖

float x = .50;

 I.5. ទិន្នន័យប្រភេទ  Char (Character Type)

កុំព្យូទ័រវាពុំត្រឹមតែធ្វើការជាមួយទិន្នន័យជាតំលៃលេខប៉ុណ្ណោះទេ ថែមទាំងវាអាចធ្វើ ការជាមួយបណ្ដាតួអក្សរ  (Letters)  តួលេខ   (Numerals)  និងអាចលាយជាមួយបណ្ដា  សញ្ញាផ្សេង (Sign) ទៀតផង ដែលធាតុនីមួយៗរបស់សំនុំទាំងនេះអាចត្រូវបានគេហៅថា ជា Character។ បណ្ដា Character ដែលយើងតែងតែជួបប្រទះ និងប្រើប្រាស់សព្វថ្ងៃមាន ដូចជា  a, b, c, …, z, A, B, C, …, Z, 0, 1, 2, …, 9, !, ?, \។ល។

ក្នុងភាសា      C     ដើម្បីសរសេរចំនួនថេរនៃ       Character     យើងត្រូវសរសេរ      Character

នោះនៅក្នុងចន្លោះសញ្ញា ‘ ’ (single quote) ឧទាហរណ៍ដូចជា ‘a’, ‘0’, ‘?’, ‘2’, ‘z’ ជាដើម។

Character   ទាំងអស់សុទ្ធតែត្រូវបានគេកំណត់កូដតំណាងអោយវា   ដើម្បីងាយស្រួល ក្នុងការរក្សាទុក និងអនុវត្ដន៍ប្រមាណវិធីលើវា។ ក្នុងនោះដែរ  ASCII (American Standard Code

 

for Information Interchange) បានកំណត់កូដសំរាប់ 256 character និងប្រើមួយ Byte memory

ដើម្បីរក្សាទុកទិន្នន័យ 1 character។

តារាង  ASCII ខាងក្រោមនេះបានបង្ហាញ 128 character ដំបូង ចំណែក 128 ក្រោយទៀត នឹងត្រូវបានបង្ហាញនៅក្នុង សេចក្ដី បន្ថែម នៃសៀវភៅនេះ។ 32 តួដំបូង  (ដែល មានកូដចាប់ពី 0 ដល់ 31) ជាបណ្ដា     character     បញ្ជា      ជាក់ស្ដែងដូចជាកូដ     7     ជា      ASCII     របស់      BELL

បានន័យថាពេលដែលកុំព្យូទ័រទទួលបានតំលៃនេះ វានឹងបញ្ចេញ សំលេងជួង  (Bell)។  ចំណែកឯកូដ  13 (CR-Carriage Return) និង 10 (LF-Line Feed) វិញគឺជា  character បញ្ជាអោយ  screen អនុវត្ដន៍កាចុះបន្ទាត់ និងត្រឡប់មកដើមបន្ទាត់វិញ។ ចាប់ពី ASCII 32 រហូតដល់ 127 ជាបណ្ដា character ដែលអាចបង្ហាញលើអេក្រង់ និង បោះពុម្ពចេញក្រៅបាន។

C C++ក្នុងភាសា   C  យើងអាចសរសេរបណ្ដា character បញ្ជាបានដោយ ប្រើ Constance character ដែលគេបានកំណត់ជាស្រេច ដូចតារាង ខាងក្រោម ៖

Constance character ASCII

មុខងារ

‘\a’                         7            បញ្ចេញសំលេងជួង (BELL)‘\b’                         8            លប់មកឆ្វេងមួយតួអក្សរ (Back Space)‘\t’                         9            Character Tab

‘\n’                        10           ចុះបន្ទាត់ថμី (Line Feed)

‘\r’                        13           ត្រឡប់ទៅដើមបន្ទាត់ (Carriage

Return)

 

ក្រៅពីបណ្ដា     Character     ខាងលើនេះ      ដើម្បីសរសេរសញ្ញា      ឬ     Character     ពិសេស មួយចំនួនដូចក្នុងតារាងខាងក្រោម នោះត្រូវដាក់ Character ‘\’ ពីខាងមុខសិនដូចជា ៖

របៀបសរសេរ                                 Character

 

‘\‘’                                                   ‘

‘\“’                                                   “

‘\\’                                                   \

‘\0’                                          \0 ឬ NULL

 

 

ចូរប្រយ័ត្នចំពោះ Character ‘\0’ និង ‘0’ :

+       Character ‘\0’ គឺជា  Character ដែលត្រូវបានគេហៅម្យ៉ាងទៀតថា NULL និងមាន

ASCII =  0។

+       Character ‘0’ គឺជាតួលេខសូន្យដែលមាន ASCII = 48 decimal។

ការភ្ជាប់តំលៃចាប់ផ្ដើមអោយអថេរប្រភេទ char :                                                                                                    យើងអាចកំណត់ ឬភ្ជាប់តំលៃចាប់ផ្ដើមអោយអថេរប្រភេទ char បានដូចឧទាហរណ៍ ខាងក្រោម ៖

ឧទាហរណ៍char x = ‘5’;

ឬក៏

char x ;x = ‘5’ ;

កមμវិធីខាងក្រោមនេះជាឧទាហរណ៍បង្ហាញអំពីការប្រើប្រាស់បណ្ដា Character បញ្ជា។ ចូរអ្នកវាយកូដកមμវិធីនេះក្នុងមជ្ឈដ្ឋានម្របូលផ្ដុំ TURBO C រួចហើយដំណើរការវា ជាមួយនឹងការពិនិត្យមើល គ្រប់ ដំណាក់កាលនៃការប្ដូរ ឬលុប Character បញ្ជាណាមួយ។ កមμវិធី Prog2_1.C ខាងក្រោមនេះមានការប្រើ Character បញ្ជាមួយចំនួនដូចជា ‘\n’, ‘\t’, ‘\a’, ‘\’’, ‘\”’

។ល។
#include <stdio.h>

#include <conio.h>

void main( )

{

clrscr( );

printf(“Hello every body ! \nThis is a program”); printf(” Showing about the Escape sequence.”); printf(“\nThis program just output text onto

screen\n\n\a\a”);

printf(“\t1.\tGood morning !\n”); printf(“\”Build Bright University\”  \’BBU\'”); getch( );

}

លទ្ធផលលើអេក្រង់គឺ ៖

Hello every body !

This is a program Showing about the Escape sequence. This program just output text onto screen

1.         Good morning ! “Build Bright University”  ‘BBU’

I.6. ទិន្នន័យប្រភេទ  String

ក្នុងភាសា  C String គឺជាស៊េរីនៃ Character ដែលត្រូវបានគេសរសេរ ដាក់ ក្នុង ចន្លោះសញ្ញា “ ” (double quotes) ឧទាហរណ៍ដូចជាឃ្លា “Cambodia”។ ធាតុនីមួយៗ  របស់ String ត្រូវបានដំរៀប ជាប់ៗ គ្នាអស់ពីមួយទៅមួយក្នុង Memory ហើយផ្នែកខាង ចុងបំផុតនៃ ធាតុ របស់ String ត្រូវបានគេផ្ទុក Character NULL ឬ ‘\0’ ដែលនេះជា សញ្ញាមួយប្រើសំរាប់បញ្ញាក់ថា String ត្រូវបានបញ្ញប់ត្រឹមនេះ។

ដូច្នេះឃ្លា “Cambodia” នឹងត្រូវបានរក្សាទុកក្នុង Memory ដូចខាងក្រោម ៖ភាពខុសគ្នារវាង String “A” ជាមួយនឹង  Character ‘A’ គឺ ៖

“A” ត្រូវបានរក្សាទុកក្នុង 2 Byte Memory គឺ ៖                    A       \0

ចំណែក ‘A’ វិញត្រូវបានរក្សាទុកក្នុង 1 Byte Memory គឺ ៖     A

យើងអាចសរសេរ ៖ ‘A’ + ‘b’ + 5 មានន័យថា 65 + 98 + 5

តែយើងពុំអាចសរសេរ ៖

“A” + “b” + 5 (មានកំហុសព្រោះ “A” និង “b” សុទ្ធតែជា  String)

I.7. ទិន្នន័យប្រភេទ  Boolean ទិន្នន័យប្រភេទ   Boolean   ជាប្រភេទទិន្នន័យសំដៅទៅលើតែតំលៃពីរប៉ុណ្ណោះ       គឺ   1   នឹង   0

ដែលនេះជាតំលៃតក្កតំណាងអោយលទ្ធផលរបស់សំណើរមួយ ពិត (TRUE) ឬ មិនពិត (FALSE)។

ឧទាហរណ៍

សំណើរ 5 < 1 នោះលទ្ធផល = FALSE ឬ 0

5 > 1 នោះលទ្ធផល = TRUE ឬ 1

 

យោងតាមឧទាហរណ៍ខាងលើយើងឃើញថា លទ្ធផលរបស់សំណើរ ខាងលើគឺជា ចំនួនគត់ដែលអាចមានតែពីរតំលៃប៉ុណ្ណោះគឺ 0 និង 1។

 II.ចំនួនថេរ និង  អថេរ  (Constance & Variable)

II.1. ចំនួនថេរ

 នៅក្នុងការសរសេរកមμវិធី គេប្រើចំនួនថេរដើម្បីជួយសំរួល អោយ មានភាពងាយស្រួល ក្នុងការប្រើតំលៃ ជាក់ស្ដែងណា មួយដែល នឹង ពុំត្រូវបានប្រែប្រួលក្នុងដំណើរការនៃកមμវិធី។ យើងអាចកំណត់ ឈេμាះ ណាមួយ ដើម្បីតំណាងអោយ តំលៃនៃ ចំនួនថេរ ប្រភេទ ណាមួយ ដោយប្រើពាក្យគន្លឹះ const ពីខាងមុខ។

ឧទាហរណ៍ដូចជា     ³

const int a = 300;

const float b = 3.50;

const char ch = ‘A’, k = ‘5’;

ក្រោយការប្រកាសដូចខាងលើ ពេលនេះយើងទទួលបាន ៖

a ជាចំនួនថេរប្រភេទ integer ដែលមានតំលៃ 300 b ជាចំនួនថេរប្រភេទ float ដែលមានតំលៃ 3.50

ch និង kជាចំនួនថេរប្រភេទ charដែលមានតំលៃ ‘A’ និង ‘5’

ក្រោយពេលប្រកាសបណ្ដាឈេμាះខាងលើនេះជាចំនួនថេររួច                       នោះយើងនឹងពុំអាច

នឹងធ្វើប្រមាណវិធីណាមួយ ដែលបណ្ដាលអោយមានការប្រែ ប្រួល ដល់តំលៃរបស់ចំនួនថេរ ទាំងនោះឡីយ។ ទំរង់នៃការប្រកាសចំនួនថេរ ៖

const ប្រភេទទិន្នន័យ  ឈេμាះចំនួនថេរ = តំលៃនៃចំនួនថេរ

 II.2. អថេរ

នៅក្នុងភាសាសរសេរកមμវិធីកុំព្យូទ័រ   អថេរគឺជាឈេμាះនៃបណ្ដុំ    Memory    (ចាប់ពី   Address ណាមួយទៅ)  ដែលត្រូវបានគេ ប្រើ សំរាប់ រក្សាទុកទិន្នន័យប្រភេទណាមួយនៅក្នុង  Memory  នៃកុំព្យូទ័រ។

ទិន្នន័យទាំងអស់សុទ្ធតែមានប្រភេទរបស់វា      ដូច្នេះដើម្បីប្រើអថេរ     សំរាបផ់ជាដំបូងយើងត្រូវប្រកាសអថេរនោះជាមួយប្រភេទ ទិន្នន័យ ដែល នឹងត្រូវផ្ទុកជាមុនសិន។
របៀបប្រកាសអថេរ

 ប្រភេទទិន្នន័យ      អថេរ1,     អថេរ2, …,    អថេរn;

ឧទាហរណ៏     ៖

int  m,n ;

float  x ;

ក្រោយពេលប្រកាសដូចខាងលើ ពេលនេះយើងទទួលបាន m និង n គឺជាអថេរ  ប្រភេទ int ដូច្នេះយើងអាចយក m និង n ប្រើដើម្បីផ្ទុក ទិន្នន័យប្រភេទ int បាន។ ចំនែកឯ  x វិញត្រូវបានប្រកាសជាមួយ float ដូច្នេះយើងបានវាជាអថេរប្រភេទ float ដែលអាច  ប្រើសំរាប់ផ្ ទុកទិន្នន័យប្រភេទ float បាន។

III. ប្រមាណវិធី
III.1. បណ្ដាសញ្ញាដែលប្រើក្នុងប្រមាណវិធីនពន្ដ

សញ្ញា

អត្ថន័យ

ឧទាហរណ៏

+

បូក

a+b

ដក

a-b

*

គុណ

a*b

/

ចែក

a/b

%

ចែកយកសំណល់

a%b

សញ្ញា    ,               

+       ប្រសិនបើចែកលេខរវាងពីរចំនួនគត់ នោះយើងនឹងទទួលបានផលចែកជា ចំនួនគត់។


ឧទាហរណ៍ ៖

10/3 = 3 (លទ្ធផលគឺ  3ពុំមែន 3.333 ទេ)

+       បើចែកលេខរវាងចំនួនពិត         និងចំនួនពិត        ឬចំនួនពិត       និងចំនួនគត់        នោះយើង នឹងទទួលបានផលចែកជាចំនួនពិត។

ឧទាហរណ៏ ៖

10.00/3      =    3.333333

10/3.0        =    3.333333

សញ្ញា    5               ៖


នេះគជឺាសញ្ញាចែកយកសំណល់ វាត្រូវបានអនុវត្ដតែលើការចែកចំនួនគត់ជាមួយ ចំនួនគត់ប៉ុណ្ណោះ។

ឧទាហរណ៍ ៖

10%3 = 1

10.0%3  ករណីនេះមានកំហុស

កមμវិធីឧទាហរណ៍  ៖

កមμវិធីខាងក្រោមនេះជាឧទាហរណ៍បង្ហាញអំពីការប្រើសញ្ញាចែកយកផលចែក                           និង ការប្រើសញ្ញាចែកយកសំណល់។ កមμវិធី Prog2_2.C

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

void main()

{    int a, b; /*— ប្រកាសអថេរ a និង b ជាអថេរប្រភេទ int —*/

float x; /*— ប្រកាសអថេរ x ជាអថេរប្រភេទ float —*/

a = 10 ;

b = 3;

x = a/b; /*— ចែកចំនួនគត់ a អោយ b —*/

clrscr(); /*— លុបបណ្ដាអក្សរដែលកំពុងមានលើអេក្រង់ —*/

printf(“x = %f”,x); /*— បង្ហាញតំលៃ  x លើអេក្រង់  —*/ x = 10.0/3; /*— ចែកចំនួនទសភាគ 10.0 អោយ 3 —*/ printf(“\nx = %f”,x);

x = a % b;

printf(“\nx = %f”,x);

a = 20 % 7; /* ចែកយកសំណល់ ហើយភ្ជាប់លទ្ធផលអោយ a */

printf(“\nA = %d”,a);

getch(); /*— រង់ចាំ  Press Key ណាមួយ  —*/

}

លទ្ធផលលើអេក្រង់គឺ ៖

x = 3.000000 x = 3.333333 x = 1.000000 x = 6

 III.2. អាទិភាពក្នុងប្រមាណវិធីនពន្ដ

នៅក្នុងការធ្វើប្រមាណវិធីនព្វន្ដ ការគណនាត្រូវចាប់ចេញ ដំណើរ ពីឆ្វេងទៅស្ដាំ និងសញ្ញាប្រមាណ វិធីនីមួយៗអាចមាន អាទិភាព ផ្សេងៗគ្នា ដូចជា  ប្រមាណវិធីបូក និងដក គឺមានអាទិភាពសេμីគ្នា ក៏ប៉ុន្ដែវាត្រូវទាបជាងអាទិភាពរបស់ប្រមាណវិធីគុណ ចែក និងចែក  យកសំណល់ (តែប្រមាណវិធីទាំងបី នេះមានអាទិភាពសេμីគ្នា)។

ក្នុងកន្សោមមួយ វាអាចមានការធ្វើប្រមាណវិធីច្រើន  ហើយ ប្រមាណ វិធីនីមួយៗអាចមានអាទិភាពផ្សេងៗគ្នា  ដូច្នេះក្នុងកន្សោម នោះនឹង ត្រូវមានប្រមាណវិធីខ្លះបានអនុវត្ដ  មុននិងខ្លះទៀតត្រូវអនុវត្ដ តាម ក្រោយ។

ឧទាហរណ៏ការគណនាកន្សោម ៖       5+10/3

លទ្ធផលនៃការគណនាកន្សោមខាងលើនេះគឺ 8 ពីព្រោះសញ្ញាចែក មាន អាទិភាព ខ្ពស់ជាងសញ្ញាបូកដូច្នេះត្រូវអនុវត្ដប្រមាណវិធីចែក មុន បានលទ្ធផលហើយទើបអនុវត្ដ ប្រមាណវិធីបូកតាមក្រោយ។ ដើម្បី ជៀស វាង កំហុសក្នុងប្រមាណវិធី   ឬក្នុងកន្សោមប្រមាណវិធី   នោះយើងត្រូវ

ប្រើសញ្ញារង្វង់ក្រចក ( ) ដើម្បីបញ្ញាក់អំពីអាទិភាពនៃប្រមាណវិធី។ ឧទាហរណ៍ដូចជា ៖ (5+10)/3    យើងបានលទ្ធផលគឺ 5

5+(10/3)    យើងបានលទ្ធផលគឺ 8

III.3. ប្រមាណវិធីប្រៀបធៀប  និង  ប្រមាណវិធីតក្ក

លទ្ធផលរបស់ប្រមាណវិធីប្រៀបធៀប    និងប្រមាណវិធីតក្ក    មានតែពីរតំលៃប៉ុណ្ណោះ    គឺពិត    (1) ឬមិនពិត (0) ដូច្នេះលទ្ធផល របស់ប្រមាណវិធីនេះជាទិន្នន័យប្រភេទ Boolean។

សញ្ញា

អត្ថន័យ

ឧទាហរណ៍

>

ធំជាង  ឬទេ?

a > b

>=

ធំជាង  ឬសើμ ឬទេ? a > = b

<

តូចជាង  ឬទេ?

a < b

<=

តូចជាង  ឬសើμ ឬទេ? a < = b

==

សើμគ្នា ឬទេ?

a = = b

!=

ខុសគ្នា  ឬទេ?

a ! = b

 

4         សញ្ញាប្រមាណវិធីដំបូងមានអាទិភាពសេμីគ្នា  ប៉ុន្ដែវា ខ្ពស់ជាងអាទិភាពរបស់ពីរសញ្ញាប្រមាណវិធី ចុងក្រោយ     (គឺ    ==    និង    !=    )    តែក្នុងនោះប្រមាណវិធី     (==)    និង    (!=)

មានអាទិភាពសេμីគ្នាវិញ។គ្រប់បណ្ដាសញ្ញាប្រមាណវិធីប្រៀបធៀប ទាំងអស់ សុទ្ធតែមានអាទិភាពទាបជាងបណ្ដាសញ្ញាប្រមាណ វិធីនព្វន្ដ    ឧទាហរណ៍ដូចជាកន្សោម          m     <     (n-1)     នោះកុំព្យូទ័រនឹងអនុវត្ដ

សញ្ញា

អត្ថន័យ

ឧទាហរណ៍

!

បដិសេធន៍ (NOT)

!a

&&

ប្រមាណវិធី (AND) a && b

||

ប្រមាណវិធី (OR)

a || b

ខាងក្រោមនេះ ជាតារាងឧទាហរណ៍បង្ហាញអំពីការប្រើប្រាស់បណ្ដាសញ្ញាប្រមាណ  វិធីតក្ក។

a       b      !a      !b        a&&b        !(a&&b)         a || b           !(a || b)

0       0       1       1            0                 1                  0                 1

0       1       1       0            0                 1                  1                 0

1       0       0       1            0                 1                  1                 0

1       1       0       0            1                 0                  1                 0

 

cMNaM   ³     ក្នុងប្រមាណវិធីតក្ក a និង b អាចជាចំនួនគត់ ឬចំនួនពិត បណ្ដាសញ្ញាប្រមាណវិធីប្រៀបធៀបទាំងអស់ សុទ្ធតែមាន អាទិភាព ទាបជាងសញ្ញា  ប្រមាណវធិ  ី NOT ក៏ប៉ុន្ដែវាមានអាទិភាព ខ្ពស់ជាង សញ្ញាប្រមាណវិធី AND និង OR វិញ។ ឧទាហរណ៏កន្សោម (a<b)&&(c>d) យើងអាចសរសេរបានថា a<b&&c>d ពេលនោះការធ្វើប្រមាណវិធីលើកន្សោមនេះគឺត្រូវអនុវត្ដប្រមាណវិធី a < b រួចហើយទើប គណនា c > d និងជាចុងក្រោយទើបយក លទ្ធផល ពីរ ប្រមាណវិធីមុននេះទៅអនុវត្ដប្រមាណ វិធី AND។ ខាងក្រោមនេះ បង្ហាញ អំពីលំដាប់អាទិភាពក្នុងប្រមាណវិធីប្រៀបធៀប និងប្រមាណ វិធីតក្ក ៖

!

>> =                   <<=

= =                      ! =

&&                     ||

ប្រមាណវិធីទាំងនេះ ជាធមμតាវាតែងត្រូវបានគេប្រើដើម្បីបង្កើតលក្ខខណ្ឌសំរាប់ ជ្រើស រើសការងារ ឬក៏បញ្ចប់ការងារនៅក្នុងរង្វិល (Loop) ណាមួយ។

កមμវិធីខាងក្រោមនេះ                         ជាឧទាហរណ៍បង្ហាញអំពីរបៀបប្រើប្រាស់បណ្ដាសញ្ញាប្រៀប ធៀបខាងលើនៅក្នុងការសិក្សាលក្ខខណ្ឌដើម្បីជ្រើសរើសការងារមកអនុវត្ដ។កមμវិធី Prog2_3.C

#include <stdio.h>

#include <conio.h>

void main()

{

int n;

printf(“\nInput an integer between 0 and 10 :”);

scanf(“%d”,&n);

if(n>5)

printf(“\nYou entered %d which is greater than 5”,n);

if(n<5)

printf(“\nYou entered %d which is smaller than 5”,n);

if(n==5)

printf(“\nYou entered 5”);

getch();

}

លទ្ធផលលើអេក្រង់គឺ ៖

Input an integer between 0 and 10 : 6

 

III.4. ប្រមាណវិធីលើ  BIT

ខាងក្រោមនេះជាបណ្ដាការងារដែលតែងតែបានជួបជាញឹកញាប់នៅក្នុងភាសា កំរិត ទាប តែពុំសូវជាបានជួបនៅក្នុងភាសាកំរិតខ្ពស់ឡើយ។ វាមាន មុខ ងារ សំរាប់ ធ្វើប្រមាណ វិធីទៅលើ  Bit នីមួយៗរបស់ចំនួនគត់  (បណ្ដាសញ្ញាប្រមាណវិធីខាងក្រោមនេះ  ពុំអាច   អនុវត្ដបានចំពោះ ប្រភេទទិន្នន័យ float និង double ឡើយ) :

សញ្ញា

អត្ថន័យ

ឧទាហរណ៍

&

ប្រមាណវិធី AND ចំពោះ  Bit នីមួយៗ

a & b

|

ប្រមាណវិធី OR ចំពោះ  Bit នីមួយៗ

a | b

^

ប្រមាណវិធី XOR ចំពោះ  Bit នីមួយៗ

a ^ b

<<

រំកិលឆ្វេង a << b

>>

រំកិលស្ដាំ a >> b

~

ប្រមាណវិធីបដិសេធន៍ Bit នីមួយៗ

~ a

ឧទាហរណ៍ ៖

a

b

a & b a | b

a^b

1

1

1

1

0

1

0

0

1

1

0

1

0

1

1

0

0

0

0

0

N

a << N = a*2

a >> N =    a  

2N

~1     = 0

~0     = 1

សំណួរ

1.      ចូរនិយាយអំពីភាពខុសគ្នារវាង Character ‘\0’ និង ‘0’ ?

2.      ចូរនិយាយអំពីភាពខុសគ្នារវាង “A” និង ‘A’ ?

3.      តើអថេរ និងចំនួនថេរគឺជាអ្វី? និងត្រូវបានគេប្រើសំរាប់ធ្វើអ្វី?

4.      ចូរកំណត់តំលៃរបស់កន្សោមខាងក្រោម ៖

x1 = 10%3

x2 = 10/3 x3 = 10/3.0 x4 = 10.0/3 x5 = 10.0/3.0

5.      ចូរកំណត់តំលៃកន្សោមខាងក្រោម ៖ a).            5.6 + 2.7 + 20/6 + 8.0 b).        5.6 + 2.7*20/6 – 8

6.      ចូរគណនាកន្សោមប្រៀបធៀបខាងក្រោម ៖

a).     x1 = (6+5*3/2) <= (7/4*2+10/4)

b).     x2 = (6+5*3/2) == (7/4*2+10/4)

c).     x3 = (6+5*3/2) != (7/4*2+10/4)

7.      ចូរគណនាប្រមាណវិធីខាងក្រោម ៖

a = 10;       b = 5;         c = 7;

x = (((a+b) <= (a-c)) || (a+b+c) >= 1000)

y = (!(a+b) <= 4 || (a-c) > 2) && (a+b+c < 100)

8.      ចូរកំណត់តំលៃរបស់បណ្ដាកន្សោមខាងក្រោម ៖

x1 = 10 & 5

x2 = x1 | 25 – 5 x3 = x1 ^ x2

x4 = (10 << 2) + (20 >> 4)

9.      ចូរបង្ហាញបណ្ដាកន្សោមដែលមានលក្ខណៈត្រឹមត្រូវ ៖

a).     (i = j)++                          b).     i+j++

c).     ++(i+j)                            d).     ++i+++j

មេរៀនទី៤: Control Structure

មេរៀនទី៤: Control Structure

I. If …statement :

 Syntax 1 :

 if (Logic Expression ) statermen1 ;

 if (កន្សោមលក្ខខណ្ឌÐ )

Statement1;
Syntax 2 :
if ( Logic Expression ) statement 1 ; else statement 2 ;

 if (កន្សោមលក្ខខណ្ឌ)

Statement1;
else

Statement2;

ចំពោះ Syntax1: បើ Expression មានតំលៃ True (=1) នោះ Statement 1 ត្រូវបានអនុវត្ដ, ផ្ទុយមកវិញ (Expression មានតំលៃ False (= 0 ) នោះ Statement 2 ត្រូវបានអនុវត្ដ ។ ចំពោះ syntax 2 : បើ Expression =1 នោះ Statement 1 ត្រូវបានអនុវត្ដ បើ Expression

= 0 នោះ statement If … នឹងត្រូវបញ្ចប់ ។ ចំពោះ Expression ត្រូវតែសរសេរក្នុងវង់ក្រចក () ។
ចំពោះ single statement នោះត្រូវបញ្ចប់ដោយសញ្ញា (់ប ។
C C++ពិនិត្យ ឧទាហរណ៍ខាងក្រោម ៖គណនាតំលៃ Max, Min នៃពីរចំនួន Read from Keyboard :

Ex:
#include <stdio.h>

#include <conio.h>

main ( )

{

int n1, n2, min, max;

clrscr ( ) ; /* clear screen output */

printf (“Enter the first Value = ”); scanf (“%d”, &n1);

printf (“Enter the Second Value = ”); scanf (“%d”, &n2);

if (n1 <n2)

{

min = n1 ;

max = n2 ;

}

else

{

min =n2 ;

max= n1 ;

}

printf (“maximum = %d”, max);

printf (“minimum = %d”, min);

getch(); return(0);

}

យើងអាចជំនួស statement if … else …្បខាងលើដោយ statement

min = (n1 < n2) ? n1 : n2 ;

max = (n1 > n2) ? n1 : n2 ;

ឬយើងអាចសរសេរ ៖ (n1 < n2 ) ? (min = n1, max = n2 ) : (min = n2, max =n1 );

Ex 2: កំណត ់តំលៃ n តើសេ μីសូន្យឬអត ់ ? បើ n =0 នោះត្រូវសរសេរមកលើ screen ថា ៖ តំលៃ n

= 0 ផ្ទុយមកវិញ n< >0 .

#include <stdio.h>

#include <conio.h>

main ( )

{

int n;

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

if ( n !=0 )

printf (“ Value n < > 0 “);

else

printf (“ Value n = 0 “ );

getch ( ); return (0) ;

}

បណ្ដាឧទាហរណ៍នៃប្រភេទ Expression logic ក្នុង Statement If :

if ( count < =100)…

if ( sqrt ( a + b + c )> 0.005 )…

បើ ch1 ឈរពីមុខ ទ ក្នុងតារាង Code ASCII )

if ( latter != ‘x’)…

if (( count <= 100) && (ch != ‘x’))…

if ( ! (copy >=100.0) && (status == ‘s’))…

Ex4:
#include <stdio.h>
#include <conio.h>
main ( )
{
float a, b;

 clrscr ( )
printf (“Enter a, b = ”); scanf (“ %f %f”, &a, &b );

if (b != 0 )

printf (“Result = %f ”, a/b);

else

printf (“Error ! Division by Zero” ) ;

gatch ( ); return 0 ; }

យើងអាចជំនួស Logic Expression if (b! = 0) ដោយ if (b) .

Ex5: សរសេរកមμវិធីដោះស្រាយឬសនៃសមីការ ax² + bx +c =0 (a,b,c.: Read from

keyboard ):

#include <stdio.h>

#include <conio.h>

#include <math.h>

main ( )

{ float a, b, c ;

float x1 , x2, delta;

clrscr ( ) ;

printf (“a =”); scanf (“ %f”, &a);

printf (“b =”); scanf (“ %f”, &b);

printf (“c =”); scanf (“ %f”, &c);

delta =(b * b) – (4 *a * c );

printf (“ delta = %f ”, delta );

if (delta ==0)

{ printf (“ Only One Root ” );

printf (“x = %f ”, -b/(2 *a));

}

if (delta >0 )

{ printf (Two Root ”);

x1 = (-b + sqrt (delta )) / (2 * a);

x2 = (-b – sqrt (delta )) / (2 * a);

printf (“ x1 = %f ”, x1 );

printf (“ x2 = %f ”, x2 );

}

if (delta < 0)

printf (“ No root”);

getch ( );

return (0);

}

ដោះស្រាយវិសមីការ ax + b>0; (a,b :Read from keyboard )

#include <stdio.h>

 #include <conio.h>

#include <math.h>

main ( ) { float a, b, x ; clrscr ( );

printf (“ Enter a,b =”); scanf (“%f %f”,&a, &b);

if ( a = 0)

if ( b > 0)

printf (“Infinitive ”);

else

printf (“No Root ”);

if ( a > 0 )

printf (“x > %f ”, ( -b/a));

if ( a< 0 )

printf (“x < %f ”, ( -b/a));

getch ( );

return (0);

}

 II. switch ( ) Statement :

ពាក្យគន្លឹះ switch ប្រើសំរាប់កំណត់តំលៃកន្សោមចំនួនគត់
ចាប់ផ្ដើមការងារ (Statement) ដែលមានទំរង់ដូចខាងក្រោម ៖

 switch (កន្សោមចំនួនគត់)

{

case n 1 :

បណ្ដា Statements;

case n 2 :

បណ្ដា Statements;

………

case n k :

បណ្ដា Statements;

[default :

បណ្ដា Statements;]

}

ដែល i ≤ 1 ≤ k) នៅទីនេះអាចជាចំនួនគត់ អាចជាចំនួនថេរប្រភេទ charឬអាចជាកន្សោមថេរណាមួយ។ ចំពោះកំណាត់កម μវិធីសរសេរ នៅក្នុងចន្លោះ “ និង ” វិញហៅថាជាតួខ្លួនរបស់ switch ដូច្នេះពេល ដែលយើងនិយាយថា ចាកចេញពី switchឬចាកចេញពីតួខ្លួនរបស់ switch នោះមានន័យថាកម μវិធីនឹងលោតទៅអនុវត្ដ Statement

ដែលស្ថិតនៅក្រោយបន្ទាប់ពី សញ្ញា ” 9ដែលសញ្ញា ” នេះជាសញ្ញា បញ្ចប់ switch). ចំពោះ default វិញគឺជាផ្នែកមួយ របស់ switch តែមិនចាំបាច់ដាច់ខាតត្រូវតែមានវា នោះទេ។

 ដំណើរការរបស់ពាក្យគន្លឹះ switchដំណើរការរបស់ switchសញ្ញា រង្វង់ក្រចកជាប់ពាក្យគន្លឹះ swicth នោះ។គឺពឹងផ្អែកទៅលើតំលៃ របស់ កន្សោម ដែលស្ថិតនៅក្នុងពេលដែលតំលៃនៃកន្សោមនោះសេ μី n នោះកុំព្យូទ រនឹងលោតទៅអនុវត្ដបណ្ដា Statement

iដែលស្ថ តនៅជាប់ខាងក្រោយសញ្ញា ( : ) របស់ត ៃ ំ ល n នោះបន្ដទៅខាងក្រោម។ពេលដែលតំលៃកន្សោមខុសពី n នោះកុំព្យូទ័រនិងធ្វើការដូចខាងក្រោម ៖

a. បើមាន default នោះវានឹងលោតទៅអនុវត្ដ Statement ចាប់ពី ក្រោយសញ្ញា ( : )

របស់ default.

b. បើគ μាន default ទេនោះកុំព្យូទ័រនឹងចាកចេញពី switch.

 ចាកចេញពីពាក្យគន្លឹះ switch

ម៉ាស៊ីននឹងចាកចេញពី switch នៅពេលជួបពាក្យគន្លឹះ break ឬជួបសញ្ញាបិទ ឃ្នាបរបស់ switch } 9សញ្ញាបិទបញ្ចប់ switch ចុងក្រោយបង្អស់ ប។ យើងក៏អាចប្រើ ពាក្យគន្លឹះ goto

នៅក្នុងខ្លួនរបស់ switch ដើម្បីលោតទៅរក Statement ណាមួយនៅ ខាងក្រៅតួ switch. ពេលដែល switch ត្រូវបានគេប្រើនៅក្នុង អនុគមន៍ណាមួយនោះ យើងអាចប្រើពាក្យគន្លឹះ return នៅក្នុងតួខ នរបស់ switch ដើម្បីចាកចេញពីអនុគមន៍នោះ។


ចំណាំ ៖ពេលដំណើរការជួប switch នោះកុំព្យូទ័រនឹងកំណត់តំលៃ កន្សោមក្នុងសញ្ញារង្វង់ ក្រចករបស់ switch រួចស្វែងរកតំលៃដែល កំណត់បាននោះក្នុងតួខ្លួន switch. បើរកពុំ ឃើញទេ វានឹងចាក ចេញពីតួ switch តែបើវារកឃើញនោះវានឹងចាប់ ផ្ដើមអនុវត្ដការងារ ចាប់ពីសញ្ញា ( : ) នៃ n i ឧបមាថាតំលៃរបស់កន្សោមគឺ n i 
នោះតាមលំដាប់ពីឆ្វេងទៅ ស្ដាំ ជួបបណ្ដាពាក្យគន្លឹះ return, goto, break ឬក៏ជួប សញ្ញាបិទឃ្នាបបញ្ចប់ switch ទើបកុំព្យូទ័រចាកចេញពីតួ switch ហើយលោតទៅតាម កន្លែងដែលបណ្ដា Keyword ខាងលើបានកំណត់អោយទៅអនុវត្ដបន្ដ។ ចូរសរសេរពីរកម μវិធីខាងក្រោម ហើយពិនិត្យមើលភាពខុសគ្នារវាង Statement ទាំងពីរ ៖

 កមμធី
Prog4_3.C :

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

 void main()

{ int n;

clrscr();

printf(“Input n = “);

scanf(“%d”, &n); /*បញ្ចូលតំលៃអោយអថេរ n */

switch(n)

{ case 1 : printf(“year in BBU”);

break;

case 2 : printf(“year in BBU”);

break;

case 3 : printf(“year in BBU”);

break;

case 4 : printf(“year in BBU”);

break;

default : printf(“inputed %d”,n);

}

getch();

}

 កមμវិធី Prog4_4.C :

 #include <stdio.h>

#include <conio.h>

void main()

{ int n;

 clrscr();

printf(“Input n = “);

scanf(“%d”,&n);

switch(n)

{ case 1 : printf(“year in BBU”);

break;

case 2 : printf(“year in BBU”);

case 3 : printf(“year in BBU”);

case 4 : printf(“year in BBU”);

default : printf(“inputed %d”,n);

}

getch();

}

ចូរព្យាយាមដំណើរការទាំងពីរកម μវិធ ខាងលើនេះ ជាមួយនឹងការបញ្ច លតំលៃអោយ អថេរ n ផ្សេងៗគ្នា។

 Ex3:

#include <stdio.h>

#include <conio.h>

main ( )

{ int n;

clrscr ( );

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

switch (n);

{

case 0 : printf (“ number 0” ); Break;

case 1 : printf (“ number 1” ); Break;

case 2 : printf (“ number 2” ); Break;

}

printf (“ Good by ”);

getch ( );

return (0)

}

 តំលៃមួយទៅអោយ n . ហើយ statement switch និង ពិនិត្យមើលតំលៃរបស់ តើសមមូលនិងករណីណា,

+ បើ n = 0 នោះវា នឹងអនុវត្ដ Statement ដែលនៅពីក្រោយ Keyword Case 0…

+ បើ n = 1 នោះវា និងអនុវត្ដ Statement ដែលនៅពីក្រោយ Keyword Case 1…

_ Statement break មាននាទីសំរាប់ចេញក្រៅ statement switch ( ) ហើយ ទៅអនុវត្ដន៏ នូវបណ្ដាstatement ដែលនៅបន្ដបន្ទាប់ពី statement switch . ដើម្បីយល់ច្បាស់នូវ Statement break, ចូរពិនិត្យ

ឧទាហរណ៍ខាងក្រោម ។

 Ex4:
#include <stdio.h>

#include <conio.h>

main ( )

{ int n ; clrscr ();

printf (“ Enter n = ”);

scanf (“ %d”, &n );

switch (n)

{ case 0 : printf (“ number Zero”); break;

case 1 : printf (“ number One”); break;

case 2 : printf (“ number Two”); break;

default : printf (“ Good by ! ”);

}

getch ( );

}

ក្នុង ឧទាហរណ៍នេះ, យើងថែម Statement default នៅខាងចុង ។ នោះជាករណីសមមូលនឹងតំលៃក្រៅពី 0,1, 2, .

Ex5 : ករណី case មូយដែលមានតំលៃច្រើន ៖

#include <stdio.h>

#include <conio.h>

main ( )

{ int n;

printf (“ Enter n = ”);

scanf (“ %d”, &n );

switch (n)

{

case 0 : printf (“ Number Zero ”); break;

case 1 : printf (“ Number One ”); break;

case 2 : printf (“ Small number ”); break;

case 3 : printf (“ Small number ”); break;

case 4 : printf (“ Average number ”); break;

case 5 : printf (“ Big number ”);

}

printf (“ Good by ! );

getch ( );

return (0) ;

}

លំហាត់អនុវត្ដន៍

 គេអោយ 4ចំនួន a, b, c, d Read from Keyboard . ចូររកចំនួន Maximum និង Assignment តំលៃនោះទៅអោយ Variable Max, និង print the Result on screen output សរសេរកមμវិធីដោះស្រាយ ប្រព័ន្ឋសមីការខាងក្រោម ៖

ax + by = m

cx + dy = n

 សរសេរកមμវិធីដោះស្រាយសមីការ ax +b >0

4. សរសេរកមμវិធី Read from keyboard នូវបណ្ដាចំនួនគត់ n (1≤ n ≤ 10 )ហើយ សរសេរភាសា អងគ្លេសនៃចំនួនទាំងនោះមកលើ screen .

ឧបមាថា ៖ បើវាយបញ្ចូលលេខ 2 នោះត្រូវសរសេរមកលើ screen : 2 Tow .បណ្ដាប្រទេសជាសមាជិកនៃអង្គការពិភពលោកមួយ ៥។
ត្រូវបានបែងចែកជា
% ប្រភេទដែលមានលេខរៀង ៖ 1, 2, 3, 4, 5, ប្រទេសនីមួយៗត្រូវបង់វិភាគទានតាមការកំណត់មួយដូចខាងក្រោម ៖

។ រៀងរាល់ឆ្នាំ ប្រទេសទី 1, 2, 3, 4 ត្រូវបង់ 1%, 0,7%, 0,5%, 0,1% នៃប្រាក់ចំណូលប្រចាំឆ្នាំ ។ ប្រទេសប្រភេទទី5

ត្រូវបង់ 1.000.000$ . ចូរសរសេរកម μវិធី Read from keyboard នូវឈេ μាះប្រទេស, ប្រភេទប្រទេស, ប្រាក់ចំនូលប្រចាំឆ្នាំ (បើត្រូវការ ), ហើយគណនា និង សរសេរមកលើ screen នូវឈេ μាះរបទេស និង ប្រាក់ដែលត្រូវបង់វិភាគទារ ។

6. សរសេរកមμវិធី គណនាជ្រុង a នៃត្រីកោណ ABC បើគេស្គាល់ជ្រុង b ជ្រុង c និង មុំ B.
7. Read from keyboard នូវកូអរដោនេដេកាតនៃ4ចំនុច A, B, C, D. .

ចូរត្រួតពិនិត្យមើលបួនចំនួនខាងលើនោះអាចបង្កើតបានជាចតុកោណប៉ោង

បើបានចូរគណនាក្រលាផ្ទៃនៃចតុកោណប៉ោង នោះ, ហើយសរសេរមកលើ screen .ថ្ងៃ, ខែ, ឆ្នាំ នៃថ្ងៃណាមួយក្នុងសតវត្សទី2០, ហើយគណនាថ្ងៃនោះជាថ្ងៃអ្វី


? (ចន្ទ័, អង្គារ,…,អាទិត្យ ) ផ្អែកលើថ្ងៃបច្ចុប្បន្នដែល Read from keyboard .

9. Read from keyboard នូវកូអរដោនេ3ចំនួន A, B, C, ហើយ Read ថែមមួយចំនុច ំ ទៀតពី

keyboard, ហើយត្រួតពិនិត្យ មើលចំនុច ំ នោះ, ស្ថិតត្រីកោណ ABC ឬ នៅក្រៅត្រីកោណ

10. សរសេរកមμវិធី ដោះស្រាយសមីការ ax + bx + c >0

11. សរសេរកមμវិធី Read from keyboard នូវតំលៃ ខ ហើយគណនា ៖

មេរៀនទី៥: រង្វិលជុំ 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 */

}

មេរៀនទី៦: អនុគមន៍ និង ម៉ាក្រូ

មេរៀនទី៦: អនុគមន៍ និង ម៉ាក្រូ Function & Macro

I. សញ្ញាណទូទៅនៃ   SubProgram

ក្នុងការសរសេរកមμវិធី យើងតែងជួបប្រទះផ្នែកមួយ ចំនួន របស់ កមμវិធីត្រូវបានសរសេរ ម្ដងហើយម្ដងទៀតជាច្រើនលើក ច្រើន សារនៅតាមកន្លែងខុសៗគ្នា។  ដើម្បីជៀសវាងការ សរសេរ ច្រើន ដងនូវ កំណាត់កមμវិធីដដែលនេះ យើងអាចយកកំណាត់កមμវិធីទាំង នេះទៅបង្កើត ជាកមμវិធីរង (Subprogram) ហើយយកឈេμាះ របស់កមμវិធីរងនោះទៅជំនួសនៅតាម កន្លែងដែលត្រូវប្រើកំណាត់ កមμវិធីនេះ។ មានន័យថា ពេលណាចាំបាច់ត្រូវប្រើកំណាត់កមμវិធី មុននេះយើងគ្រាន់តែហៅឈេμាះរបស់កមμវិធីរងសមមូលនឹងវាមក ប្រើជាការស្រេច ដោយ មិនចាំបាច់សរសេរកំណាត់កមμវិធីទាំងនោះ ឡើងវិញជាច្រើនលើកច្រើនសាឡើយ។ ឧទាហរណ៍ ថាពេលធ្វើ លំហាត់ គណនា cos ឬ sin នោះយើងត្រូវគណនាជាច្រើនលើកច្រើន សានូវ sin របស់មុំណាមួយ ដូច្នេះយើងត្រូវបង្កើតកមμវិធីរងមួយ មាន ឈេμាះថា sin និងប៉ារ៉ាមែត្រ សមមូលរបស់វាគឺ x (ដែល x ទីនេះគឺ ជាមុំ ត្រូវគណនា)។ បណ្ដាកមμវិធីរងទាំងអស់នេះត្រូវ បានគេបង្កើត ឡើង រួចជា ស្រេច និងសរសេរប្រកាសវានៅក្នុង library file របស់ ភាសា សរសេរកមμវិធីមួយចំនួនដូចជា C, Pascal, Basic។ល។ ដូចនេះយើងអាចហៅកមμវិធីរង ទាំងនេះបានថាជាអនុគមន៍ដែល មាន ស្រាប់  ឬ Standard Subprogram ។ ក្នុង Turbo C បណ្ដា  Subprogram ទាំងនេះត្រូវបានបែងចែកទៅជាក្រុម ហើយទុកនៅក្នុង file ផ្សេងៗពីគ្នាដូចជា stdio.h , conio.h , math.h ជាដើម។

ហេតុផលមួយទៀតដែលត្រូវបង្កើតកមμវិធីរងគឺ នៅពេលសរសេរ កមμវិធី ធំមួយនោះ ភាពសμុគ្រសμាញជាច្រើនបានកើតឡើង ហើយពេលនោះកមμវិធីអាចមានប្រវែងវែងអន្លាយ ដែលបណ្ដាល អោយមានការពិបាកយ៉ាងខ្លាំងក្នុងការស្វែងរកកំហុស និងកែសំរួល។ ដូច្នេះយើងអាចផ្ដាច់បញ្ហាសμុគសμាញទាំងនោះទៅជាចំណែកតូចៗ គឺបង្កើតទៅជាកមμវិធីរង ឬជា បណ្ដុំ  (Block) ឬជាម៉ូឌុល ដើម្បីងាយ ស្រួលក្នុងការត្រួតពិនិត្យ និងស្វែងរកកំហុស តាមបំណែកនីមួយៗ របស់កមμវិធីរង បន្ទាប់មកទើបប្រមូលកមμវិធី រងទាំងនោះ មកផ្គុំ គ្នាដើម្បី បង្កើតជាកមμវិធីធំខាងលើវិញ។ កមμវិធីរង ត្រូវ បាន គេប្រើប្រាស់យ៉ាងទូលំទូលាយ ដូច្នេះចំណេះដឹងអំពីការប្រើ និង បង្កើតកមμវិធីរង គឺជាភាពចាំបាច់បំផុតសំរាប់អ្នក ក្នុងការសរសេរ កមμវិធី។ ក្នុងបណ្ដាភាសា សរសេរកមμវិធីមួយចំនួនដូចជា Basic ឬ Pascal ជាដើម  មានការបែងចែកកមμវិធីរង ជាពីប្រភេទគឺ Function និង Procedure តែក្នុង C/C++ វិញគឺមានតែ  Function មួយគត់។ II. អនុគមន៍       (Function ) ក្នុងភាសាសរសេរកមμវិធីកុំព្យូទ័រ អនុគមន៍គឺជាទំរង់បែបបទនៃការងារណាមួយ ដែលត្រូវបានកំណត់ ឈេμាះ នឹងត្រូវបានរក្សាទុកក្នុង Memory ដើម្បីឆ្លើយតបអោយអ្នក ប្រេនីវូ តៃំ លដែលមានប្រភេទណាមយួ   ។ ឧទាហរណ៍ដូចជា អនុគមន៍ NPV របស់ MS-Exel វានងឹ ផ្ដល់អោយអ្នកនូវតំលៃបច្ចុប្បន្ន (Present Value) គឺប៉ុនμាន?  ក្រោយពេលដែលអក្ន បាន បញ្ចូល ទិន្នន័យអោយវាមួយចំនួនដូចជា អំឡុងពេល  (Period)

អត្រាការ ប្រាក់  (Rate) និង តំលៃអនាគត (Future Value)។អនុគមន៍ត្រូវបានគេប្រេជីាមួយបណា្ដ កន្សោមផ្សេងៗបាន តែពុំអាច ចាត់ទុកវាថាជា Statement បានទេ។ អនុគមន៍យក ទិន្នន័យ ចូលតាមរយៈប៉ារ៉ាមែត្រ នឹងបោះតំលៃចេញមកខាងក្រៅវិញ តាមរយៈឈេμាះរបស់វា។ ក្នុង C យើងអាចប្រើអនុគមន៍ តាម បែបផែនផ្សេងៗគ្នា ៖

•     តៃំ លរបសអ់នុគមន៍ យើងអាចនឹងពុំយកវាប្រើក៏បាន ជាកែ់ ស្ដងដចូជាអនគុមន៍ printf និង scanfដែលអនុគមន៍ទាំងនោះ សុទ្ធតែផ្ដល់ តំលៃមកវិញមានប្រភេទជាចំនួនគត់។

•   អនុគមន៍ខ្លះអាចគμានតំលៃណាមួយត្រូវបានភ្ជាប់អោយ ឈេμាះរបស់វា (អនុគមន៍ ប្រភេទ void)។

•     ឈេμាះអនុគមន៍  អាចផ្ដល់តំលៃជាអាសយដ្ឋាន  Memory ដែលវាបានកំពុង  តែចង្អុលទៅរក(អនុគមន៍ប្រភេទ  Array ឬ Pointer)។

•     អនុគមន៍ អាចផ្លាស់ប្ដូរ ឬធ្វើអោយប្រែប្រួលតំលៃដើមរបស់ អាគុយម៉ង់។ ទោះបីជាហៅថាអនុគមន៍មែន ប៉ុន្ដែ C មិនបានកំណត់ លក្ខខណ្ឌនៃរបៀបប្រើប្រាស់ ទេ។ ក្រៅពីនេះទៀត C នៅផ្ដល់ លទ្ធភាព អោយយើងអាច Compile ម៉ូឌុលនីមួយៗដាច់ ដោយឡែក ពីគ្នាបាន ដែលបញ្ហានេះមានសារៈសំខាន់បំផុត នៅពេលដែល ចំណោទ ធំមួយ ត្រូវបានបំបែកទៅជាម៉ូឌុលតូចៗ និងសរសេរ ដោយឯករាកជ្យ។

ឧទាហរណ៏     ៖ គណនាអនុគមន៍គណិតវិទ្យាខាងក្រោម ៖

y = f(x) = f_ex(x) = x2 + bx + c

ដែលក្នុងនោះ x ជាចំនួនពិត ចំណែកឯ b និង c ជាចំនួនគត់ និងមាន ប្រើ f_ex

ជាឈេμាះរបស់អនុគមន៍។

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

#include <stdio.h>

#include <conio.h>

void main( )

{

float f_ex(float , int , int); /*ប្រកាសទំរង់អនុគមន៍មុនពេលប្រើវា */

float x = 1.5;

float y , z ;

int n = 3 , p = 5 , q = 10;

/*ហៅអនុគមន៍ f_ex ដើម្បីគណនា រួចហើយភ្ជាប់លទ្ធផលអោយអថេរ y  */

y = f_ex(x, n, p);

clrscr( );

printf(“Value of y = %f \n”, y); /* បង្ហាញតំលៃរបស់ y លើអេក្រង់  */

/*ហៅអនុគមន៍ f_ex ដើម្បីគណនា រួចហើយភ្ជាប់លទ្ធផលអោយអថេរ z  */

z = f_ex(x+0.5 , q , n – 1);

printf(“Value of z = %f \n”, z); /* បង្ហាញតំលៃរបស់ z លើអេក្រង់  */

getch();

}

/* ប្រកាសអនុគមន៍ – Declaring Function */

float f_ex(float x , int b , int c )

{

float value ; /* ប្រកាសអថេរដំបន់ */

2

/* គណនាអនុគមន៍ x +bx+c រួចយកលទ្ធផលភ្ជាប់អោយអថេរ value */value = x*x + b*x + c;

/*បោះតំលៃដែលកំពុងតែផ្ទុកក្នុងអថេរ value អោយទៅឈេμាះអនុគមន៍ */

return value ;

}

លទ្ធផលលើអេក្រង់គឺ ៖

Value of y = 11.750000

Value of z  = 26.000000

   វិភាគលើកមμវិធី  Prog5_1.C

អនុគមន៍ f_ex មានបីប៉ារ៉ាមែត្រសំរាប់យកទិន្នន័យចូល ទៅក្នុង តួអនុគមន៍។ មុនពេលហៅអនុគមន៍ប្រើ ជាដំបូងត្រូវសរសេរប្រកាស ទំរង់អនុគមន៍ (Prototype) នៅ ខាងដើមនៃកមμវិធីសិន (អាចក្នុង តួ អនុគមន៍ main ឬក៏អាចប្រកាសពីមុខ main ក៏បាន ដែរ) ដែលការ ប្រកាស នេះរួមមាន ឈេμាះរបស់អនុគមន៍ជាមួយប្រភេទទិន្នន័យ និងបណ្ដា

ប៉ារ៉ាមែត្ររបស់អនុគមន៍ (សំរាប់កមμវិធី Prog5_1.C នេះ ការប្រកាស ទំរង់អនុគមន៍ គឺនៅបន្ទាត់ float

f_ex(float , int , int); /*ប្រកាសទំរង់អនុគមន៍មុនពេលប្រើវា */ )។ ចំណែកឯការងាររបស់អនុគមន៍វិញយើងមិនទាន់ដឹងនៅឡើយទេ នៅខាងចុងនៃកមμវិធី

ទើបមានការប្រកាសអនគុមនព៍តិ  ប្រាកដ។ នៅក្នុងតួខ្លួនរបសអ់
នុគមន៍ main យើងបានហៅ អនុគមន៍ f_ex ចំនួនពីរដងជាមួយ Argument ផ្សេងៗគ្នា  ៖

*        ការហៅលើកទី 1 :

y = f_ex(x, n, p);

ក្នុងការហៅមួយនេះ Argument មានបីគឺ  x, n, p ដែល Argument ទាំងបីនេះ ត្រូវចំលងតំលៃអោយទៅប៉ារ៉ាម៉ែត្ររបស់ អនុគមន៍ តាមលំដាប់គឺ ៖
Argument x ចំលងតំលៃអោយទៅប៉ារ៉ាមែត្រ x របស់អនុគមន៍
Argument n ចំលងតំលៃអោយទៅប៉ារ៉ាមែត្រ b របស់អនុគមន៍
Argument p ចំលងតំលៃអោយទៅប៉ារ៉ាមែត្រ c របស់អនុគមន៍

*        ការហៅលើកទី 2 :

y = f_ex(x+0.5 , q , n-1);

ពេលនេះ Argument មានបីគឺ  x+0.5 , q , n-1 ដែល Argument ទាំងបីនេះ ត្រូវចំលងតំលៃអោយទៅប៉ារ៉ាម៉ែត្រ របស់អនុគមន៍ តាម លំដាប់គឺ ៖
Argument x+0.5 ចំលងតំលៃអោយទៅប៉ារ៉ាមែត្រ x របស់អនុគមន៍
Argument q ចំលងតំលៃអោយទៅប៉ារ៉ាមែត្រ b របស់អនុគមន៍
Argument n-1 ចំលងតំលៃអោយទៅប៉ារ៉ាមែត្រ c របស់អនុគមន៍
សរុបមកលំនាំនៃការហៅអនុគមន៍ f_ex មកប្រើក្នុងអនុគមន៍ main ត្រូវបានបង្ហាញ

បន្ថែមដោយរូបខាងក្រោម ៖
C C++C C++ចំណាំ   ៖     ចុងបន្ទាត់គμានសញ្ញាចុចក្បៀស (;) ទេ (គឺដូចគ្នាជា មួយការប្រកាស main ដែរ)

និងបណ្ដាប៉ារ៉ាមែត្ររបស់អនុគមន៍ត្រូវចែកដាច់ពីគ្នាដោយសញ្ញាក្បៀស (,) ។ កមμវិធីដែលអ្នកបានសរសេរតាំងពីមុនរហូតមកដល់ពេលនេះ សុទ្ធតែមានអនុគមន៍មួយជានិច្ចនោះគឺ main ដែលគμានប៉ារ៉ាមែត្រ និងក៏គμានសញ្ញាចុចក្បៀសនៅខាងចុងបន្ទាត់ដែរ។

ក្នុងតួខ្លួនអនុគមន៍ f_ex យើងឃើញថា អថេរដែលគេបានប្រកាស សំរាប់ ផ្ទុក លទ្ធផលអនុគមន៍ (អថេរ value) ត្រូវបានគេហៅថាជា អថេរ ដំបន់ (Local Variable)

ព្រោះអថេរនេះអាចប្រើបានតែនៅក្នុងខ្លួនរបស់អនុគមន៍ f_ex ប៉ុណ្ណោះ។ អថេរ value នោះត្រូវបានគេប្រើសំរាប់ផ្ទុក លទ្ធផល គណនារបស់កន្សោម  x*x + b*x +c ជាបណ្ដោះ អាសន្ន ដើម្បី ភ្ជាប់ លទ្ធផលនោះអោយទៅឈោμ ះរបស់អនុគមន៍តាមរយៈពាក្យគន្លឹះ return។ តំលៃរបស់អនុគមន៍មានអត្ថន័យដូចខាងក្រោម ៖

ឈេμាះអនុគមន៍ = តំលៃ

ឬមានន័យថា ៖

f_ex = តំលៃ = value

III. អនុគមន៍ក្នុងភាសា  C

+ parameter និង Argument

បណ្ដា parameter ប្រើនៅពេល Declaration Function ហៅថា parameter ។ បណ្ដា  parameter  ដែលផ្ដល់អោយ  Function  (ក្នុង  main   program)  នៅពេលយើងហៅ Function ហៅថា Argument ។ parameter ពិតអាចជាកន្សោមមួយក៏បាន, តែ parameter រូបភាពមិនអាចជាកន្សោមបានទេ ។

+ return Statement :

–  return : អាចផ្ដល់តំលៃនៃកន្សោមមួយទៅអោយឈេμាះ Function បាន ដូច្នេះ Function

ខាងលើអាចសរសេរជា ៖

/ * Declaration */

float f_Exam (float x, int b, int c)

{

return ( x * x + b * x + c );

}

បានន័យថាយើងមិនចាំបាច់ Declaration local Variable ទេ ។

–   return អាចសរសេរច្រើនដងក្នុង Function ។

Example :

double tt (double a, double b )

{ double s ;

s = a + b

if ( s> 0 ) return (s) ;

else return (-s);

}

–     បើប្រភេទរបស់កន្សោមក្នុង return ផ្ទុយពីប្រភេទរបស់ឈេμាះ Function នោះ Turbo C និង ប្ដូរ ប្រភេទសមមូលអោយវិញ ។

–     យើងអាចមិនប្រើតំលៃលទ្ឋផលរបស់ Function បាន ។ Example printf ( ), scanf ( ) ។

–     ករណី  Function   គμានតំលៃតបតវិញ     (តំលៃផ្ដល់អោយ ឈេμាះ     Function)   Function

មួយដែលគμានតំលៃ តបតវិញនោះយើងប្រើ Keyword void ដើម្បី Declaration វា ។

Example :

void Function_Name (int n);

–     Function ប្រភេទ Void នេះគμាន Statement return ទេ ។

–     ករណី Function គμាន parameter :

មាន Function មួយចំនួនគμាន  parameter ទេ ។ ដូច្នេះ Declaration Function នោះយើងប្រើ

Keyword void :

Ex: float Exam_para (void );

នៅមានករណីផ្សេងទៀតដូចខាងក្រោម ៖

void Exam_display (void )

បានន័យថា គμានតំលៃតបត, និងគμាន parameter ទេ ។

ចូរពិនិត្យបណ្ដា Example ខាងក្រោម ៖

# include <stdio.h>

# include <conio.h>

main ( )

{          /* prototype */

void          display_square ( int, int );

void          ONError (void );         /* have got a Error */

int             Start1 = 56, End1 = 10;

display_square (start1, End1);

if (…) ONError ( ); /* Error */

}

void display_square (int d, int f )

{ int i;

for ( i = d, i <= f; i ++ )

printf (“%d square root is %d \n”, i, i * i );

}

void          ONError (void )           /* Error */

{

printf (“*** Error *** \n”);

}

ករណី Function គμាន Declaration Value : នោះ Function, នឹងមានតំលៃ int ។

Ex: Declaration Function ដែលគμានប្រភេទ Function Name (float x );

IV.  Declaration និងបណ្ដា  ឧទាហរណ៏   ៖

+ លំដាប់ក្នុងការ declaration :

ពិនិត្យឧទាហរណ៌ខាងក្រោម ៖

Example :

# include <stdio.h>

# include <conio.h>

/* Declaration Function before Function main */

float f_Exam (float x, int b, int c)

{ float value ;   /* Declaration local variable */

value = x * x + b * x + c;

return (value );

}

main ( )

{

/* float f_Exam (float, int, int ); មិនបាច់មាន prototype ទេ */

float x = 1.5;

float y , z;

int    n = 3 , p =5, q =10 ;

y = f_Exam ( y, n, p ) ;

printf (” Value of y = %f \n”,y); z = f_Exam (x + 0.5, q , n-1); printf (“Value of y = %f \n”,z ); getch ( );

return (0)

}

+ Example គណនា n! = 1.2.3…. .(n-1).n

# include <stdio.h>

# include <conio.h>

long int factorial (int n)

{ int i;

long int FF = 1;

if (n>1 )

for (i = 2; i < =n; i ++) FF * = i;

return (FF);

}

main ( )

{ int n;

/* Read number n */

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

 

/* printf the result */

printf (“\n n! = %ld \n “, factorial (n) );

getch ( );

return (0) ;

}

+ Example : ប្ដូរពីអក្សរធមμតាទៅជាអក្សរពុម្ព,ដោយប្រើប្រមាណវិធីលក្ខខ័ណ្ឌ  ។

# include <stdio.h>

# include <conio.h>

char converttocapital (char ch )

{ char c2;

c2 = ( ch> = ‘a’ && ch < = ‘z’) ? ( ‘A’- ‘a’ + ch ): ch;

return (c2);

}

main ( )

{ char smallchar , capital;

clrscr ( );

printf (“Enter a character :”); scanf (“%c”, &smallchar );

capital = converttocapital (smallchar ); printf ( “\n the capital is %c \n \n”, capital); getch ( );

return (0 );

}

Example :   convert capitaltosmallchar : ( ដោយប្រើ if statement )

# include <stdio.h>

# include <conio.h>

char converttosmallchar (char ch )

{

if (ch > = ‘a’&& ch < = ‘z’)

return ( ‘A’ – ‘a’ + ch );

else

return (ch);

}

Example : អនុគមន៏សេស គូ ៖  កំណត់ចំនួនមួយ តើជាចំនួនសេស ឬ គូ

even (n)

int n;

{

int result;

if ( (n %2 ) = = 0)

result = 1;

else

result = 0;

return ( result );

}

ឬមួយកំណត់ចំនួនមួយជាចំនួនគូ ឬ ចំនួនសេស, យើងអនុវត្ដន៏ ប្រមាណវិធី AND តាម bit វិញ ៖

if ( (n&0 x 01 ) ==0 )

result = 0;

else

result = 1;

V. បញ្ចូល parameter  អោយ sub-program :

ការបញ្ចូល parameter អោយ Function ក្នុង Turbo C ត្រូវបាន អនុវត្ដន៏ តាមរបៀបតែមួយគត់ ៖

+  បញ្ចូល Value parameter, មានន័យថា តំលៃរបស់ parameter ពិត, មុននឹងក្រោយពេលហៅ Function នោះមិនប្រែប្រួលតំលៃទេ ។

ពិនិត្យឧទាហរណ៌ខាងក្រោម ៖

# include <stdio.h>

# include <conio.h>

main ( )

{ void swap ( int a, int b);        /* prototype */

int n = 10, p = 20;

printf ( “\n Before call Function : %d %d \n”, n, p);

swap ( n, p);

printf ( “\ n After call Function: %d %d \n”, n, p);

getch ( );

return (0);

}

void swap (int a, int b);

{

int t;

printf ( “Befor swap : %d %d \n”, n, b);

t = a; a = b; b = t;

printf (“After swap : %d %d \n”, a, b );

}

Before call Function :   10        20

Before swap     :           10        20

After swap       :           20        10

 

After call Function :     10        20   មិនប្រែប្រួលតំលៃ   បើធៀបនឹងតំលៃមុនពេល   Call

Function

+     វិភាគ  ៖  Function  swap  ទទួលតំលៃពីរពី  parameter  ពិត  (n,p)  ដែលសមមូល  និង parameter រូបភាពពីរទៀតគឺ (a, b) ។   វានឹងអនុវត្ដន៏ការប្ដូតំលៃពី parameter (a, b) ខាងលើ ។ តែបន្ទាប់ មកយើងឃើញថា នៅពេលត្រឡប់ទៅ main program វិញនោះ តំលៃ របស់ parameter ពិតទាំងពីរនៅដ៏ដែល ដោយមិនប្រែប្រួល តំលៃទេ (n,p ) ។

–   ដូច្នេះនៅពេល call sub program, តំលៃ n និង p នឹងត្រូវបាន បញ្ចូន ទៅអោយ parameter

រូបភាព  a,  b  ជាបណ្ដោះអាសន្នសិន, ហើយ Function  swap  នឹងប្ដូរតំលៃ a  និង  b  ជាមួយគ្នាដោយខ្ចី variable ជួយក្នុងការប្ដូរ តំលៃនេះ ។  បន្ទាប់មកតំលៃរបស់ n, p មិនត្រូវបានប្រែប្រួលទេ, នេះជាលក្ខណៈមិនតំរូវទៅតាមតំរូវការរបស់យើង ព្រោះយើង ចង់ប្ដូរ តំលៃ n និង p មិនមែនចង់ប្ដូរតំលៃ parameter រូបភាព a, b នោះទេ ។

–        យើងនិងឃើញថាការប្ដូរតំលៃនៃពីរ  (ឬច្រើន    )    parameter   ដោយប្រើ   Function អាចប្រព្រឹតទៅបាន តាមការបញ្ជូនជាតំលៃ Address របស់ parameter ពិតទៅអោយ parameter រូបភាព

(មិនមែនបញ្ចូល Value ទេ)។

នោះគឺក្នុងករណី Function scanf   ។   បើចង់ Read តំលៃ x យើងត្រូវប្រើ Address របស់ x ដើម្បីបញ្ជូនទៅអោយ Function  scanf : scanf ( “%f”, &x ); មុននិងក្រោយការ call Function scanf, តំលៃ Address  របស់  Variable  គμានប្រែប្រួល,  តែយើងប្រើតំលៃ Address នេះដើម្បីប្រែប្រួលតំលៃខាងក្នុងវា ។   យើងនិង និយាយ ឡើង វិញ  នូវបណ្ដាបញ្ហានេះ  នៅពេលយើងរៀន pointer  ។  តែ ដើម្បី អោយយើងចេះប្រើ  Function  swap  ដូច្នេះយើងសរសេរ  Function  នេះនៅក្នុង Chapter នេះទោះបីមានប្រើ pointer ក៏ដោយ ៖

Example :   សរសេរកមμវិធីប្ដូរតំលៃពីរ  Variable n,p ដោយប្រើការបញ្ជូន Value Address

ទៅអោយ Function :

# Include <stdio.h>

# Include <conio.h>

main ( )

{ void swap (int *a, int *b );

int n = 10; p = 20;

clrscr  ( ) ;

printf (” \n Before Call Function : %d %d \n”, n, p);

swap ( &n, &p);

printf ( “\n After Call Function : %d %d \n”, n, p );

getch ( );

return (0);

}

void swap (int *a, int *b)

{ int t.

printf ( “\n Before swap : %d %d”, *a, *b);

t = *a;

*a = *b;

*b = t;

printf (“\n After swap : %d %d”, *a, *b);

}

Before Call Function 10 20
Before swap 10 20
After swap 20 10
After Call Function 20 10

ពេលនេះទើបត្រូវបានប្ដូរតំលៃនៃ Variable n, p ពិតប្រាកដមែន ។

Note:*a  ជាសញ្ញានៃតំលៃដែលរក្សាទុកក្នុង Memory និង មាន Address a ។ &a ជាសញ្ញានៃ Address memory ផ្ទុកតំលៃ a .

IV. ដែនកំនត់របស់អថេរ  ៖អថេរក្រៅ   (Global Variable)

គឺជាអថេរដែលអាចអោយយើងប្រើប្រាស់បានគ្រប់ទីកន្លែងទាំងអស់ក្នុងកមμវិធី។ ចូរពិនិត្យមើលកមμវិធី Prog5_7.C ខាងក្រោម  ៖

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

#include <stdio.h>

#include <conio.h>

int n ; /*ប្រកាសអថេរក្រៅ n*/

void main()

{

void myfunction(void); /* ប្រកាសទំរង់ទូទៅរបស់ myfunction */

n = 1; /* ភ្ជាប់តំលៃអោយ  n = 1 */

clrscr();

/* ប្រើរង្វិល while ដើម្បីហៅ myfunction ចំនួន  4 ដង */

while(n<5) myfunction();

/* បង្ហាញតំលៃ  n ក្រោយពេលហៅ myfunction */ printf(“\nAfter called myfunction n = %d”, n); getch();

}

/* ប្រកាសរូបរាងពិតរបស់អនុគមន៍ */

void myfunction(void)

{

/* បង្ហាញតំលៃ  n លើអេក្រង់  */

printf(“\n The value of global variable n = %d”,n);

n++; /* បង្កើន  n ឡើងថែមមួយតំលៃទៀត */

}

លទ្ធផលលើអេក្រង់គឺ ៖

The value of global variable n = 1

The value of global variable n = 2

The value of global variable n = 3

The value of global variable n = 4

After called myfunction n = 5

ក្នុងកមμវិធី Prog5_7.C ខាងលើនេះមានអថេរ n ជាអថេរក្រៅ (Global Variable) ព្រោះវាត្រូវបានប្រកាសនៅ ខាងក្រៅ អនុគមន៍ ទាំងអស់ ដែលរួមទាំងអនុគមន៍ main ផងដែរ (គឺគμាន ស្ថិតនៅ ក្នុង អនុគមន៍ណាមួយឡើយ)។ ក្នុងនោះ អ្នកក៏បានឃើញដែរ ថា អ្នកមាន លទ្ធភាពអាចប្រើអថេរ n ក្នុងអនុគមន៍ myfunction ដោយគμាន កំហុសអ្វី ទាំងអស់ ដែលនេះគឺជាចំណុចល្អផង និងមិនល្អផង។ ចំណុច ល្អត្រង់ថា យើងអាចប្ដូរតំលៃ របស់អថេរនៅក្រោយពេលហៅ អនុគមន៍ មក ប្រើ និងមិនល្អត្រង់ថា ដោយសារតែភាពអាច ប្ដូរតំលៃ បាន នៅគ្រប់ទីកន្លែងបែបនេះហើយ ដែលអាចធ្វើអោយមានបញ្ហានៅ ពេលក្រោយ ជាពិសេសក្នុងកមμវិធីដ៏ធំមួយ បើសិនជាអ្នកប្រើ n នៅ ក្នុងអនុគមន៍ណាមួយ នោះ តំលៃរបស់  n នឹងមានការប្រែប្រួល ដែល នេះជាហេតុអាចឈានទៅដល់ការមាន កំហុសក្នុងកមμវិធី ដោយ ពុំបានដឹងថា តើតំលៃ n ពេលនេះត្រូវបានប្រែប្រួលដោយសារ អនុគមន៍ មួយណា។ ដែនកំនត់របស់អថេរក្រៅ ដែនកំណត់របស់អថេរ បានន័យថា ជាតំបន់ដែលអថេរនោះអាចមានសកមμភាពទៅ ដល់ បាន។ ដែនកំណត់របស់អថេរក្រៅគឺ ពេញកមμវិធីរបស់អ្នក ដោយគិត ចាប់ពីកន្លែងដែលបានប្រកាសអថេរនោះរហូតទៅដល់ខាងចុងបញ្ចប់នៃ កមμវិធី។

ឧទាហរណ៍ ៖

void main()

{

———-

———-

}

int n ; /* ប្រកាសអថេរក្រៅ */

float x ;

function1(—)

{

——–

}

function2(—)

{

——–

}

សំរាប់ពេលនេះយើងឃើញថា អថេរ n និង x អាចប្រើនៅក្នុង function1 និង  function2 បានតែពុំអាចប្រើនៅក្នុង main បាន ឡើយ ព្រោះវាត្រូវបានប្រកាសនៅខាង ក្រោយអនុគមន៍ main។ យើងអាចប្រកាសអថេរក្រៅនៅត្រង់កន្លែងណាមួយនៃកមμវិធីក៏បាន តែដើម្បីងាយស្រួលដល់ការពិនិត្យមើល និងស្វែងរក អ្នកសរសេរ កមμវិធី គួរតែប្រកាសអថេរក្រៅនៅខាង ដើមនៃកមμវិធី (ផ្នែកខាងលើ នៃកមμវិធី ដែលស្ថិតនៅក្រោមការប្រកាស header file)។

*        អថេរដំបន់   (Local Variable) ជាអថេរដែលមាន សកមμភាព (ឬអាចប្រើបាន) តែនៅក្នុងអនុគមន៍ដែលបានប្រកាស វាតែប៉ុណ្ណោះក្រោយពេលអនុគមន៍ត្រូវបានបញ្ចប់ នោះបណ្ដាអថេរ ដំបន់ដែលបានប្រកាស ក្នុងអនុគន៍នោះក៏ត្រូវបានរំដោះចេញពី Memory វិញដែរ។ចូរពិនិត្យមើលកមμវិធី Prog5_8.C ខាងក្រោមនេះ មានបង្ហាញអំពីការប្រើប្រាស់អថេរ ដំបន់ (Local Variable)។

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

#include <stdio.h>

#include <conio.h>

/* ប្រកាសអថេរក្រៅ */

int x;

float y = 5.5;

/* ប្រកាសទំរង់ទូទៅរបស់អនុគមន៍ */

void F1();

void F2();

void main()

{

clrscr();

x = 10;

printf(“x = %d y = %f”, x, y); F1();

F2();

printf(“\n\nAfter called functions x = %d”, x);

getch();

}

void F1()

{
printf(“\nCall in F1, x gloable = %d”, x);

printf(“\nCall in F1, y gloable = %f”, y);

}

void F2()

{    int a = 50;

printf(“\nCall in F2, a + x = %d + %d = %d”, a, x, a+x);

x = x + a; /* ផ្លាស់ប្ដូរតំលៃរបស់អថេរក្រៅ x */

}

លទ្ធផលលើអេក្រង់ ៖

x = 10 y = 5.500000

Call in F1, x gloable = 10

Call in F1, y gloable = 5.500000

Call in F2, a + x = 50 + 10 = 60

After called functions x = 60

ក្នុងកមμវិធីខាងលើយើងឃើញថា អថេរក្រៅ  x និង y អាចយកទៅ ប្រើបានគ្រប់ទី កន្លែង (បានគ្រប់ក្នុងអនគមន៍) ដោយឡែកអថេរដំបន់ a ដែលបានប្រកាសក្នុងអនុគមន៍ F2 វិញ ពុំត្រូវបានអនុញ្ញាតអោយ យក ទៅប្រើនៅក្នុងអនុគមន៍ផ្សេងដូចជា F1 ឬក៏ main បានទេ គឺអាចប្រើ បានតែក្នុងអនុគមន៍ដែលបានប្រកាសវាតែប៉ុណ្ណោះ ក្នុងករណី ឈេμាះ ដូចគ្នា  តើអថេរដំបន់អាចច្រឡំជាមួយអថេរក្រៅដែរឬទេ?

ដើម្បីបកស្រាយអោយសំណួរនេះ ចូរពិនិត្យមើលកមμវិធី Prog5_9.C ខាងក្រោម ដែលក្នុងនោះមានការប្រកាសអថេរ m និង n ជាអថេរក្រៅផង និងជាអថេរដំបន់របស់ អនគមន៍ផ្សេងៗទៀតផង។

/*—— កមμវិធី Prog5_9.C ——*/

#include”stdio.h”

#include”conio.h”

/* ប្រកាសអថេរក្រៅ n និង m */

int n = 20;

int m = 50;

void main()

{

/* ប្រកាសទំរង់ទូទៅរបស់អនុគមន៍ */

void fun1();

 

void fun2();

void fun3();

int m = 10; /* ប្រកាសអថេរដំបន់ m */

clrscr();

printf(“\nm in main = %d”, m);

fun1(); fun2(); fun3(); getch();

}

void fun1()

{

int m = 11;

printf(“\nm in fun1 = %d”,m);

}

void fun2()

{   int n = 30;

printf(“\nn in fun2= %d”,n);

}

void fun3()

{

printf(“\nm globle = %d”,m);

printf(“\nn globle = %d”,n);

}

លទ្ធផលលើអេក្រង់គឺ ៖ m in main = 10 m in fun1= 11

n in fun2 = 30 m globle = 50 n globle = 20 តាមរយៈ ឧទាហរណ៏ ខាងលើនេះ អថេរ n និង m ដែលបានប្រកាសក្នុងអនុគមន៍ fun1

គឺមានឥទ្ធិពលតែក្នុងអនុគមន៍នោះតែប៉ុណ្ណោះ បានន័យថាយើងពុំអាច យកអថេរទាំងនោះទៅប្រើនៅខាងក្រៅដែនកំនត់របស់វាបានឡើយ។ ក្នុងអនុគមន៍ fun1 និង fun2 មានប្រកាស អថេរ m ដូច្នេះពេល នេះ គ្រប់ឈេμាះ m ក្នុងអនុគមន៍ fun1 គឺជាអថេរដំបន់ របស់ fun1

មិន មែនជាអថេរដំបន់របស់អនុគមន៍ main ទេ ហើយក៏មិនមែន ជាអថេរក្រៅ ដែរ។ ដើម្បីជាការងាយយល់យើងអាចនិយាយថា នៅក្នុងស្រុកមួយមានមនុស្សបីនាក់ ដែលមានឈេμាះដូចគ្នាគឺ
“ក” តែរស់នៅផ្ទះផ្សេងគ្នាឧបមាថាផ្ទះ A, B និង C។ ដេូ ចះ្ន ប្រសនិ

បើក្នុងផ្ទះ  A មានការហៅឈេμាះ “ក” នោះប្រាកដជាសំដៅទៅ លើឈេμាះ “ក”  ដែលរស់  នៅក្នុងផ្ទះ A នោះហើយ គឺមិនមែន សំដៅ ទៅលើអ្នកដែលរស់ក្នុងផ្ទះផ្សេងនោះទេ។ ក្នុងកមμវធិីដចូ

ខាងលើ តើអថេរក្រៅ  m និងអថេរដំបន់ m អាចច្រឡំគ្នាបានដែរឬទេ? ការហៅឈេμាះ m មកប្រើក្នុងករណីនេះ ប្រសិនបើឈេμាះ m នោះបានប្រកាសក្នុង អនុគមន៍នោះនាំអោយវានឹងប្រើអថេរ ដំបន់ m នោះតែម្ដង (បានន័យថាពេល Compile វានឹងជំនូសកន្លែង m

ក្នុងអនុគមន៍នោះដោយអាសយដ្ឋាន Memory របស់អថេរដំបន់ m) ជាក់ស្ដែងដូចក្នុងអនុគមន៍ fun1 និង fun2។ ប្រសិនបើមាន ប្រើ ឈេμាះអថេរ m នោះ តែមិនបានប្រកាសក្នុងអនុគន៍នោះទេ នោះ Compiler នឹងពិនិត្យរកមើលថា តើឈេμាះ m នោះមាន ប្រកាស ជាអថេរក្រៅដែរឬទេ បើមានវានឹងប្រើអរថរក្រៅ m នោះ (ជាក់ ស្ដែង ដូច ក្នុងអនុគមន៍ fun3 មានប្រើអថេរ m និង n) តែបើគμានទេវានឹង ប្រាប់កំហុសភ្លាម (undefined symbol m in module…)។

*        អថេរដំបន់ស្ដាទិក   (Static local variable)

យើងអាចអោយកុំព្យូទ័រផ្គត់ផ្គង់ Memory ក្នុងដំបន់  Static អោយទៅ អថេរ ដំបន់ ដោយគ្រាន់តែប្រើពាក្យគន្លឹះ static ពីខាងមុខការ ប្រកាស អថេរ ដំបន់នោះតែប៉ុណ្ណោះ។ ពេលនេះទិន្នន័យ របស់អថេរ ដំបន់នោះ នឹងត្រូវបានរក្សាទុកក្នុង Memory រហូតទោះជា អនុគមន៍បាន បញ្ចប់ ក៏ដោយ។ ដើម្បីស្វែងយល់អំពីពាក្យគន្លឹះ static នេះអោយកាន់តែ ច្បាស់លាស់ នោះចូរមើលក្នុងចំណុចទី I.3 នៃមេរៀនទី  12 (ទំព័រទី 482)។កមμវិធី Prog5_10.C ខាងក្រោមនេះ បង្ហាញអំពីដំណើរការ របស់អថេរដំបន់ ស្ដាទិក (Static Local Variable)។

/*——— កមμវិធី Prog5_10.C ———*/

#include <stdio.h>

#include <conio.h>

void main()

{   void fun(void); /* ប្រកាសទំរង់ទូទៅរបស់អនុគមន៍ fun */

int n ; /* អថេររាប់រង្វិលជុំ for */

/* ប្រើរង្វិល for ដើម្បីហៅអនុគមន៍ fun ចំនួន  5 ដង */

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

fun();

getch( );

}

void fun(void)

{   static int i; /* ប្រកាសអថេរដំបន់ស្ដាទិក i */

i++;

printf(“\nCall in the %d time”, i);

}

លទ្ធផលលើអេក្រង់គឺ ៖

Call in the 1 time

Call in the 2 time Call in the 3 time Call in the 4 time Call in the 5 time

ក្នុងកមμវិធី Prog5_10.C ខាងលើនេះ អថេរ i ត្រូវបានប្រកាសជា អថេរដំបន់ ស្ដាទិកក្នុងអនុគមន៍ fun ដូច្នេះហើយបានជាយើងឃើញថា ការហៅអនុគមន៍ fun ចំនួន  5 ដងដោយអនុគមន៍ main

បានធ្វើ អោយ តំលៃរបស់អថេរដំបន់ស្ដាទិក i ប្រែប្រួលជានិច្ច (ដោយសារ Statement i++; ក្នុងអនុគមន៍ fun)។ ជាធមμតាចំពោះ អថេរដំបន់ក្នុង អនុគមន៍ណាមួយ ក្រោយពេលដែលអនុគមន៍ នោះ ត្រូវបានអនុវត្ដចប់ នោះបណ្ដាអថេរ ដំបន់របស់អនុគមន៍នោះក៏ត្រូវ បាន រំដោះចេញពី Memory ដោយស្វ័យប្រវត្ដិដែរ ឬបានន័យ ថា បណ្ដាទិន្នន័យដែលកំពុងតែរក្សាទុកដោយបណ្ដាអថេរដំបន់ទាំងនោះ ត្រូវបានបាត់បង់។ ចំពោះអថេរដំបន់ស្ដាទិកវិញ មានលក្ខណៈ ខុសពី អថេរដំបន់បន្ដិចត្រង់ថា Memory ដែលបានផ្គត់ផ្គង់អោយអថេរ ដំបន់ ស្ដាទិក នឹងពុំត្រូវបានរំដោះចេញវិញឡើយ ទោះបីជា អនុគមន៍ដែល បានប្រកាស អថេរដំបន់ស្ដាទិកនោះបានអនុវត្ដចប់ក៏ដោយ ឬបាន ន័យថាទិន្នន័យដែលត្រូវបានរក្សាទុកដោយអថេរដំបន់ស្ដាទិក នឹងពុំ ត្រូវ បាត់បង់ឡើយក្នុងខណៈដែលអនុគមន៍ដែល បានប្រកាស អថេរដំបន់ស្ដាទិកនោះពុំត្រូវបានអនុវត្ដក៏ដោយ ហើយកុំព្យូទ័រ នឹងរក្សាទុកទិន្នន័យនោះដរាបណាកមμវិធីទាំងមូលត្រូវបានបញ្ចប់។ ដូចដែលអ្នកបានឃើញ លទ្ធផលរបស់កមμវិធី Prog5_10.C ខាងលើនេះ នៅពេលដែល i ត្រូវបានប្រកាសជា អថេរដំបន់ស្ដាទិក និងមិនទាន់បានភ្ជាប់តំលៃកំណត់ណាមួយអោយវានោះ ពាក្យគន្លឹះ static និងភ្ជាប់តំលៃសូន្យអោយទៅ i ដោយស្វ័យ ប្រវត្ដិ លុះដល់ ពេលជួប i++; នោះតំលៃរបស់ i ត្រូវបានកើនឡើងមួយ តំលៃថែម ទៀត (ពេលនេះ i=1)។ ក្រោយការហៅអនុគមន៍ fun ដោយ main នៅជុំទីមួយ តំលៃរបស់  i ត្រូវបានប្រែប្រួលសេμី 1 លុះដល់ ពេល ជួបការហៅ ជាថμីទៀតនៅជុំទីពីរ តំលៃរបស់  i ក៏ត្រូវបូកថែម មួយ ទៀត  ដែលពេលនេះធ្វើអោយ i = 2 (ព្រោះក្រោយការហៅ លើក ទីមួយ i = 1) ហើយជាបន្ដបន្ទាប់នៅជុំទី 3, 4 និង 5 តំលៃ របស់ i ក៏ត្រូវបានកើនឡើងតាមលំដាប់គឺ 3, 4, 5 ដែរ។ តំលៃរបស់  i ពេលនេះគឺ 5 ហើយ  តំលៃនេះនឹងរក្សាទុកក្នុង Memory រហូត ដល់ ពេលដែលកមμវិធីបានបញ្ចប់។

 ចំណាំ  ៖ អថេរក្រៅអាចរក្សាទុកទិន្នន័យបានពេញដំណើរការនៃ កមμវិធី   ឬបានន័យថា  Memoryដែលបានផ្គត់ផ្គង់អោយ អថេរក្រៅ  ពុំត្រូវបានរំដោះវិញឡើយដរាបណាកមμវិធី  នៅតែដំណើរការ។

យើងអាចប្រើអថេរក្រៅបាននៅគ្រប់ទីកន្លែងទាំងអស់នៃកមμវធិ
ី ដោយ ចាប់ពីកន្លែងដែលបានប្រកាសវាទៅ។

*    អថេរដំបន់អនុញ្ញាតអោយប្រើបានតែនៅក្នុងតួអនុគមន៍ដែលបាន ប្រកាសវាតែប៉ុណ្ណោះ ហើយទិន្នន័យដែលវាបានរក្សាទុក នឹងត្រូវបាត់ បង់នៅពេលណាដែលអនុគមន៍ ដែលបានប្រកាសអថេរ ដំបន់នោះ បាន បញ្ចប់។*        អថេរដំបន់ស្ដាទិក   អនុញ្ញាតអោយយើងប្រើវាបាន តែក្នុង តួអនុគមន៍ដែលបាន ប្រកាសវាតែប៉ុណ្ណោះនិងទិន្នន័យ ដែលវា កំពុងរក្សាទុកពុំត្រូវបានបាត់បង់ឡើយ   គឺទិន្នន័យ    នោះនឹង ត្រូវបានរក្សាទុករហូតដល់ពេលណាដែលកមμវិធីទាំងមូលត្រូវបាន បញ្ចប់។

VII. លក្ខណៈ Recursion នៃ  Sub-program :

Function អាចហៅខ្លួនឯងមកប្រើបាន, លក្ខណៈនេះហៅថា Recursion ។

ឧទាហរណ៌ ៖ គណនាតំលៃ N!

n ! = 1. 2. 3….(n-1) . n

ឬតាមនិយមន័យ

n ! =
1      ពេល n = 0

(n-1) !.n

ពេល
 n >= 1

ដូច្នេះ Function Factorial អាចកំណត់ដូចខាងក្រោម ៖

int Factorial (int n )

{

if ( n ==0 ) return (1);

else return ( n* Factorial (n-1));

}

Example:

# include < stdio.h>

# include <conio.h>

long int Factorial (int n );          /* Function prototype */

main ()

{ int n ;

printf (“\n

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

printf (“ n! = %ld \n”, Factorial (n));

getch();

return (0 );

}

long int Factorial (int n)

{ if ( n == 0) return (1);

else return ( n* Factorial ( n – 1));

}

*Note :   លក្ខណៈ Recursion ត្រូវប្រើ memory   ប្រភេទ

ដើម្បីផ្ទុកលទ្ឋផល បណ្ដោះអាសន្ន ។

LIFO ( Last In, First Out, stack )

Example :  គណនា PGCD នៃពីរចំនួន x, y តាមនិយមន័យខាងក្រោម ៖

PGCD (x, y) = x         បើ y = 0

= PGCD (y, x/y)

ដូច្នេះ PGCD អាចគណនាដូចខាងក្រោម ៖

int PGCD (int x, int y)

{

បើ y < > 0

if ( y == 0) return (x) ;

else return (PGCD ( y, x %y));

}

តែ program ខាងក្រោមនេះមានល្អជាងខាង Algorithme, ទោះបីជាវាមានជាងក៏ដោយ ៖

int PGCD (int x, int y )

{ int number;

while ( y != 0)

/* សំណល់ */

{ number = x %y;

x = y;

y = number;

}

return (x);

};

+  ដូច្នេះយើងពុំគម្បីប្រើ Recursion នៅពេលដែលយើងអាចប្រើ looping ដើម្បីគណនាលំហាត់នោះ ។

 VIII.   ម៉ាក្រូ    (Macro)

ក្រៅពីអនុគមន៍ ភាសា C នៅមានអង្គកំណត់ទិស (Directive Compiler) មួយ ប្រភេទដែលអាចជួយ អោយយើង ចាកផុតពី ភាពសμុគសμាញ និងអាចសន្សំបាននូវពេលវេលា នោះ គីការប្រើម៉ាក្រូ។

VIII.1. និយមន័យ(Macro) ម៉ាក្រូអាចជាសំណុំនៃ Statement និងកន្សោម ដែលត្រូវបានតំណាងដោយឈេμាះ ណាមួយ។ ក្នុង លំនាំនៃការ Compile បើសិនជា Compiler បានជួបបណ ្ដា ឈេμាះ ម៉ាក្រូ នោះវានឹងជំនួសកន្លែងឈេμាះ ម៉ាក្រូនោះ ដោយបណ្ដា Statement ដើមរបស់វា រួចទើប  អនុវត្ដន៍ការ Compile ជាក្រោយ។


VIII.2. របៀបប្រើ  ម៉ាក្រូ    (How to Use Macro)

ទំរង់ទូទៅនៃការប្រកាសម៉ាក្រូ ៖

#define9ឈេμាះម៉ាក្រូ9បណ្ដុំនៃ Statementចូរពិនិត្យមើលបណ្ដាឧទាហរណ៍ខាងក្រោមនេះ សុទ្ធតែជាកមμវិធីបង្ហាញអំពីរបៀប ប្រើប្រាស់ម៉ាក្រូ។

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

#include <conio.h>

#include <stdio.h>

/* ប្រកាសម៉ាក្រូ Msg*/

#define Msg printf(“\nWelcome to you”)

/* ប្រកាសម៉ាក្រូ Ext*/

#define Ext “\nPress any key to exit the program !”

void main()

{

clrscr();

Msg;

printf(“\nHow to use macro in C”);

printf(Ext);

getch();

}

លទ្ធផលលើអេក្រង់គឺ ៖

Welcome to you

How to use macro in C

Press any key to exit the program !

នៅពេល C Compiler ចាប់ផ្ដើមការ Compile នោះជួបជាមួយ ការប្រកាសម៉ាក្រូ ពីរគឺ Msg តំណាងអោយឃ្លា printf(“\nWelcome to you”) និង Ext តំណាងអោយ “\nPress any key to exit the program !”។ នៅពេល Compile មកដល់ក្នុងអនុគមន៍ main

 

ក៏បានជួបជាមួយការហៅឈេμាះម៉ាក្រូមកប្រើគឺ Msg; និង printf(Ext);។ នៅពេល ជួប Msg នោះ Compiler ពុំទាន់  Compile ទេ វាត្រូវជំនួសសំណុំ Statement ដើមគឺ printf(“\nWelcome to you”); សិន (ដែលសំណុំ Statement ដែលបានជំនួសចូលពេល នេះគឺជា  Statement ដែលមានមុខងារបង្ហាញឃ្លា


“Welcome to you” លើអេក្រង់)  រួច ទេបី

Compile បន្ដទៀត។ ក្នុងខណៈដែល Compile

មកដល់ការប្រើម៉ាក្រូ Ext ពេលនោះ Compiler ក៏ត្រូវអនុវត្ដ ដូច ពេលជួបឈេμាះម៉ាក្រូមុននេះដែរ

គឺជំនួសឈេμាះ Ext ដោយសំណុំ Statement ដើម ដែលពេលនេះគឺ “\nPress any key to exit the

program !”។ ក្រោយ ពេលជំនួសចូលរួចទើប Compiler ធ្វើការ Compile Statement នោះ។

ដើម្បីកាន់តែ  ច្បាស់ថែមទៀតអំពីការជំនួសម៉ាក្រូដោយសំណុំ Statement ដើមនោះ ចូរពិនិត្យមើលរូប ខាងក្រោមនេះ ៖

ខាងក្រោមនេះជាកមμវិធីមួយទៀត ដែលបង្ហាញអំពីការ ប្រើ ម៉ាក្រូក្នុងទំរង់មួយប្រហាក់ប្រហែលទៅនឹងការប្រើអនុគមន៍។

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

#include <stdio.h>

#include <conio.h>

#define num 3

#define print(a) printf(“The result of calculation is %d”, a)

#define calculate(y) ((y)*(y)*(y))

void main()

{   int x , z ; /* ប្រកាសអថេរ x និង z */

x = num; /* ពេលនេះយើងបាន x = 3 */

z = calculate(x) ; /* ហៅម៉ាក្រូ calculate យើងបាន z = 27 */

 clrscr();

print(z) ; /* ហៅម៉ាក្រូ printf */

getch();

}

លទ្ធផលលើអេក្រង់គឺ ៖

The result of calculation is 27

នៅក្នុងកមμវិធី Prog5_12.C ខាងលើនេះមានការប្រកាសម៉ាក្រូចំនួនបីគឺ num, print(a) និង

calculate(y)។ កង្ន
អនុគមន៍ main ការហៅម៉ាក្រូលើកទីមួយគឺ x = num ដែលពេលនោះ Compiler

ត្រូវជំនួសកន្លែង num នោះដោយតំលៃ 3 រួចហើយក៏ភ្ជាប់ អោយទៅ x ទើបនាំអោយ x = 3។ ជាមួយម៉ាក្រូពីរទៀតគឺ ៖

1.     print(a)

Ö      នោះអង្គកំណត់ទិស #define នឹងបំលែងទៅជា

printf(“The result of calculation is %d”, a)

ឧបមាថាគេហៅម៉ាក្រូនេះប្រើដូចខាងក្រោម ៖

print(3)

ពេលនោះអង្គកំណត់ទិស #define នឹងបំលែងទៅជា ៖

printf(“The result of calculation is %d”, 3)

2.     calculate(y)

Ö      នោះអង្គកំណត់ទិស #define នឹងបំលែងទៅជា

((y)*(y)*(y))

ឧបមាថាគេហៅម៉ាក្រូនេះប្រើដូចខាងក្រោម ៖

calculate(3);

ពេលនោះអង្គកំណត់ទិស #define នឹងបំលែងទៅជា ៖

((3)*(3)*(3))

ពេលនេះយើងឃើញថា ជាមួយនឹងការប្រើម៉ាក្រូបែបនេះ គឺមាន លក្ខណៈប្រហាក់ ប្រហែលទៅនឹងការប្រើប្រាស់អនុគមន៍ដែរ ក៏ប៉ុន្ដែ ចូរកុំចាត់ទុកថា នេះគឺជាអនុគមន៍អោយ សោះ។ អ្នកក៏អាច ប្រកាសប្រើ ម៉ាក្រូបានដូចទំរង់ខាងក្រោមនេះ ៖

ឧទាហរណ៍ថា ៖

#define product(m, n) ((m)*(n))

ឧបមាថាក្រោយពេលប្រកាសរួច ក្នុងកមμវិធីអ្នកបានប្រើ ៖

result = product(x, y+1)

នៅពេលនោះអង្គកំណត់ទិសនឹងអោយ Compiler បំលែងទៅជា ៖

result = ((x)*(y+1))

ª    ចូរប្រយ័ត្នក្នុងការប្រើប្រាស់ម៉ាក្រូ    ៖

នៅខាងចុងបំផុតរបស់អង្គកំណត់ទិស #define គμានសញ្ញាចុចក្បៀស (;) ទេ។

*      អ្នកត្រូវសរសេរធាតុនីមួយៗនៅក្នុងរង្វង់ក្រចកអោយបាន ច្បាស់បើសិនជាមិនសរសេរក្នុងរង្វង់ក្រចកទេ នោះអាចនាំអោយ មានការជំនួសខុស។

ឧបមាថាអ្នកប្រកាស ៖

#define calculate(y) (y*y*y)

បន្ទាប់មកអ្នកមានហៅប្រើ ៖

calculate(a+b)

នៅពេលនោះអង្គកំណត់ទិសបានបញ្ជាអោយ Compiler បំលែងទៅជា ៖

a+b*a+b*a+b

ដែលលទ្ធផលនេះខុសពីការចង់បានរបស់អ្នក ពីព្រោះលទ្ធផល ដែលអ្នករងចាំគឺ ៖

(a+b)*(a+b)*(a+b)

ª      ម៉ាក្រូមួយចំនួនដែលគេច្រើនប្រើ   ៖

ក្នុងការសរសេរកមμវិធី មានម៉ាក្រូមួយចំនួនដែលតែង តែជួប ប្រទះញឹកញាប់ជាងគេ នោះ ត្រូវបានបង្ហាញនៅខាងក្រោមនេះ ៖

#define ESC 0x1B /* បង្កើតម៉ាក្រូ ESC តំណាងអោយ Key ESC ដេលមាន ASCII = 0x1B Hex

= 27 Dec*/

#define TRUE 1 /* បង្កើតម៉ាក្រូ TRUE តំណាងអោយ ភាពពិត របស់តក្ក */
#define FALSE 0 /* បង្កើតម៉ាក្រូ FALSE តំណាងអោយភាព មិនពិតរបស់តក្ក */
#define PI 3.14159 /* បង្កើតម៉ាក្រូ PI តំណាងអោយតំលៃ 3.13159 */

#define ON 1 /* បង្កើតម៉ាក្រូ ON តំណាងអោយសភាពបើករបស់ Transistor */
#define OFF 0 /* បង្កើតម៉ាក្រូ OFF តំណាងអោយសភាពបិទរបស់ Transistor */

 VIII.3. តើគួប្រើ   អនុគមន៍ ឬ  ម៉ាក្រូ

លក្ខណៈដូចគ្នារវាងម៉ាក្រូ   និងអនុគមន៍  ៖ការប្រើឈេμាះរបស់ អនុគមន៍ឬក៏ម៉ាក្រូ ធ្វើអោយអ្នកសរសេរកមμវិធីអាចធ្វើការងារ បាន យាង៉ដែលមិនត្រឹមតែសន្សំបាននូវពេលវេលលា ថែមទាំងអាច ជៀស វាងបានកំហុស មួយចំនួន និងម្យ៉ាងទៀតវាធ្វើអោយ កមμវិធី មាន លក្ខណៈ ងាយមើល ងាយយល់។ល។

*        ភាពខុសគ្នារវាងម៉ាក្រូ និងអនុគមន៍ច្រេនី

+     កមμវិធីដែលសរសេរជាមួយម៉ាក្រូ នោះត្រូវចំណាយ Memory សំរាប់  Code Segment ច្រើនជាងកមμវិធីដែល សរសេរជា មួយ អនុគមន៍  ពីព្រោះពេលជួបឈេμាះម៉ាក្រូ  នៅកន្លែងណា  នោះ Compiler នឹងជំនួសកន្លែងនោះដោយបណ្ដា Statement ដើម របស់ វា។ ដូច្នេះបើក្នុងកមμវិធីជួបឈេμាះម៉ាក្រូ n ដង នោះក៏ត្រូវជំនួស Statement ដើមរបស់វាចំនួន n ដងដែរ  ដែលនេះជាមូល ហេតុនាំ អោយក្រោយពេល Compile  រួច   កូដរបស់កមμវិធីមានប្រវែង  វែងជាងកមμវិធីដែលសរសេរជាមួយអនុគមន៍ ពីព្រោះ អនុគមន៍ ត្រូវបាន Compile តែម្ដងគត់  បន្ទាប់មកពេលជួបការហៅអនុគមន៍នោះ Compiler គ្រាន់តែជំនួសកន្លែងហៅឈេμាះ   អនុគមន៍នោះ ដោយ អាសយដ្ឋានក្នុង   Code   Segment របស់វាជាការស្រេច។

+      កមμវិធីដែលប្រើម៉ាក្រូដំណើរការលឿនជាងកមμវិធីដែលប្រើ អនុគមន៍បន្ដិចពីព្រោះវាគμានចំណាយពេលសំរាប់ការហៅ    ដូច កមμវិធី ដែលប្រើអនុគមន៍      (ចូរស្វែងយល់អំពីដំណើរការ របស់  CPU Instruction CALL នោះអ្នកនឹងបានឃើញថា នៅពេលហៅ  អនុគមន៍  តើ CPU ធ្វើការយ៉ាងដូចម្ដេច? អ្នកអាចរកមើលវាបានក្នុង បណ្ដាសៀវភៅនិយាយ អំពីភាសា Assembly)។

+      យ៉ាងណាមិញ   អ្នកគួរប្រើម៉ាក្រូតែជាមួយបណ្ដុំ  Statement   ងាយៗបានហើយ   បើបណ្ដុំStatement វែងពេក នោះ #define នឹងគμានឥទ្ធិពល (មិនអាចប្រើបាន) ឡើយ។

IX. Statement library របស់ function :ក៏ដូចជាបណ្ដាភាសាសរសេរកមμវិធីផ្សេងទៀតដែរ,    Turbo   C មានបណ្ដា   function ជាច្រើនដែលត្រូវបានកំណត់ និយមន័យជា ស្រេចក្នុង C ។ គេចែកបណ្ដា Function ទាំងនោះជាបណ្ដាក្រុមៗ ហើយទុកវាក្នុងបណ្ដា file header, ខាងក្រោមនេះ ជាបណ្ដា file standard library : stdio.h   library នៃបណ្ដា function Input / output math.h        library នៃបណ្ដា function គណិតវិទ្យា stdlib.h     library នៃបណ្ដា function update memory string.h    library នៃបណ្ដា function របស់ stringctype.h   library នៃបណ្ដា function convert character ។

 X. បណ្ដាអនុគមន៍ ដែលមានស្រាប់  (Build-in Function)
X.1. random function

+  Syntax : int  random (num) : ជា function បង្កើតបណ្ដាចំនួន Random នៅចន្លោះពី០ ដល់ num–1
+ Syntax : rand ( ): បង្កើតចំនួន Random នៅចន្លោះ ០ ដល់ 32767
+ Syntax : randomize ( ): ធ្វើអោយបណ្ដា function random ( ) និង rand ( )បង្កើតនូវបណ្ដា លេខផ្សេងៗគ្នា ។

Example :

# include <stdlib.h>

# include <stdio.h>

# include <time.h>

int main (void)

{ randomize ( ) ;

printf (” \n random in range ( 0 – 99 ): %d \n” random (100));

return (0);

}

X.2.

បណ្ដាអនុគមន៍   នៃរយៈពេល  (DateTime Function)
ជា បណ្ដា Function បង្កើតនិង Read រយៈពេល, បង្កើតនិង Read  ថ្ងៃ  – ខែ  ។  បណ្ដា Function

នេះផ្ទុក ក្នុង <DOS.H> ។

ក្នុង Turbo C កំណត់និយមន័យ ទំរង់របស់ថ្ងៃ, ខែនិងរយៈពេលដូច ខាងក្រោម ៖

* ថ្ងៃ, ខែ ៖

struct date

{

int year;           /* Current year */

char date;         /* date of the month */

char month;     /* month ( 1 = Jan ) */

};

void getdate ( struct date * datep );     (យកថ្ងៃ, ខែពី System )

void setdate (struct date * datep );      ( កំនត់ថ្ងៃខែ )

Example :  យកថ្ងៃ, ខែពី System របស់កុំព្យូទ័រ ៖

# include < dos.h>

# include <stdio.h>

# include <conio.h>

int main (void )

{ struct date d ;

getdate (&d) ;

printf (“The current year is %d \n”, d.da_year );

printf (“The current date is %d \n”, d.da_day );

printf (“The current month is: %d \n”, d.da_mon );

getch ( );

return (0);

}

Example :  កំណត់ថ្ងៃ, ខែអោយកុំព្យូទ័រ ៖

# include <process.h>

# include <conio.h>

# include < dos.h>

int main (void)

{

struct date reset ;

struct date save_date ;

getdate ( &save_date);

printf ( “day, month source : \n”);

system ( “date”);

reset.da_year = 2001

reset.da_day  = 1;

reset.da_month = 1;

setdate (&reset );

printf ( “day month have set : \n”);

system ( “date”);

setdate (&save_date );

printf (“return to day month source : \n”);

system ( “date”);

getch ( );

return (0);

}

Note: Function System ជា Function call statement DOS ។

Example : System (“dir”) ប្រើ call statement dir របស់ dos ។ Function ត្រូវ call :

# include <stdio.h>

# include <process.h>

10. c) ទំរង់ Variable នៃរយៈពេល និង បណ្ដា Function ដែលមានទំនាក់ទំនងជាមួយ struct time

{

unsigned char         /* minutes */

unsigned char

/* hours */

unsigned char ti_hund;            /*hundredths of seconds */

unsigned char ti_sec;               /* Seconds */

};

ជាមួយ Function Read និង set រយៈពេល ៖

void gettime (struct time * timep ); (Read រយៈពេល )

void  settime (struct time * timep); ( Set រយៈពេល )

Example : Function Read រយៈពេល ៖

# include <conio.h>

# include <stdio.h>

# include <dos.h>

int main (void )

{ struct time t ;

gettime (&t);

printf ( “Current time is : %2d : %02d : % 02d. %02d \n”), t.ti_hour, t.ti_min, t.ti_sec, t.ti_hund );

getch ( );

return (0 );

}

Example : Function set time:

# include <stdio.h >

# include <conio.h>

# include <dos.h>

int main (void )

{

struct time t ;

gettime (&t)

printf (“current minutes is %d \n”, t.ti_min); printf (“current hour is %d \n”, t.ti_hour); printf( “current seconds is %d \n”, t.ti_sec ); printf ( “hundredths of seconds \n”, t.ti_hund);

/* add 1 minute and call setting */

t.ti_min ++; settime (&t); getch ( ). return (0);

}

លំហាត់អនុវត្ដន៍

 

1/ ចូរសរសេរកមμវិធីដោយប្រើ Function, ដោះស្រាយ រឺសសមីការដឺក្រេទី ២ ax2 + bx + c = 0

Function សមមូលនឹងករណី delta positive, delta negative, delta zero ។

n n!
1 1
2 2
3 6
4 24
5 120
6 720
7

 

2/ ចូរសរសេរកមμវិធីដោយប្រើ Functin, សរសេរតារាង n! ដែល n = 1… 14 ក្រោយមកចូរសាកល្បងមើលប្រភេទ int តើអាចគណនាបាន ប៉ុនμានតួ ? បើ long int តើអាចគណនាបានប៉ុនμានតួ ?

3/ សរសេរកមμវិធីដោយប្រើ Function គណនា an ដែល a: Real; n : ជាចំនួនគត់វិជ្ជមាន, តាមពីររបៀប ៖

+   គណនាដោយផ្ទាល់, មិនចាំបាច់ប្រើ recursion
+    គណនាតាម recursion

4/  សរសេរកមμវិធីដោយប្រើ Function គណនាក្រលាផ្ទៃនៃបណ្ដាការ៉េ, រង្វង់, ចតុកោណកែង, ដោយបង្កើតជា

menu ដើម្បី select គណនាដូចខាងក្រោម ៖

0.   Exit program

1.   គណនាក្រលាផ្ទៃការ៉េ
2.   គណនាក្រលាផ្ទៃរង្វង់
3.   គណនាក្រលាផ្ទៃចតុកោណកែងឧ

“press select ”

5/   ចូរសរសេរ Function គណនា n! ក្រោយមកសរសេរកមμវិធី ពេញលេញដើម្បីគណនា ៖

Cnk = n! / ( k! * (n-k)!)

6/ បង្កើតស្វីត Fibonacci

ស្វីត Fibonacci ជាស្វីត F1, F2, F3, … Fn ត្រូវបង្កើតដោយប្រើរូបមន្ដ ៖

Fn  = Fn-1 + F n-2

ដែល F1 = 1, F2 = 1
ឧទាហរណ៌ 1, 1, 2, 3,5, 8, 13, 21

ចូរសរេសកមμវិធីដោយប្រើ  Function គណនា Maximum និង   minimum   នៃ 3ចំនួន Read

from Keyboard

8/ គេអោយអនុគមន៏    f(x,t)   = |a-b| (a³ + b-3)

ក្នុងនោះ

a = log3 (x² + Sin² (x) + |tg (x)| + s)b = ( ផ្នែកគត់របស់ y)

និង x,y ជា Variable ប្រភេទ Real ។

a.   ចូរសរសេរ Function គណនា f(x,y)
b.   គណនា f(x,y) ដែល x =1.234, y = 2. 345

9/     តើការបង្កើតអនុគមន៍ក្នុងការសរសេរកមμវិធី មានប្រយោជន៍យ៉ាងដូចម្ដេច?
10/    អ្វីទៅដែលហៅថា   ប៉ារ៉ាមែត្រ    និងអាគុយម៉ង់    (Argument)   ?    ចូរនិយាយ   អំពីការដោះដូរទិន្នន័យរវាងប៉ារ៉ាមែត្រ និងអាគុយម៉ង់។

11/   តើពាក្យគន្លឹះ return មានមុខងារដូចម្ដេចដែរ?

12/   ចូរអោយនិយមន័យទៅលើ ៖

*        អថេរក្រៅ (Gloable Variable)

ƒ      អថេរដំបន់ (Local Variable)

ƒ      អថេរដំបន់ស្ដាទិក (Static local variable)

13/   អ្វីទៅគឺជាម៉ាក្រូក្នុងភាសា C? តើម៉ាក្រូខុសពីអនុគមន៍ដូចម្ដេចដែរ?

14/   ចូរបង្កើតអនុគមន៍ដើម្បីដោះស្រាយប្រព័ន្ធសមីការពីរអញ្ញត្ដិខាងក្រោម ៖

ax by = c

dx ey = f

ក្នុងនោះ a, b, c, d, e, f គឺជាប៉ារ៉ាមែត្រដែលត្រូវបញ្ចូលតំលៃអោយវា។

 

 

 

= = = = = * = = = = =

មេរៀនទី៧: Array & Pointer

មេរៀនទី៨: Array & Pointer

I. Array : អថេរមួយអាចផ្ទុកបានតំលៃតែមួយគត់ នាំអោយ ដើម្បី ផ្ទុកតំលៃរបស់ស្វ៊ីតមួយ ឬតារាង មួយបានលុះត្រាតែយើង ប្រើច្រើន អថេរ ក៏ប៉ុន្ដែនៅពេលនោះវាមានលក្ខណៈសμុគសμាញខ្លាំង ណាស់។ ដូច្នេះដើម្បីជៀសវាងការ ប្រកាសអថេរច្រើន ដូចករណី ខាងលើ នោះគេប្រើ Array វិញ។
I.1. អ្វីទៅជា Array : Array   គីជាឈេμាះនៃសំនុំមួយដែល មាន ច្រើនធាតុ   និងធាតុនីមួយៗរបស់វាមាន ប្រភេទទិន្នន័យដូចគ្នា និងអាច ផ្ទុកបានតំលៃមួយរៀងៗខ្លួន។ ការប្រកាស Array ដើម្បីប្រើ ក៏មាន លក្ខណៈដូចការប្រកាសអថេរធមμតាដែរ តែត្រូវចាំថា  ប្រភេទ ទិន្នន័យរបស់ Array គឺជាប្រភេទទិន្នន័យរបស់ធាតុនីមួយៗនៃ Array។ Array ត្រូវបានប្រកាសតាមទំរង់ដូចខាងក្រោម ៖

ប្រភេទទិន្នន័យ   ឈេμាះរបស់ Array [ចំនួនធាតុរបស់ Array]; Datatype        VariableName[size of array];

ការប្រកាស Array អាចមានច្រើនវិមាត្រ អាស្រ័យទៅតាមដំរូវការ។ ដើម្បីស្វែង យល់អំពីវិមាត្ររបស់ Array ចូរពិនិត្យមើលឧទាហរណ៍ ខាងក្រោម ៖

int  a[10],  b[4][2];
float  x[5],  y[3][3];

ខាងលើនេះជាការប្រកាស Array ចំនួន  4 គឺ a, b, x, y ដែលមាន អត្ថន័យដូចខាង ក្រោម ៖

–     ចំពោះ  Array ទី 1 មានប្រភេទទិន្នន័យជា int, ឈេμាះ a, ចំនួនវិមាត្រគឺ 1, ចំនួនធាតុគឺ 10។

Array a មានធាតុ  10 គឺ a[0], a[1], a[2],…, a[9] ដែលធាតុ នីមួយៗនេះ នឹងត្រូវបានគេប្រើសំរាប់ផ្ទុកតំលៃមួយដែលមានប្រភេទ ជា int។ ដូច្នេះ  Array a ពេលនេះអាចផ្ទុកបាន 10 តំលៃប្រភេទ int។

–     ចំពោះ  Array ទី 2 មានប្រភេទទិន្នន័យជា int, ឈេμាះ  b, ចំនួនវិមាត្រគឺ 2, ចំនួនធាតុគឺ 4

គុណនិង   2   សេμី    8   (វិមាត្រទីមួយគុណជាមួយវិមាត្រទីពីរ)។   Array   b   មាន    8

ធាតុដូចខាងក្រោមគឺ ៖

b[0][0] b[0][1] b[1][0] b[1][1] b[2][0] b[2][1] b[3][0]         b[3][1]

ដែលធាតុនីមួយៗរបស់ b គឺ b[i][j] អាចផ្ទុកបានតំលៃមួយមាន ប្រភេទជា int។ ដូច្នេះ  Array b

អាចផ្ទុកចំនួនគត់ int បានចំនួន 4 ជួរដេក  និង 2 ជួរឈរ។

–     ចំពោះ    Array   ទី   3   មានប្រភេទទិន្នន័យជា    float,   ឈេμាះ        x,   ចំនួនវិមាត្រគឺ   1,

និងចំនួនធាតុមាន   5   គឺ    x[0],   x[1]…,x[4]។   ធាតុនីមួយៗ     x[i]   អាចប្រើសំរាប់ ផ្ទុកតំលៃប្រភេទទិន្នន័យជា    float    ដូច្នេះ     Array    x    ពេលនេះអាចផ្ទុកបានចំនួន   5

តំលៃចំនួនពិត float។

–    ចំពោះ    Array   ទី   4   មានប្រភេទទិន្នន័យជា    float,   ឈេμាះ        y,   ចំនួនវិមាត្រគឺ   2,

និងចំនួនធាតុមាន 9 គឺ ៖

y[0][0]    y[0][1]     y[0][2] y[1][0]     y[1][1]     y[1][2] y[2][0]   y[2][1]      y[2][2]

ពេលនេះ ធាតុនីមួយៗរបស់ y គឺ y[i][j] អាចផ្ទុកបានមួយតំលៃប្រភេទ float ដូច្នេះ  Array

y ទាំងមូលអាចផ្ទុកបានចំនួន 9 តំលៃចំនួនពិត float។

I.2. ការប្រើប្រាស់ Array :ដើម្បីយល់អោយបានច្បាស់អំពីការប្រើប្រាស់ Array យើងពិនិត្យ មើលឧទាហរណ៍ ខាងក្រោម  ៖
I.2.1. បញ្ចូលតំលៃ និង   អានតំលៃពី Array : Ex1:  Read បណ្ដាតំលៃទៅអោយ Array x ពី Keyboard

# include <stdio.h>

# include <conio.h>

# define SIZE 5 main ( )

{ int x [SIZE];

int i ;

for ( i = 0; i <=SIZE – 1; i ++ )

{ printf ( “x[%d] =”, i ); scanf (“%d”,&x[i]);

}

/* display Array on screen */ printf (“\n Display Array x : ”); for ( i =0; i <= SIZE –1; i ++)

printf ( “\n x[%d] = %d”, i, x[i]);

getch ( );

return (0);

}

x[0] = 12 x[1] = 34 x[2] = 56

Display Array x: x[0] = 12 x[1] = 34 x[2] = 56

ចំណាំ ៖ ការសរសេរកន្សោម <= SIZE – 1 និង < SIZE ក្នុង Loop for នោះមានន័យដូចគ្នា ។ យើងអាចសរសេរ Access data ទៅអោយ x នៅលើបន្ទាត់តែមួយបាន ៖

# include <stdio.h>

# include <conio.h>

# define SIZE 5 main ( )

{     int x[SIZE];

int i;

printf (“\n Enter Value into Array on the one line :”);

for ( i = 0; i <SIZE ; i ++)

{ scanf (“%d”, &x[i]); }
printf (“\n Display Array on screen : ”);

for ( i = 0; i <SIZE; i ++ )

printf (“\n x[%d] = %d”; i, x[i]);

getch ( );

retune (0);

}

Enter Value into Array on one line :

12         34         56

Display Array on screen :

x[0] = 12 x[1] = 34 x[2] = 56

Ex2: បូក One dimensional Array : C = A + B

# include <conio.h>

# include <stdio.h>

# define SIZE 5 main ( )

{     int A[SIZE], B[SIZE], C[SIZE];

int i; clrscr ( );

for ( i = 0 ; i <= SIZE – 1 ; i ++ )

{   printf (“A[%d] =”, i);

scanf (“%d”, &A[i]);

}

for ( i = 0; i <SIZE; i ++ )

{   printf (“\n B[%d] =”, i);

scanf (“%d”, &B[i]);

}

for ( i = 0; i <SIZE ; i ++ )

{ C[i] =A[i] + B[i] }

getch ( );

return (0);

}

I.2.2. កំណត់តំលៃអោយ  Array ជាមុន ៉

Array អាច Create Value អោយវាបាននៅពេលយើង Declaration :

int x[3] = { 7, 4, 5 } ;

មានន័យថាពេលយើង Declaration, នោះយើងតាងបណ្ដាតំលៃ អោយ Array តែម្ដង

x[0] = 7; x[1] = 4; x[2] = 5 ;

I.2.3. Array នៃ  Characters : បីប្រភេទ Declaration ខាងក្រោមនេះសមមូលនឹងគ្នា ។

char     text1 [5] = { ‘D’, ‘C’, ‘f’, ‘s’, ‘p’ };

char     text2 [5] = DCfsp”;

char     text3 [  ] = DCfsp”;

text[0] = ‘D’; text[1] = ‘C’; text[2] = ‘f’; text[3] = ‘s’; text[4] = ‘p’;

តែ Tucbo C ក៏ប្រើ Declaration Array of character ដូចគ្នានិង array of string  ។  string ក្នុង turbo C ត្រូវបាន បញ្ចប់ដោយ ធាតុចុងក្រោយមានតំលៃសេμី Character NULL, ជា character ដំបូងមាន Code = 0 in ASCII Table, ត្រូវតាងក្នុង Turbo C ដោយ សញ្ញា ‘\0’ ។ ដូច្នេះ text1, text2 មានគ្រប់លμម  ៥កន្លែងសំរាប់ 5 characters, ដូច្នេះនៅខ្វះមួយកន្លែងទៀតអោយ ‘\0’,

ដូច្នេះត្រូវ សរសេរឡើងវិញ

char     text1 [6] = { ‘D’, ‘C’, ‘f’, ‘s’, ‘p’ };

char     text2 [6] = DCfsp”; បើមិនចង់រាប់ទេចូល Declaration: char text3[ ] = “DCfsp”

Computer ផ្ដល់អោយយើង ៦ន្លែង, ៥កន្លែងសំរាប់ Characters និង ១កន្លែងសំរាប់សញ្ញា ‘\0’ ។

Ex3: Convert string ពីអក្សរតូចទៅអក្សរធំ ៖

# include <stdio.h>

# include <conio.h>

# include <ctype.h>

# define SIZE 80 main ( )

{

char text [SIZE];

int count;

for (count = 0; count <= SIZE –1; count ++ )

text[count] = getchar ( );

for (count = 0; count < SIZE; count ++ )

putchar (toupper (text[count]));

getch ( );

return (0);

}

 Ex4: រាប់ Characters:

ឧបមាយើងចង់រាប់ក្នុង  ១០០ដងនៃការចុចបញ្ចូល Character  ពី  Keyboard, ចំនួនលេចចេញនៃបណ្ដា character ពី ‘A’ ដល់ ‘Z’ មានប៉ុន្នាន ? Variable count ត្រូវបាន Declaration ខាងក្រោមនេះ

# include <stdio.h>

# include <conio.h>

# include <ctype.h>

# define SIZE 80 main ( )

{     char text[SIZE];

int i, count[‘Z’ – ‘A’ + 1];

clrscr ( );

for ( i = 0; i <SIZE; i ++ )

text [i] = toupper (getchar ( ) );

for ( count = 0; count <SIZE, count ++ )

putchar (text [count] );

for ( i = 0; i < ‘Z’ – ‘A’ + 1; i ++)

count [i] = 0;

for (i = 0; i < SIZE; i ++)

{ printf (“%d”, count [text [i] – ‘A’] );

count [text [i] – ‘A’] ++;

printf (“%d”, count [text [i] – ‘A’]); }

for ( i = ‘A’; i <= ‘Z’; i ++)

if (count [i – ‘A’] )

printf (“\n number of characters %c = %d”, i, count[i – ‘A’]);

getch ( );

return (0);

}

Note:   កមμវិធីខាងលើបើយើង  Run  កមμវិធីនោះយើងត្រូវ  Input  character រហូតដល់ 80  character

ទើបឈប់។ ដូចេμះ យើងគប្បីសរសេរកមμវិធីដោយអោយ Read character រហូតដល់ជួប Enter ទើបឈប់ ។

I.3. តំរៀប   Arrayការ Sort ធាតុ Array តាមលំដាប់កើន ឬចុះ មានសារៈសំខាន់ ក្នុង ការគណនា Array   ។   នេះជា Algorithm ដែលត្រូវរៀន ។ ខាង ក្រោមនេះនឹងអធិប្បាយពីរបៀបរៀបបណ្ដាធាតុរបស់ Array តាមឧទាហរណ៍ ៖

Ex5: Sort Array

# include <stdio.h>

# include <conio.h>

# include <math.h>

# define SIZE 5 main ( )

{     int x[SIZE];

int i, j, temp;

for ( i = 0; i <= SIZE –1; i ++ )

{   printf (“x[%d] = ”, i);

scanf (“%d”, &x[i]);

}

/* sort Array */

for ( i = 0; i < SIZE –1; i++)

for ( j = i +1; j < SIZE; j++ )

{   if (x [i] > x [j])

{   temp = x[i]; x [i] = x [j]; x [j] = temp

}

}

printf (“\n The Array After Sort: ”);

for (i =0; i < SIZE – 1; i++)

printf (“%7d”, x[i]);

getch ( );

return (0);

 

}

លទ្ឋផល Run program :

x[0] = -1 x[1] = 456 x[2] = 34 x[3] = -312 x[4] = -56

The Array After Sort :

ខាងក្រោមនេះជាកមμវិធី Sort Array ត្រូវបានសរសេរក្រោមរាង Function :

Ex6:

# include <stdio.h>

# include <conio.h>

# include <math.h>

# define SIZE 5

void Sort_Array ( int n, int x [ ] );

main ( )

{     int x[SIZE]

int i;

for ( i =0; i <SIZE; i++)

{   printf (“x[%d] = ”, i);

scanf (“%d”, &x[i] );

}

Sort_Array (size, x);

printf (“\n Array x : ” ); for ( i =0; i <Size; i++ ) printf (“%7d”, x[i] );

getch ( );

return (0);

}

void Sort_Array (int n, int x [ ] )

{     int temp, i, j;

for ( i =0; i < n – 1; i++)

for (j = i + 1; j < n; j++ )

{   if (x[i] > x[j] )

{      temp = x[i]; x[i] = x[j]; x[j] = temp;

}

}

return ;

}

ក្នុងឧទាហរណ៍ខាងលើយើងឃើញរបៀបបញ្ជូន Parameter ជា Array អោយទៅ Function ។ នៅពេល Declaration Function, យើងគ្រាន់តែបញ្ជូន Declaration Array ដែលមាន [ ] ដើម្បីបញ្ចូល Address ។ បើយើងបញ្ជូន Array មាន Index នោះមិនមែនជា Address គឺជា Value .

void Sort_Array (int n, int x[ ]) ;

នឹងពេល Call Function, យើងគ្រាន់តែបញ្ជូនឈេμាះ Array ប៉ុណ្ណោះ Sort_Array (size, x);

II. Pointer និង Linking with Array :

–   ចំនុចដែលត្រូវយកចិត្ដទុកដាក់ក្នុងឧទាហរណ៍ខាងលើគឺ ក្រោយពី Call Function Sort_Array, statement ដែល print លទ្ឋផល មកលើ Screen ស្ថិតនៅខាងក្រៅ Function Sort_Array   (ក្នុង main Function) តែនៅតែ print ត្រូវ ។  យើងដឹងថា parameter ដែលបញ្ជូនអោយ Function Sort_Array ជា Value parameter ។ តាមពិតចង់ print ត្រូវ យើងត្រូវតែសរសេរ statement ដែល print លទ្ឋផលនោះនៅក្នុង Function Sort_Array តែម្ដង ។នោះគឺដោយ សារតែឈេμាះ  Array ជា Address, បានន័យថា pointer point ទៅធាតុតំបូងរបស់ Array ។ ការយល់ពី អត្ថន័យរបស់ Array ក្នុង C ទាមទាអោយយើង ត្រូវមានគំនិតមូលដ្ឋានអំពី Pointer ។ យើងប្រើ បណ្ដាសញ្ញា Operator pointer និង Address ដូចខាងក្រោម ៖

* p ជាទិន្នន័យដែលផ្ទុកក្នុង Address p, និយាយមួយរបៀបទៀត p ជា memory ផ្ទុក address របស់ *p ឬជា Pointer point ទៅ Variable ផ្ទុកតំលៃ *p ។ &x ជា Address របស់ Variable x ។ pointer ជា Variable ផ្ទុក Address, គμានផ្ទុកតំលៃទេ ។ ឧបមាយើង Declaration variable x, p និង assignment ដូចខាងក្រោម ៖

int x = 15;     /* x ជា Variable មានតំលៃ = 15 */

int *p;          /* Declaration ទិន្នន័យជាចំនួនគត់មាន address គឺ p */

p = &x ;       /* p ទទួលតំលៃ address របស់ x */

ដំបូង pointer p គμាន Value ទេ, តែក្រោយពេលមាន assignment   p = &x នោះ p និង point ទៅ x ។ ពេលនោះ Pointer ជា Variable ផ្ទុក តំលៃ Address នៃ memory របស់ x ។ ហើយ p ខ្លួនឯងក៏មាន address   ផ្ទាល់របស់ខ្លួន   ដែរគឺ    &p  ។   តែ    address   របស់   p    យើងមិនយកចិត្ដទុកដាក់ទេ, តែយើងគិតទៅដល់ អត្ថន័យ memory គឺ address p ។ ចូរពិនិត្យរូបខាងក្រោម ៖ ។ ចូរយក ចិត្ដទុកដាក់អត្ថន័យ F0F4, គឺជាតំលៃសរសេរក្រោមរាង Hexa, សមមូលនិង  2 bytes ។ អ្នកមិនចាំបាច់ខ្វល់គិតថា តំលៃនោះ ប៉ុណ្ណា ទេក្នុងលេខគោលដប់ ។ ចំពោះ variable  p នោះ F0F4 ជាតំលៃ របស់ p ។ ចំពោះ x, វាជា address គឺ &x ។
C C++បើចង់ p ជា pointer point to variable x, ក្នុង program យើងត្រូវ Assignment p = &x; រំលឹកឡើងវិញបណ្ដាបញ្ហាដែល មានទំនាក់ ទំនងជាមួយ Array : ជាមួយ Declaration :

int x[SIZE];

នោះតាមពិត x ជា address នៃធាតុតំបូងរបស់ Array ។ យើងអាច សរសេរ x សមមូល នឹង &x[0]

Note : ចូលចំណាំចំនុចមួយគឺ មានតែឈេμាះរបស់  Array ទេដែលមានតំលៃ address, ពោលគឺ pointer ។ ចំណែកពេល  សរសេរធាតុរបស់  Array,  នោះឈេμាះរបស់  Array  ជាមួយ សញ្ញា  [  ]  ដែលមាន  Index, នោះវាជា Variable មួយ, មានន័យថា x ឬ x[ ] ជា variable pointer ចំណែក x[0], x[1] ជា Variable

ធមμតាវិញ ។

Ex: ពិនិត្យតំលៃបណ្ដា pointer

# include <stdio.h>

# include <conio.h>

main ( )

{     int  number ; int *pointer ; number = 10;

printf (“\n Address of number : %p”, &number );

printf (“\n value of number : %d”, number);

pointer = &number;     /* pointer point to number */

printf (“\n Address of pointer : %p”, &pointer );

printf (“\n value of pointer : %p”, pointer );

printf (“\n value have point to is : %d”, *pointer);

getch ( );

return (0);

}

The Result on screen :
Address of number : 8 EEA : OFFE Value of number :  10
Address of pointer : 8EEA : OFFA Value of pointer : 8EEA : OFFE Value have point to is : 10

&number number &pointer pointer

* pointer

+ format សំរាប់ print pointer គឺ %p ។

Ex : របៀប Declaration និងប្រើប្រាស់ pointer :

static char  *msg = “rose”;

C នឹងផ្ទុក String នៅក្នុង Array រួមមាន៥ធាតុ ។ ជាមួយនោះ C ក៏រៀបចំ memory ដើម្បីផ្ទុក pointer msg ។ pointer នេះនឹងត្រូវបានចាត់ទុកដូចជា Variable មួយ, ដូច្នេះវាក៏អាចប្រែប្រួលតំលៃបាន ។ ចូលពិនិត្យ Looping ខាងក្រោម ៖

while ( *(msg) != ‘\0’)

putchar (* (msg++));

ជាមួយ Declaration

Void Sort_Array (int n, int x[ ]);

យើងយល់ថា  parameter x[ ] ជា Address របស់ Array x, គឺជា Address នៃធាតុតំបូងរបស់  Array ។ Address នេះមុននិងក្រោយ Function Sort_Array ( ) អនុវត្ដន៍, វាមិនប្រែប្រួល ។   Function នឹងធ្វើអោយប្រែ ប្រួល អត្ថន័យផ្ទុកត្រង់ Address   x, មិនមែន ធ្វើ អោយ ប្រែប្រួល Address x ទេ ។ ចូរពិនិត្យបណ្ដាឧទាហរណ៍ ខាង ក្រោម ៖

Ex 10:

# include <stdio.h>

# include <conio.h>

main ( )

{     int Array [4], *ptr1, index;

float Value [4], *ptr2;

ptr1 = Array;

ptr2 = Value;

for (index = 0; index < 4; index ++ )

printf (“base + %d : %10d %10d \n”, index, ptr1 + index, ptr2 +index );

getch ( );

return (0);

}

លទ្ឋផលនឹង print មកពី Screen ដូចខាងក្រោម ៖

base + 0 : ^^^^^ 12345 ^^^^^ 31890

base + 1 : 346 913
base + 2 : 36 345
base + 3 : 28934 12891

ជាមួយ Declaration :

float value[4] , *ptr2;

Note:   យើងដឹងថា Value (array ផ្ទុក Value ) ជា Array មាន ៤ធាតុហើយ Value ជា Address របស់ធាតុតំបូង ។  *ptr2 មាន ន័យ ថា ptr2 ជា pointer point ទៅ float, *ptr2 ជា Variable មាន ប្រភេទ float, ត្រូវបានផ្ទុកក្នុង memory, មាន Address គឺ ptr2 ។ ឈេμាះ Array អាចសរសេរដោយគμានសញ្ញា [ ]

បាន, នោះគឺ Address នៃធាតុតំបូង ។

ptr1 = Array;    /*ptr1 point to Array */

+ មានចំនុចមួយដែលត្រូវយកចិត្ដទុកដាក់, គឺ ក្នុង Turbo C, Variable pointer ត្រូវកើនឡើង ១ និងមិន កើនតំលៃ Address ឡើង១ទេ, តែវា កើនឡើងទំហំសមមូលនឹងទំហំទិន្ឋន័យដែលវា point ទៅនោះ។ បើ យើង សរសេរ ptr2++ នោះវានិងកើនឡើង ៤ ព្រោះប្រភេទ float មាន ទំហំ 4 byte ។ ក្នុងឧទាហរណ៍ខាងលើ ៖

Array + 2 = = &Array[2]

*(Array +2) = = Array[2]

 ប្រមាណវិធីអនុវត្ដន៍ជាមួយ pointer :

មានតែប្រមាណវិធីខាងក្រោមទេដែលអនុវត្ដន៍ជាមួយ pointer បាន ៖

– ប្រមាណវិធី Assignment (=)

–     ប្រមាណវិធីប្រៀបធៀប (= =) ឬ ( != )

+  ប្រមាណវិធីកើនថែម Address : ដូចក្នុងឧទាហរណ៍ខាងលើ យើងមានប្រមាណវិធីគណនា Array + 2 នោះគឺ យើងត្រូវ យល់ ថាប្រមាណវិធីកើនថែម Address, ឡើង២ធាតុទៀត, គឺមិនមែនកើន Value ឡើង 2ទេ។

+   បណ្ដាតំលៃរបស់ Variable pointer, មិនអាច Read   from Keyboard បានទេ ។ តែយើងអាច Print វាមក លើ Screen ដោយត្រូវ Format %p ។

Constant NULL : NULL ជាតំលៃ Const ពិសេសមួយប្រើអោយ បណ្ដា Variable pointer ហើយវាត្រូវបានប្រើដើម្បីបញ្ជាក់ថា គμាន point ទៅណាទាំងអស់  ។ NULL អាចតាងអោយគ្រប់ Variable ប្រភេទ pointer បានទាំងអស់ ។ NULL ជា pointer ពិសេសមួយ ផ្ទុកតំលៃ ០ ។ ឧទាហណ៍ Declaration NULL ដូចខាងក្រោម ៖

int n = 0, *pn = NULL;

 III. Array  ច្រើនវិមាត្រ  (Multidimensional Array) :

Multidimensional Array, ជា Array ដែលមានបណ្ដាធាតុច្រើន Rows, ច្រើន Columns។ Ex:   int x[3] [5]; បានន័យថា Array ផ្ទុកបណ្ដាចំនួនគត់, មាន 3 Rows, 5Colunm ។ បណ្ដាធាតុ Array ត្រូវបានកំណត់

Index ដូចរូបខាងក្រោម ៖
C C++Ex: Access ធាតុ Array x[1,3]; x[i +1, J +3] … Ex: Declaration Array ផ្សេង

float x [3] [5];

char x [3] [5];

 បង្កើនតំលៃអោយ Multidimensional Array : Multidimensional Array អាចបង្កើតតំលៃដំបូងបាន ។ Ex:  int x[3,2] = {(1,2), (3,4), (5,6) };

int x[3,2] = {1, 2, 3, 4, 5, 6};

បណ្ដាឧទាហរណ៍ ៖

Ex1: program គុណ matrix ការ៉េពីជាមួយគμា ៖

C = A * B

បណ្ដាធាតុនៃ Array C, ត្រូវគណនាតាមរូបមន្ដ ៖

n

Cij  = ∑ Aik  * Bkj

k =1

# include <stdio.h>

# include <conio.h>

# include <math.h>

# define N 3 main ( )

{     int i, j, k;

int A[N][N],B[N][N], C[N][N];    /* Matrix */

/* Read data into Array A */

for (i = 0; i <N; ++i)

for ( j = 0; j < N; j++)

{   printf (“A[%d, %d] =”, i, j );

scanf (“%d”, &A[i][j]);

}

/* Read data into Array B */

for ( i = 0; i < N; i++)

for ( j = 0; j < N; j++)

{   printf (“B[%d, %d] =”, i, j );

scanf (“%d”, &B[i][j]);

}

/* C = A * B */

for ( i = 0; i < N; i++ )

for ( j = 0; j < N; j++)

{   C [i][j] = 0;

for ( k = 0; k < N; k++ )

C [i][j] = C [i][j] + A[i][k] * B[k][j];

}

/* Display Result on screen */

for ( i = 0; i < N; i++ )

{   for ( j = 0; j < N; j++ ) printf (“%4d”, C [i][j]); printf (“\n”);

} getch ( ); return (0);

}

Note:  របៀបម្យ៉ាងទៀតយើងមិនចាំបាច់ Read data into matrix ទេ, ចូរពិនិត្យកំណាត់កមμវិធីខាងក្រោម យើង បង្កើតចំនួន Random ហើយតាងចំនួន Random ទាំងនោះទៅអោយធាតុ Matrix :

for ( i = 0; i < N; i++ )

for ( j = 0; j < N; j++ ) A[i] [j] = rand ( );

ក្នុងនោះ Function rand ( ) ជា Function បង្កើតចំនួន Random ។

Ö     កមμវិធីខាងលើយើង Declaration N = 3, យើងអាចប្រែប្រួលតំលៃរបស់ N បាន ។

Ex 2: បូកពីរ Matrix ជាមួយគ្នា ៖

C = A + B

យើងប្រើរូបមន្ដ ៖  C[i][j] = A[i][j] + B[i][j]

ឧទាហរណ៍នេះអធិប្បាយរបៀបផ្សេងក្នុងពេលសរសរេកមμវិធី, គឺរបៀបដែលមានលក្ខណៈគ្រប់គ្រាន់ជាងមុន ។

ដោយរបៀបខាងក្រោម ៖

–     Matrix A និង B ត្រូវមានធាតុដូចគ្នា ៖ (Rows <= 20, Column <= 30 )

–     Read Value into Array

–     Display the Result on screen

# include <stdio.h>

# include <conio.h>

# define Max_Row 20

# define Max_Column 30

void read_input ( int a[ ][Max_Column], int num_Row, int num_Col );

void Sum (int a[ ][Max_Column], int b[ ][Max_Column], int c[ ][Max_Column], int num_Row, int num_Col );

main ( )

{     int numRow , numCol ;

int   a[Max_Row][Max_Column],b[Max_Row][Max_Column], c[Max_Row][Max_Column];   printf   (“Number   of   Rows   :”);   scanf   (“%d”,

&num_Row );

printf (“Number of Column :”); scanf (“%d”, &num_Col);

printf (“\n\n Array A :\n”);

read_input (a, num_Row, num_Col );

printf (“\n\n Array B :\n”);

read_input (b, num_Row, num_Col ); sum (a, b, c, num_Row, num_Col ); printf (“\n\n sum of 2 matrix : \n\n”);

write_output ( c, num_Row , num_Col); getch();

}

*/ Function Read Array integer */

void read_input (int a[ ][Max_Col], int m, int n)

{     int i, j;

for (i = 0; i <m; i++)

{   printf (“\n please input data %2d \n”, i + 1);

for ( j = 0; j <n; ++j)

scanf (“%d”, &a[i][j] );

}

return ;

}

/* Calculate sum of to Array intege */

void sum ( int a[ ][Max_Column], int b[ ][Max_Column], int c[ ][Max_Column], int  m, int n)

{     int i, j;

for ( i = 0; i , m; i++)

for (j = 0; j < n; ++j )

c[i][j] = a[i][j] + b[i][j];

return ;

}

/* Display the Result on screen */

void write_output ( int a[ ][Max_column], int m, int n)

{     int i, j;

for ( i = 0; i <m; i++ )

{     for ( j = 0; j <n; ++j ) printf (“%4d”, a[i][j] ); printf (“\n”);

}

return ;

}

ឧបមាយើងត្រូវបូក 2 Matrix :

Matrix A                                         Matrix B

1 2 3 4

10

11 12 13
5 6 7 8

14

15 16 17
9 10 11 12

18

19 20 21

នោះវានិង Display the result on screen

លំហាត់

បណ្ដាលំហាត់ខាងក្រោមគប្បីសរសេរជា Function :

1)  សរសេរកមμវិធី ដោះស្រាយប្រព័ន្ឋសមីការខាងក្រោមៈ

a11 . x + a12 . y = C1

a21 . x + a22 . y = C2

2) សរសេរកមμវិធី បង្កើតតារាងមេលេខគុណ

3)  បង្កើត Matrix X[1..10] [a..10]

a.   សរសេរកមμវិធីបង្កើត 1០០ តំលៃ Random ស្ថិតនៅបន្លោះតំលៃពី 1..10 ។

b.   គណនាផលបូកនៃបណ្ដាធាតុស្ថិតនៅលើអង្កត់ទ្រូង

c.   គណនាផលបូកការេនៃបណ្ដាលេខនៅលើ Column គូ

d.   គណនាផលបូក រឺសការ៉េនៃបណ្ដាលេខនៅលើ Column សេស

e.   តើមានប៉ុនμានធាតុនៃ Array, ដែលមានតំលៃស្ថិតនៅចន្លោះ 4..6

4) សរសេរកមμវិធីគណនាផលបូកការ៉េនៃបណ្ដាចំនួនអវិជ្ជមានក្នុង Array Integer ។

5) សរសេរកមμវិធីរកចំនួនធំបំផុត និងចំនួនតូចបំផុតនៃ Array R ដែលមានចំនួន ១៥ចំនួនពិត ។

6 )   សរសេរកមμវិធីដោះស្រាយប្រព័ន្ឋសមីការខាងក្រោម ៖

A11 . X + A12 . Y + A13 .Z = U1 ; A21 . X + A22 . Y + A23 .Z = U2 ; A31 . X + A32 . Y + A33 .Z = U3 ;

7 ) សរសេរកមμវិធីដោយប្រើ Sub-program, គុណ Matrix និង Matrix

–     Matrix A មានធាតុ ៖ N * L

–     Matrix B មានធាតុ ៖ L * M

–     Matrix C មានធាតុ ៖ N * M

8) សរសេរកមμវិធីធ្វើការងារខាងក្រោម ៖

a.   Read បញ្ចូល N ចំនួនគត់ពី Keyboard, N>5  ។ មាន Path ច្បាស់លាស់ក្នុងពេល Read ។

b.   រៀបបណ្ដាលេខដែលមានតំលៃធំជាង ១០ទៅខាងដើម ។

c.   ចូរលុបធាតុទី៣ របស់ Array និងធាតុទី n ។ សរសេរលទ្ឋផលមកលើ Screen

9) សំនួរបន្ថែម ៖

1) តើត្រូវការប៉ុនμាន byte សំរាប់ប្រើអោយការ Declaration ដូចខាងក្រោម ៖

char ch [ ] = “A”;

a. 0
b. 1
c. 2
d. 3

10) តើត្រូវការប៉ុនμាន byte សំរាប់ប្រើអោយការ Declaration ដូចខាងក្រោម ៖

char ch [ ] = “A”;

a. 0 b. 1 c. 2 d. 3

11) បន្ទាត់ទីពីរនៃលទ្ឋផលក្រោយពីយើង Run program :

# include <stdio.h>

main ( )

{     static char msg [ ] = “Hello!” ;

char * msgptr; msgptr = msg; puts (++msg); puts (msg);

msg [3] = ‘\0’;

puts (msg);

}

a.   Hello

b.   Welcome c.   ch

d.   គμាន  a, b, c. កមμវិធីមានកំហុស

12) បន្ទាត់តំបូងនៃលទ្ឋផលរបស់មμវិធីខាងក្រោម ៖

# include <stdio.h>

main ( )

{     static char msg [ ] = “Hello!”

char * msgptr;

msgptr = msg + strlen (msg);

while ( – – msgptr >= msg )

puts (msgptr );

}

a.   0 b.  lo c.       H

d.   គμាន  a, b, c. កមμវិធីមានកំហុស

13) ក្នុងកមμវិធីខាងក្រោម, តើមានប៉ុនμាន byte ប្រើអោយការ Declaration ខាងក្រោម ៖

char  *ptr = “C”;

a. 0 b. 1

c. 3 ( 1សំរាប់ pointer, 2 សំរាប់ data )

d. 4( 2 សំរាប់ pointer, 2 សំរាប់ data )

 14) តើតំលៃរបស់ *ptr ក្នុងឧទាហរណ៍ខាងក្រោម ៖

char *ptr;

static char msg[ ] = “Test”;

ptr = msg [0];

a.   មិនកំណត់បាន

b.   T

c.   Address របស់ character ដំបូង

d.   គμានចំលើយណាត្រឹមត្រូវទេ

15) តើតំលៃរបស់ *(ptr + 2) ក្នុងឧទាហរណ៍ខាងលើ

a.   មិនកំណត់បាន

b.   T

c.   Address របស់ character ដំបូង

d.   s

16) Declaration ptr ជា pointer នៃ Array 20 character

a.    char ptr[20];

b.    char (*ptr) [20];

c.    *(ptr[20]);

d.    គμានចំលើយណាត្រឹមត្រូវទេ

17) Declaration ជា Array នៃ 20 pointer point to Array

a.    char ptr [20];

b.    char (*ptr)[20];

c.    *(ptr [20]);

d.    គμានចំលើយណាត្រឹមត្រូវទេ
18)   សញ្ញាណាជាធាតុទី៣ របស់ Array msg ដែលមាន 4 characters a.        msg [3]

b.   msg [2] c.       *msg [3] d.   msg [4]

19) សញ្ញាណាជា pointer របស់ធាតុទី៣ របស់ Array msg មាន 4 characters a.        *(msg + 3)

b.   *(msg + 2)

c.   *msg + 3 d.   *msg + 2

20)  បើមាន Declaration ដូចខាងក្រោម ៖

char msg [10];

char value;

តើឃ្លាខាងក្រោមណាមួយដែលត្រឹមត្រូវ ?

a.   msg [2] = Value;

b.   msg = Value;

c.   ឃ្លាទាំងពីរខាងលើត្រឹមត្រូវ

d.   គμានចំលើយណាត្រឹមត្រូវ

21) បើមាន Declaration ដូចខាងក្រោម ៖

char *ptr; char [10]; char Value;

ឃ្លាខាងក្រោមនេះត្រឹមត្រូវ ៖

a.   ptr = Value;

b.   ptr = msg;

c.   ឃ្លាទាំងពីរខាងលើមិនត្រឹមត្រូវ

22) Pointer point to array មាន 3 character គឺ ៖

a.   (*ptr) [4]; b.   (*ptr) [3]; c.    (*ptr [4]); d.   (*ptr [3]);

 

23) តំលៃលទ្ឋផលជាមួយ

static char msg [ ] = “Test”;

printf (“%d”, strlen (msg) );

គឺ ៖

a. 0
b. 6
c. 5
d. 4

 

មេរៀនទី៨: String & Text

មេរៀនទី៨: String & Text

I.    តើ String គឺជាអ្វី ? String គឺជាស៊េរីនៃ Character ដាក់ក្នុង ចន្លោះ សញ្ញា double quote (“ ”) ដែល មានរាប់បញ្ចូលទាំង Space និងសញ្ញាពិសេសផ្សេងៗ (‘\0’) ទៀត រាល់ពេលយើងបញ្ចេញឃ្លាមួយ លើ អេក្រង់ដោយប្រើ printf(), គឺយើងបានអោយ និយមន័យឃ្លា នោះ ថាជា String Constant។
ឧទាហរណ៍ដូចជា ៖
printf(“This is a string.”);

printf(“UC”);

printf(“UNIVERSITY”);

បណ្ដា  Character របស់ String មួយ ត្រូវបានផ្ទុកក្នុង Byte Memory មួយដោយ  តំលៃ ASCII របស់ Character នោះ។ ASCII របស់ Character នីមួយៗ ត្រូវបានដំរៀប ជាប់ៗគ្នា ពីមួយទៅមួយក្នុង Memory និងពេលចប់ String នោះក្នុង  Memory ត្រូវផ្ទុក ‘\0’ ដែលជាសញ្ញាបញ្ចប់ String។ ចូរពិនិត្យមើលថា តើ String Constance នៃឧទាហរណ៍ទាំង 3 ខាងលើត្រូវបានទុកក្នុង Memory យ៉ាងដូម្ដេច? ចូរមើលក្នុងរូប ខាងក្រោម  ៖

 C ប្រើសញ្ញាពិសេស (\0) ដែល  S  μីសូន  សញ្ញ   String ដូច្នេះការរក្សា    មួយនៅក្នុង Memory នោះចំនួន Byt    តូវប្រើ      តែលើស  ចំនួន  Character នៃ String មួយ

ឧទាហរណ៍ ៖
#include “stdio.h”
#include “conio.h”
void m

{

pr  0 is   d to  inate   ing”); printf(“The character to t        ate     ng is    e end    trin getch();

}

លទ្ធផលលើអេក្រង់គឺ ៖

The character

The character to terminate a string is at the end of string

បន្ទាត់ទី  1 វាបង្ហាញតែ The character ព្រោះតែមានសញ្ញាបញ្ចប់ String (‘\0’)

នៅចន្លោះកណ្ដាល (ដែលពេលនេះ (‘\0’) ត្រូវបានយើងដាក់ដោយខ្លួនឯង)។

បន្ទាត់ទី 2 វាបង្ហាញទាំងអស់ ពីព្រោះសញ្ញាបញ្ចប់ String (‘\0’) នៅខាងចុង ក្រោយបង្អស់នៃ

String (ដែលពេលនេះ (‘\0’) ត្រូវបានដាក់បំពេញដោយ Compiler)។

II.       មធ្យោបាយប្រើប្រាស់  String
II.1     ការប្រកាសអថេរString ដោយ    Array of char

char9ឈេμាះអថេរ[ចំនួនតួអក្សរ];

ឧទាហរណ៍ដូចជា ៖

char str[20] ;
ពេលនេះយើងបាន អថេរ str អាចផ្ទុកបានរហូតដល់ 19 Character ចំណែកឯ មួយ Byte

ចុងក្រោយសំរាប់ទុក ‘\0’។

ការភ្ជាប់តំលៃចាប់ផ្ដើមអោយ   String :

+   យើងអាចភ្ជាប់តំលៃចាប់ផ្ដើមអោយអថេរ String តាមរបៀបដូចខាងក្រោម ៖

char string[] = “This is a string”;

នេះជាការប្រកាស String ដែលមានឈេμាះ string , គμាន កំណត់ ចំនួនតួអក្សរ ហើយភ្ជាប់តំលៃចាប់ផ្ដើមអោយភ្លាមដោយឃ្លា This is a string។  ពេលនេះ Compiler នឹងផ្គត់ផ្គង់

Memory ចំនួន  17 byte ដោយរាប់បញ្ចូលទាំង ‘\0’ (សញ្ញាបញ្ចប់ String) សំរាប់អថេរ string។ ការប្រកាសតាមទំរង់ខាងលើនេះ គឺមិនអាចគμានការភ្ជាប់តំលៃចាប់ផ្ដេឺមបានទេ បើសិនជា គμានការភ្ជាប់តំលៃចាប់ផ្ដើមនោះ Compiler នឹងមិនអាច កំណត់ចំនួន byte ដែលត្រូវផ្គត់ផ្គង់សំរាប់អថេរនេះបានឡើយ ដែលជាហេតុនាំអោយមានកំហុសភ្លាម។

+  យើងអាចភ្ជាប់តំលៃចាប់ផ្ដើមអោយផ្នែកមួយរបស់ Array of char តាមរបៀប ដូចខាងក្រោម ៖

char str[40] = “To do”;

Compiler នឹងផ្គត់ផ្គង់ Memory ចំនួន  40 byte សំរាប់អថេរ str ក្នុងនោះ  5 ធាតុដំបូងចាប់ពី str[0]…str[4] ត្រូវបានភ្ជាប់ តំលៃចាប់ ផ្ដើមដោយពាក្យ To9do ចំណែកឯ បណ្ដាធាតុចាប់ពី str[5] រហូតដល់ str[39] ត្រូវបានផ្ទុកតំលៃសូន្យទាំងអស់ (ត្រូវចាំថា  សូន្យគឺជាតំលៃ ASCII របស់សញ្ញាបញ្ចប់ String ‘\0’) តែធាតុទាំងនេះយើងអាច ប្រើប្រាស់វាអោយផ្ទុកតំលៃផ្សេងនៅពេលក្រោយបាន។ចូរពិនិត្យមើលកមμវិធីខាងក្រោម ដែលមានការប្រកាសអថេរ string ជាមួយនឹងការ ភ្ជាប់តំលៃចាប់ផ្ដើមអោយវានៅពេលប្រកាសភ្លាម បន្ទាប់មកយើងអាចប្រើអថេរដែលបាន ភ្ជាប់តំលៃចាប់ផ្ដើមនេះ អោយរក្សាទុក  String ណាមួយផ្សេងទៀតបាន។ ក្នុងនោះក៏មាន ការបង្ហាញអំពីរបៀបប្រើ scanf ដើម្បីបញ្ចូលទិន្នន័យអោយអថេរ string ដែរ។

#include <stdio.h>

#include <conio.h>

void main()

{

char string[40] = “hello”; /* ភ្ជាប់តំលៃចាប់ផ្ដើមអោយអថេរ string */

clrscr()

printf(“\nstring : %s”, string); /* បង្ហាញតំលៃរបស់ string */ scanf(“%s”, string); /* បញ្ចូលទិន្នន័យថμីអោយអថេរ string */ printf(“\nstring : %s”, string); /* បង្ហាញទិន្នន័យថμីរបស់ string */ getch();

}

បើយើងបញ្ចូលថា abcdefghijkl នោះ លទ្ធផលរបស់កមμវិធីគឺ ៖

string : hello abcdefghijkl._

string : abcdefghijkl

+   យើងអាចភ្ជាប់តំលៃចាប់ផ្ដើមអោយ String Constant តាមទំរង់ដូចខាងក្រោម ៖

const char str[] = “Hello world”;

ក្រោយពេលប្រកាសនេះរួច str មិនអាចផ្លាស់ប្ដូរទិន្នន័យបានទេ ព្រោះវាត្រូវបាន

ប្រកាសជាចំនួនថេរដោយពាក្យគន្លឹះ const រួចទៅហើយ។

II.2 ទិន្នន័យចេញ    និងទិន្នន័យចូលជា   String
II.2.1 ទិន្នន័យអានចូលមានប្រភេទជា String

ខាងក្រោមនេះជាបណ្ដាអនុគមន៍សំរាប់អានយកទិន្នន័យប្រភេទ String :

+      scanf(“%s”, str); អនុគមន៍សំរាប់អាន String ដែលគμាន Space, tab, \n ពី Keyboard។

ឧទាហរណ៍ថា បើអ្នកវាយបញ្ចូលនូវឃ្លា Welcome to BBU នោះអនុគមន៍ scanf នឹងអានបានតែពាក្យ Welcome ប៉ុណ្ណោះ។

+      gets(str) ជាអនុគមន៍សំរាប់អានយកបណ្ដា Character (String) ដែលបាន បញ្ចូលពី Keyboard រួចភ្ជាប់អោយទៅបណ្ដា ធាតុនីមួយៗ របស់ str រហូតដល់ពេលណា ដែលអ្នកប្រើបានចុច Enter នោះទើប ចប់ ការអាន។ ដូច្នេះ  gets មានលទ្ធភាពអាចអាន យកបានទាំង Space និង Tab។

II.2.2.    បង្ហាញទិន្នន័យដែលមានប្រភេទជា String                                                                                             បណ្ដាអនុគមន៍ដែលមានមុខងារសំរាប់បង្ហាញទិន្នន័យប្រភេទជា String លើអេក្រង់ រួមមានដូចជា ៖

printf(“Test string”);

puts(“Test string”);

អនុគមន៍ទាងំ
ពីរខាងលេេី នះសុទ្ធតែមានមខុងារបង្ហាញឃ្លា Test string លើអេក្រង់ ក៏ប៉ុន្ដែវាមានលក្ខណៈខុសគ្នាបន្ដិចត្រង់ថា ក្រោយពេលបង្ហាញ String ដែលស្ថិតក្នុងសញ្ញា bouble quotលើអេក្រង់រួច ហើយ អនុគមន៍ puts នឹងបញ្ជូន Cursor អោយចុះទៅកាន់ ដើមបន្ទាត់ថμី។

 III.   Array of String                                                                               អ្នកបានដឹងរួចមកហើយថា String អាចត្រូវបានគេរក្សាទុកនៅក្នុង Array មួយ វិមាត្រ។ នៅក្នុងចំណុចនេះ អ្នកនឹងបានឃើញអំពី របៀបប្រើ Array ពីរវិមាត្រដើម្បីរក្សា ទុក String ដែលជួរដេក នីមួយៗរបស់វាត្រូវបានផ្ទុក String មួយរៀងៗខ្លួន។  ចូរពិនិត្យមើល ឧទាហរណ៍ខាងក្រោមនេះ ៖

#include <stdio.h>
#include <conio.h>
void main()

{

char str[2][50] =  { {“To be or not to be , “},

{“that is the question”}

};

int count1 = 0; /* ប្រវែងរបស់ String ទី 1 */

int count2 = 0 ; /* ប្រវែងរបស់ String ទី 2 */

/* កំណត់ប្រវែងរបស់ String ទី 1 */

clrscr();

while(str[0][count1] != ‘\0’) /* ខណៈដែលមិនមែនជាសញ្ញា ‘\0’ */

count1++; /* បង្កើនតំលៃអថេររាប់ */

/* កំណត់ប្រវែងរបស់ String ទី 2 */

while(str[1][count2] != ‘\0’)

count2 ++;

/* ពិនិត្យមើលតើ String str[0] មានទំហំគ្រប់គ្រាន់សំរាប់ផ្ទុក String

ទាំងពីរខាងលើដែរឬទេ? */

if(sizeof(str[0]) < count1+count2 + 1)

printf(“\nNot enough space.”);

else

{    /* ចាប់ផ្ដើមតំលៃអថេររាប់ count2 ជាថμីឡើងវិញ */

count2 = 0;

/* ចំលងពី  String ទី 2 បន្ថែមទៅលើ String ទី 1 */

while((str[0][count1++] = str[1][count2++]) != ‘\0’ );

/* បង្ហាញ  String ទី 1 ក្រោយពេលចំលងរួចលើអេក្រង់ */

printf(“\n%s”,str[0]);

}

getch();

}

លទ្ធផលរបស់កមμវិធីលើអេក្រង់គឺ ៖

To be or not to be , that is the question

ឧទាហរណ៍ទី 2 : ប្រើ Array 2 វិមាត្រដើម្បីដំរៀប String

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#include<conio.h>

 

void arrange(int n, char x[][12]); /*ប្រកាសទំរង់អនុគមន៍ */

void main()

{

int i, n=0;

char x[10][12];

clrscr();

printf(“Input strings on the difference line \n\n”);

printf(“press \’end\’to finish\n\n”);

/* អានយកបណ្ដា String ពី Keyboard */

do{

printf(“string %d:”, n+1);

scanf(“%s”, x[n]);

}while (strcmp(x[n++],”end”)); /* ប្រៀបធៀបមើលថាតើ String ដែល

បានបញ្ចូលមុននេះជា “end” ដែរឬទេ?  */

/* បន្ថយតំលៃ  n */

n–;

/* ហៅអនុគមន៍ដើម្បីដំរៀបបណ្ដា String ដែលបានបញ្ចូល */

arrange(n, x);

/* បង្ហាញបណ្ដា String ក្រោយពេលដំរៀបលើអេក្រង់ */

printf(“\n\nString arranged:\n”);

for(i=0;i<n;++i)

printf(“\nString %d: %s”,i+1,x[i]);

getch();

}

/* ប្រកាសអនុគមន៍ដំរៀបបណ្ដា String */

void arrange(int n,char x[][12])

{

char temp[12];

int i,item;

for(item = 0;item <n-1;++item)

/* កំណត់  String តូចជាងគេនៅក្នុងបណ្ដា String ដែលនៅសល់ */

for(i = item+1; i<n; ++i)

if(strcmp(x[item], x[i])>0)/* ប្ដូរទីតាំង  */

{    strcpy(temp, x[item]);

strcpy(x[item], x[i]);

strcpy(x[i], temp);

}

 

}

ឧបមាថា  បើអ្នកបញ្ចូល ៖

hello._

abc._ efgh._ end._

លទ្ធផលលើអេក្រង់គឺ ៖

abc

efgh hello

 IV.   អនុគមន៍មួយចំនួនសំរាប់ប្រើជាមួយ String
1.     strcat សំរាប់តភ្ជាប់ String
ទំរង់អនុគមន៍ ៖

char *strcat(char *s1, char *s2);

មុខងារ  ៖ សំរាប់តភ្ជាប់ String s2 ពីក្រោយ String s1ហើយភ្ជាប់អោយទៅ s1។

/*—— កមμវិធី Prog7_1.C ——*/

#include <string.h>

#include <stdio.h>

#include <conio.h>

void main()

{

char destination[25];

char *blank = ” “, *c = “C++”, *turbo = “Turbo”;

clrscr();

/* ចំលង  String turbo អោយទៅ String destination */

strcpy(destination, turbo);

/* បន្ថែម String blank ពីក្រោយ String destination */

strcat(destination, blank);

/* បន្ថែម String c ពីក្រោយ String destination */

strcat(destination, c);

 

/* បង្ហាញ  String destination លើអេក្រង់  */

printf(“%s\n”, destination);

getch();

}

លទ្ធផលបង្ហាញលើអេក្រង់គឺ ៖

Turbo C++

 

ទំរង់អនុគមន៍ ៖

char *strchar(char *s , int ch)

មុខងារ  ៖ ស្វែងរកតួអក្សរ  ch ដំបូងបំផុតក្នុង String s។ ប្រសិនបើរកឃើញនោះ អនុគមន៍នឹងបោះអាសយដ្ឋានរបស់តួអក្សរ ch ក្នុង String s តែបើផ្ទុយទៅវិញអនុគមន៍បោះ តំលៃ NULL។

/*—— កមμវីធី  Prog7_2.C ——*/

#include <string.h>

#include <stdio.h>

#include”conio.h” void main()

{

char string[25];

char *ptr, c = ‘r’; /* c ផ្ទុកតួអក្សរដែលត្រូវស្វែងរកក្នុង String */

clrscr();

/* ចំលង  String constance អោយទៅអថេរ  string */

strcpy(string, “hitr ssdferilsdkf”);

/* ស្វែងរកតួអក្សរ  c នៅក្នុង  String string បើឃើញ  នោះភ្ជាប់អាសយដ្ឋាន របស់តួអក្សរក្នុង string នោះអោយទៅ Pointer ptr */

ptr = strchr(string, c);

if (ptr) /* ប្រសិនបើ ptr ខុសពី  NULL នោះបានន័យថាបានរកឃើញ c */

printf(“The character %c is at position: %d\n”, c, ptr-string);

else /* ប្រសិនបើរក c ក្នុង string មិនឃើញ  */

printf(“The character was not found\n”);

getch();

}

លទ្ធផលលើអេក្រង់គឺ ៖

The character ‘r’ is at position: 3
3.      strrchr ស្វែងរកតួអក្សរមួយដែលនៅខាងក្រោយបង្អស់នៃ String                                                    

ទំរង់អនុគមន៍ ៖

char *strrchr(char *s , int ch);

មុខងារ  ៖ ស្វែងរកតួអក្សរ  ch ដែលស្ថិតនៅចុងក្រោយបង្អស់ក្នុង String s។ បើ សនិ នោះអនុគមន៍នឹងបោះអាសយដ្ឋានរបស់តួអក្សរ ch ក្នុង String s តែបើផ្ទុយ ទៅវិញនោះអនុគមន៍នឹងបោះតំលៃ NULL។

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

#include <string.h>

#include <stdio.h>

#include”conio.h” void main()

{

រកឃើញ
char string[25];
char *ptr, c = ‘o’; /* c ផ្ទុកតួអក្សរដែលត្រូវស្វែងរកក្នុង String */

clrscr();

/* ចំលង  String constance អោយទៅអថេរ  string */

strcpy(string, “Welcome to cambodia”);

/* ស្វែងរកតួអក្សរ  c ក្រោយគេបំផុតក្នុង String string បើឃើញ  នោះភ្ជាប់ អាសយដ្ឋានរបស់តួអក្សរក្នុង string នោះអោយទៅ Pointer ptr */

ptr = strrchr(string, c);

if (ptr) /* ប្រសិនបើ ptr ខុសពី  NULL នោះបានន័យថាបានរកឃើញ c */

printf(“The character %c is at position: %d\n”, c, ptr-string);

else /* ប្រសិនបើរក c ក្នុង string មិនឃើញ  */

printf(“The character was not found\n”);

getch();

}

លទ្ធផលលើអេក្រង់គឺ ៖

The character o is at position: 15

4.     strcmp ប្រៀបធៀប String ពីរ ដោយបែងចែកអក្សរតូច និងអក្សរធំ

ទំរង់អនុគមន៍ ៖

int strcmp(char *s1, char *s2);

មុខងាររបស់អនុគមន៍ គឺសំរាប់ប្រៀបធៀបរវាង String ចំនួនពីរគឺ String s1 ជា មួយ String s2 ដោយមានការបែងចែកអក្សរតូច និងអក្សរធំ។ ចូរពិនិត្យមើលឧទាហរណ៍ ខាងក្រោមដើម្បីស្វែងយល់ អំពីរបៀបប្រើអនុគមន៍។

ក្រោយពេលប្រើអនុគមន៍នេះ បើយើងទទួលបានតំលៃពីអនុគមន៍គឺ ៖

+   តំលៃ < 0 ប្រសិនបើ s1 < s2

+   តំលៃ = 0 ប្រសិនបើ s1 = s2

+   តំលៃ > 0 ប្រសិនបើ s1 > s2

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

#include <string.h>

#include <stdio.h>

#include <conio.h>

void main()

{

char *buf1 = “aaa”, *buf2 = “bbb”, *buf3 = “ccc”;

int ptr;

clrscr();

/* ប្រៀបធៀប String buf2 ជាមួយ buf1 */

ptr = strcmp(buf2, buf1);

if (ptr > 0) /* ប្រសិនបើ buf2 ធំជាង  buf1 */

printf(“buffer 2 is greater than buffer 1\n”);

else /* ផ្ទុយទៅវិញប្រសិនបើ buf2 តូចជាង  buf1 */

printf(“buffer 2 is less than buffer 1\n”);

/* ប្រៀបធៀប String buf2 ជាមួយ buf3 */

ptr = strcmp(buf2, buf3);

if (ptr > 0) /* ប្រសិនបើ buf2 ធំជាង  buf3 */

printf(“buffer 2 is greater than buffer 3\n”);

else /* ផ្ទុយទៅវិញប្រសិនបើ buf2 តូចជាង  buf3 */

printf(“buffer 2 is less than buffer 3\n”);

getch();

}

លទ្ធផលរបស់កមμវិធីលើអេក្រង់គឺ ៖

buffer 2 is greater than buffer 1

buffer 2 is less than buffer 3

5.     strcmpi ប្រៀបធៀប String ពីរ ដោយគμានការបែងចែកអក្សរតូចធំ    

ទំរង់អនុគមន៍ ៖

int strcmpi(char *s1 , char *s2);

អនុគមន៍នេះក៏ធ្វើការដូចគ្នាជាមួយ strcmp ដែរ ប៉ុន្ដែវាមិនបែងចែកអក្សរតូចធំទេ។

បានន័យថាវាចាត់ទុក “AbCd” ក៏ដូចជា  “ABCD” និង ក៏ដូចជា  “abcd” ដែរ។

 6.     strcpy ចំលង String មួយអោយទៅ String  មួយទៀត

ទំរង់អនុគមន៍ ៖

char *strcpy(char *s1, char *s2);

មុខងាររបស់អនុគមន៍គឺ ចំលង  String s2 អោយទៅ String s1 តែក្រោយពេល ចំលងរួច String

s2 មិនមានប្រែប្រួលតំលៃឡើយ។ ពេលនេះទិន្នន័យចាស់របស់ String s1

ត្រូវបានជំនួសទៅដោយទិន្នន័យថμីរបស់ String s2 ដើម្បីងាយយល់ ចូរអ្នកត្រលប់ទៅ

ពិនិត្យមើលឧទាហរណ៍ Prog7_2.C និង Prog7_3.C នៃទំព័រទី 243 និង 244 ខាងលើ។

  7.     strcspn កំណត់ទីតាំងដំបូងរបស់តួអក្សរណាមួយក្នុង String មេ    

 ទំរង់អនុគមន៍ ៖

int strcspn(char *s, char *schild);

អនុគមន៍នេះមានមុខងារពិនិត្យបណ្ដា Character ក្នុង String s ម្ដងមួយៗ ចាប់ពី  ក្បាល String s ទៅរហូតដល់ខាងចុងនៃ String s ដែលក្នុងខណៈនោះ ប្រសិនបើមាន ជួប Character ណា មួយដែល មាននៅក្នុង String schild នោះការពិនិត្យ ត្រូវបានបញ្ឈប់ ភា្ល ម បន្ទាប់មកភ្ជាប់តំលៃទីតាំងរបស់ Character នៅពេលវាបានជួបនោះ អោយទៅឈេμាះ របស់អនុគមន៍។

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

#include <stdio.h>

#include <conio.h>

#include <string.h>

#include <alloc.h>

void main()

{

char *string1 = “1234567890”;

char *string2 = “747DC8”;

int length;

clrscr();

/* ពិនិត្យមើលតើតួអក្សររបស់ string2 មាននៅក្នុង string1 ដែរឬទេ?

បើមានតើស្ថិតនៅត្រង់ទីតាំងទីប៉ុនμាននៃ string1 */

length = strcspn(string1, string2);

printf(“Character where strings intersect is at position %d\n”, length);

getch();

}

លទ្ធផលរបស់កមμវិធីគឺ ៖

Character where strings intersect is at position 3

អនុគមន៍បោះតំលៃ 3 ព្រោះពេល Scan string1 ដល់ទីតាំងទី 3 ជួបតួលេខ ‘4’ ដោយ ‘4’

មានក្នុង  string2 ដូច្នេះវាក៏បឈ្ឈប់ការ Scan ត្រឹមនោះ  ហើយក៏បោះទីតាំង នោះអោយទៅអថេរ length

តែម្ដង។

  8.     strspn កំណត់ទីតាំងដំបូងរបស់តួអក្សរណាមួយក្នុង String មេ ដែលគμាននៅក្នុង String កូន

ទំរង់អនុគមន៍ ៖

int strspn(char *s, char *schild);

អនុគមន៍នឹងពិនិត្យ String s មួយតួម្ដងៗ  ប្រសិនបើក្នុង s វាជួបនូវ  Character ណាមួយដែលគμាននៅក្នុង String schild នោះវានឹង បឈ្ឈប់ការ Scan ពិនិត្យភ្លាម ហើយ ក៏បោះតំលៃទីតាំងដែលវាបាន Scan ដល់នៅពេលបញ្ឈប់នោះ អោយទៅឈេμាះរបស់ អនុគមន៍។

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

#include <stdio.h>

#include <string.h>

#include <conio.h>

int main(void)

{

char *string1 = “1234567890”; char *string2 = “1234abcd567”; int length;

clrscr();

length = strspn(string1, string2);

printf(“Character where strings differ is at position %d\n”, length);

getch();

return 0;

}

លទ្ធផលលើអេក្រង់គឺ ៖

Character where strings differ is at position 7

length ទទួលបានតំលៃ 7 ពីព្រោះ  នៅពេលវា Scan ដល់ទីតាំងទី 7 នៃ string1 វាក៏បានជួប ‘8’ ដែល ‘8’ នេះពុំមាននៅក្នុង string2 ទេ ដូច្នេះវាក៏បឈ្ឈប់ការ Scan ត្រឹមនេះ ហើយបោះតំលៃទីតាំង ពេល បញ្ឈប់គឺ 7 នោះអោយទៅឈេμាះអនុគមន៍តែម្ដង។

 9.     សតរដុផ ចំលង String មួយទៅទុកក្នុង Memory ថμីដែលបានផ្គត់ផ្គង់ ដោយអនុគមន៍ strdup                                        ទំរង់អនុគមន៍

char *strdup(char *s);

អនុគមន៍នេះមានមុខងារសំរាប់ផ្គត់ផ្គង់ Memory ដើម្បីផ្ទុក String ដែលចំលង បានពី String s។ បើអនុគមន៍អនុវត្ដការងារបានជោគជ័យ នោះអនុគមន៍នឹងបោះ អាសយ- ដ្ឋានរបស់បណ្ដុំ Memory ដែលវាបានផ្គត់ផ្គង់នោះ បើផ្ទុយទៅវិញវានឹងបោះតំលៃ NULL។

/*—– កមμវិធី Prog7_7.C ——*/#include <stdio.h>

#include <string.h>

#include <alloc.h>

#include <conio.h>

void main()

{

char *dup_str, *string = “abcde”;

clrscr();

/* ផ្គត់ផ្គង់ Memory អោយទៅ dup_str ដើម្បីផ្ទុក String ដែលចំលងចេញ ពី String string*/

dup_str = strdup(string);

/* បង្ហាញ  dup_str លើអេក្រង់  */

printf(“%s\n”, dup_str);

/* បង្ហាញអាសយដ្ឋានរបស់ string */

printf(“string address :%d\n”,string);

/* បង្ហាញអាសយដ្ឋានរបស់ dup_str */

printf(“New address :%d\n”,dup_str);

/* រំដោះ  Memory ដែល dup_str កំពុងតែប្រើប្រាស់ចេញវិញ */

free(dup_str);

getch();

}

លទ្ធផលរបស់កមμវិធីគឺ ៖

abcde

string address : 170 new address : 1484

 10.   stricmp ប្រៀបធៀប String ពីរដោយគμានការបែងចែកអក្សរតូចធំ                                          ទំរង់អនុគមន៍ ៖

int stricmp(char *s1 , char *s2);

ដំណើរការរបស់វាដូចគ្នាទៅនឹងដំណើរការរបស់អនុគមន៍ strcmpi ដែរ ចំណែកឯ លទ្ធផលរបស់វាវិញ គឺអោយដូចគ្នាជាមួយ លទ្ធផល របស់អនុគមន៍ strcmp ប៉ុន្ដែអនុគមន៍ នេះប្រៀបធៀបដោយ គμានការបែងចែកអក្សរតូចអក្សរធំទេ។

/* កមμវិធី Prog7_8.C */#include <string.h>

#include <stdio.h>

#include <conio.h>

void main()

{

char *buf1 = “BBB”, *buf2 = “bbb”;

int ptr;

clrscr();

/* ប្រៀបធៀប String buf1 ជាមួយនឹង  buf2 */

ptr = stricmp(buf2, buf1);

if (ptr > 0) /* ប្រសិនបើ buf2 ធំជាង  buf1 */

printf(“buffer 2 is greater than buffer 1\n”);

if (ptr < 0) /* ប្រសិនបើ buf2 តូចជាង  buf1 */

printf(“buffer 2 is less than buffer 1\n”);

if (ptr == 0) /* ប្រសិនបើ buf2 និង buf1 ដូចគ្នា  */

printf(“buffer 2 equals buffer 1\n”);

getch();

}

លទ្ធផលរបស់កមμវិធីលើអេក្រង់គឺ ៖

buffer 2 equals buffer 1

 11.   strlen kMNt;RbEvgrbs;  String

 ទំរង់អនុគមន៍ ៖

int strlen(char *s);

អនុគមន៍នេះមានតួនាទីសំរាប់កំណត់ចំនួន Character ដែលមានក្នុង String តែវា មិនបានរាប់ទាំងសញ្ញាបញ្ចប់ String គឺ ‘\0’ ទេ។


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

#include <stdio.h>

#include <string.h>

#include <conio.h>

void main()

{

char *string = “Borland International”;

clrscr();

printf(“%d\n”, strlen(string));

getch();

}

លទ្ធផលរបស់កមμវិធីលើអេក្រង់គឺ ៖21

 12.         strlwr ប្ដូរពីអក្សរធំទៅជាអក្សរតូចទាំងអស់

ទំរង់អនុគមន៍ ៖

char *strlwr(char *s);

មុខងាររបស់អនុគមន៍គឺ បណ្ដាតួអក្សរធំក្នុង String s ត្រូវបានប្ដូរទៅជាអក្សរតូច វិញទាំងអស់។

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

#include <stdio.h>

#include <string.h>

#include”conio.h” void main()

{

char *string = “Borland International”;

clrscr();

printf(“String prior to strlwr : %s\n”, string);

/* ប្ដូរពីអក្សរធំទៅជាអក្សរតូចវិញទាំងអស់ */

strlwr(string);

printf(“String after strlwr :  %s\n”, string);

getch();

}

លទ្ធផលរបស់កមμវិធីលើអេក្រង់គឺ ៖

String prior to strlwr : Borland International

String after strlwr :    borland international

13.   strncat បន្ថែម n តួអក្សររបស់ String source អោយទៅ String destination                                       

 ទំរង់អនុគមន៍ ៖

char *strncat(char *s1 , char *s2 , int n);

មុខងាររបស់អនុគមន៍ គឺភ្ជាប់បណ្ដា Character ចំនួន  n តួដំបូងរបស់  String s2 អោយទៅ

String s1។ ប្រសិនបើ n ធំជាងប្រវែងរបស់ s2 នោះវានឹងភ្ជាប់តំលៃ s2 ទាំងមូលបន្ថៃមពីក្រោយ s1

តែម្ដង។

/*—— កមμវិធី Prog7_11.C ——*/

#include <string.h>

#include <stdio.h>

#include <conio.h>

void main()

{

char destination[25];

char *source = ” States in usa”;

clrscr();

/* ចំលង  String Constance អោយទៅ destination */

strcpy(destination, “United”);

/* តភ្ជាប់ 7 តួអក្សរដំបូងរបស់ source អោយទៅ destination */

strncat(destination, source, 7);

/* បង្ហាញ  String destination លើអេក្រង់  */

printf(“%s\n”, destination);

getch();

}

លទ្ធផលរបស់កមμវិធីលើអេក្រង់គឺ ៖

United States

 14.   strncmp ប្រៀបធៀប n តួអក្សរដំបូងរបស; String ពីរ   ទំរង់អនុគមន៍ ៖

int strncmp(char *s1 , char *s2 , int n);

អនុគមន៍នេះមានមុខងារធ្វើការប្រៀបធៀប n តួអក្សរដំបូងរបស់ String s1 ជាមួយនឹង  n តួអក្សរដំបូងរបស់ String s2 ដោយមាន ការបែងចែកអក្សរតូចធំ។ តំលៃ របស់អនុគមន៍ដែលនឹងទទូលបានគឺ ៖

–        តំលៃ < 0 ប្រសិនបើ n តួដំបូងរបស់ s1 តួចជាង  n តួដំបូងរបស់ s2

–        តំលៃ = 0 ប្រសិនបើ n តួដំបូងរបស់ s1 ដូចគ្នាជាមួយ n តួដំបូងរបស់ s2

–        តំលៃ > 0 ប្រសិនបើ n តួដំបូងរបស់ s1 ធំជាង  n តួដំបូងរបស់ s2

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

#include <string.h>

#include <stdio.h>

#include <conio.h>

void main()

{

char *buf1 = “aaabbb”, *buf2 = “bbbccc”, *buf3 = “ccc”;

int ptr;

clrscr();

/* ប្រៀបធៀប 3 តួដំបូងរវាង buf2 និង buf1 */

ptr = strncmp(buf2, buf1,3);

if (ptr > 0)

printf(“buffer 2 is greater than buffer 1\n”);

else

printf(“buffer 2 is less than buffer 1\n”);

/* ប្រៀបធៀប 3 តួដំបូងរវាង buf2 និង buf3 */

ptr = strncmp(buf2,buf3,3);

if (ptr > 0)

printf(“buffer 2 is greater than buffer 3\n”);

else
printf(“buffer 2 is less than buffer 3\n”);

getch();

}

លទ្ធផលរបស់កមμវិធីគឺ ៖

buffer 2 is greater than buffer 1

buffer 2 is less than buffer 3

15.   strnicmp ប្រៀបធៀប n តួដំបូងរបស់ String ពីរដោយគμានការបែង ចែកអក្សរតូចធំ

 ទំរង់អនុគមន៍ ៖

int strnicmp(char *s1 , char *s2 , int n);

ធ្វើការដូចគ្នាជាមួយ strncmp ដែរ តែវាគμានការបែងចែកអក្សរតូច និងអក្សរធំ  ឡើយ។

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

#include <string.h>

#include <stdio.h>

#include”conio.h” void main()

{

char *buf1 = “BBBccc”, *buf2 = “bbbccc”;

int ptr;

clrscr();

ptr = strnicmp(buf2, buf1, 3);

if (ptr > 0)

printf(“buffer 2 is greater than buffer 1\n”);

if (ptr < 0)

printf(“buffer 2 is less than buffer 1\n”);

if (ptr == 0)

printf(“buffer 2 equals buffer 1\n”);

getch();

}

លទ្ធផលរបស់កមμវិធីគឺ ៖

buffer 2 equals buffer 1

 16.   strncpy ចំលង n តួអក្សរពី String source អោយទៅ String destination                   

ទំរង់អនុគមន៍ ៖

char *strncpy(char *s1 , char *s2 , int n);

អនុគមន៍នេះមានមុខងារចំលង n តួដំបូងរបស់ String s2 អោយទៅ String s1

ដោយទិន្នន័យចាស់របស់ S1 ត្រូវបាត់បង់។


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

#include <stdio.h>

#include <string.h>

#include <conio.h>

void main()

{   char string[10];

char *str1 = “abcdefghi”;

clrscr();

/* ចំលង  3 តួដំបូងរបស់ str1 អោយទៅ string */

strncpy(string, str1, 3);

/* ដាក់សញ្ញាបញ្ចប់ String នៅធាតុទី  4 របស់ string */

string[3] = ‘\0’;

printf(“%s\n”, string);

getch();

}

លទ្ធផលលើអេក្រង់គឺ ៖abc

 17.   strnset ប្ដូរ n តួអក្សរដំបូងរបស់ String  eដាយតួអក្សរផ្សេងវិញ

ទំរង់អនុគមន៍ ៖

char *strnset(char *s , int c , int n);

មុខងាររបស់អនុគមន៍ strnset គឺត្រូវជំនួស n តួដំបូងរបស់ string s ដោយ Character c វិញ។

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

#include <stdio.h>

#include <string.h>

#include <conio.h>

void main()

{

char *string = “abcdefghijklmnopqrstuvwxyz”;

char letter = ‘x’;

clrscr();

printf(“String before strnset: %s\n”, string);

/* ជំនួស  13 តួដំបូងរបស់ string ដោយអក្សរ ‘x’ */

strnset(string, letter, 13);

printf(“String after strnset: %s\n”, string);

getch();

 

}

លទ្ធផលរបស់កមμវិធីគឺ ៖

String before strnset: abcdefghijklmnopqrstuvwxyz

String after strnset:  xxxxxxxxxxxxxnopqrstuvwxyz

 18.   strrev ត្រឡប់បញ្ច្រាស់តួអក្សររបស់ String

ទំរង់អនុគមន៍ ៖

char *strrev(char *s);

អនុគមន៍នេះមានមុខងារបញ្ច្រាស់បណ្ដាតួអក្សរក្នុង String s ពីខាងចុងមកខាង ក្បាលវិញ។ បើបានអនុវត្ដបានសំរេច អនុគមន៍នឹងបោះអាសយដ្ឋានរបស់ string ដែលបាន

បញ្ច្រាស់  តែបើផ្ទុយទៅវិញនោះអនុគមន៍នឹងបោះតំលៃ NULL។

*—— កមμវិធី Prog7_16.C ——*/

#include <string.h>

#include <stdio.h>

#include <conio.h>

void main()

{

char *forward = “string”;

clrscr();

printf(“Before strrev(): %s\n”, forward);

/* បញ្ច្រាស់  String forward */

strrev(forward);

printf(“After strrev(): %s\n”, forward);

getch();

}

លទ្ធផលរបស់កមμវិធី ៖

Before strrev():string

After strrev():gnirts

 19.   strset ជំនួសបណ្ដា Character របស់ String មួយដោយ Character ch vij    

ទំរង់អនុគមន៍ ៖

char *strset(char *s,int ch);អនុគមន៍នេះមានមុខងារប្ដូរបណ្ដាតួអក្សរទាំងអស់របស់ String s ដោយតួអក្សរ  ដែលមាន  ASCII

ផ្ទុកដោយ  ch វិញ។

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

#include <stdio.h>

#include <string.h>

#include <conio.h>

void main()

{   char string[10] = “123456789”;

char symbol = ‘c’;

clrscr();

printf(“Before strset(): %s\n”, string);

/* ប្ដូរបណ្ដាតួអក្សររបស់ string ដោយ symbol វិញ */

strset(string, symbol);

printf(“After strset(): %s\n”, string);

getch();

}

លទ្ធផលរបស់កមμវិធី ៖

Before strset(): 123456789

After strset(): ccccccccc

20.   strstr ស្វែងរក String មួយក្នុង String មួយផ្សេងទៀត

ទំរង់អនុគមន៍ ៖

char *strstr(char *s1,char *s2);

អនុគមន៍នេះនឹងស្វែងរក String s2 ដែលបានលេចឡើងដំបូង បង្អស់ នុង String s1។ បើសិនជារកឃើញនោះអនុគមន៍ នឹងអាសយដ្ឋាន របស់ String s2 ដែលកំពុងតែ នៅក្នុង  String s1 នោះ តែបើផ្ទុយ ទៅវិញ វានឹងបោះតំលៃ NULL។

/*—— កមμវិធី Prog7_18.C ——*/#include <stdio.h>

#include <string.h>

#include <conio.h>

void main()

{

char *str1 = “Borland International”, *str2 = “nation”, *ptr;

clrscr();

/* ស្វែងរកមើលតើមាន s2 នៅក្នុង  s1 ដែរឬទេ?  */

ptr = strstr(str1, str2);

if(ptr==NULL)

printf(“\nNot found”);

else

printf(“The substring is: %s\n”, ptr);

getch();

}

 លទ្ធផលរបស់កមμវិធីគឺ ៖ The substring is: national

 21.   strupr  ប្ដូរពីអក្សរតូចទៅអក្សរធំ      

 ទំរង់អនុគមន៍ ៖

char *strupr(char *s);

បណ្ដាតួអក្សរតូចក្នុង String s នឹងត្រូវបានប្ដូរទៅជាអក្សរធំវិញទាំងអស់។ ក្រោយ ពេលប្ដូររួច

អនុគមន៍នឹងបោះអាសយដ្ឋានរបស់ String s

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

#include <stdio.h>

#include <string.h>

#include <conio.h>

void main()

{

char *string = “abcdefghijklmnopqrstuvwxyz”, *ptr;

clrscr();

/* ប្ដូរបណ្ដាតួអក្សររបស់ String string អោយទៅជាអក្សរធំវិញ */

ptr = strupr(string);

printf(“%s\n”, ptr);

getch();

}

លទ្ធផលរបស់កមμវិធីលើអេក្រង់គឺ ៖

ABCDEFGHIJKLMNOPQRSTUVWXYZ

 សំណួរ

 1.      នៅក្នុង  String តើសញ្ញា ‘\0’គឺជាអ្វី? តំលៃ ASCII គឺប៉ុនμាន?
2.      ចូរនិយាយអំពីរទំរង់រក្សាទុកទិន្នន័យនៃការប្រកាសខាងក្រោម ៖char *str = “My String”;
3.      និយាយអំពីភាពខុសគ្នានៃការប្រើ scanf ជាមួយ gets ដើម្បីអាន String?

 

មេរៀនទី៩: ទម្រង់ Struct Keyword

មេរៀនទី៩: ទម្រង់ទិន្នន័យជាមួយនឹង  Struct Keyword

មកដល់ពេលនេះ  អ្នកប្រាកដជាបានដឹងយ៉ាងច្បាស់ ហើយអំពីរ បៀបប្រកាសអថេរ  សំរាប់ផ្ទុកគ្រប់ប្រភេទទិន្នន័យ ដូចជាប្រភេទ ចំនួនគត់ (Integer) ចំនួនទសភាគ (Floating -point) និងប្រភេទ តួអក្សរ ជាដើម  (Character)។ មនិតែប៉ុណ្ណោះអ្នកកប៏ានដឹងអពំវី ិធ បីងេត្កស៊េរីនៃចំនួនទាំងនោះ  (Array) និងស៊េរីនៃ Pointer  ដែល ចង្អុលទៅកាន់ទីតាំងណាមួយ  នៃ  Memory   ដែលមានផ្ទុក ទិន្នន័យ ប្រភេទណាមួយដែលយើងចង់បាន។   ឧបមាថាអ្នកត្រូវការ  សរសេរ កមμវិធីមួយសំរាប់គ្រប់គ្រងពត៌មានរបស់បុគ្គលិកក្រុមហ៊ុន “ក”    ហើយពត៌មានដែល                                                        អ្នកត្រូវការកត់ត្រាពី បុគ្គលិក នោះរួមមានដូចជា ឈេμាះ អត្ដលេខ ក្នុងក្រុមហ៊ុនថៃែ្ង ខឆា្ន កំេំ ណតីអាសយដ្ឋានស្នាក់នៅបច្ចុប្បន្នជាដើម   ដែលក្នុងនោះអ្នកបានឃើញថាមានពត៌មានខ្លះមាន ប្រភេទជា   String  និងខ្លះទៀតជាតំលៃលេខ។  ជាការពិតណាស់  ពេលនេះដើម្បី រក្សាទុក  ទិន្នន័យរបស់ បុគ្គលិក  ទាំងនោះ  គឺអ្នកអាចបង្កើត Array សំរាប់ប្រភេទទិន្នន័យនីមួយៗ និង  រក្សាទុកពតម៌ានទាំងនោះ បាន យ៉ាងងាយ ក៏ប៉ុន្ដែធ្វើតាមលក្ខណៈនេះគឺមានភាពចង្អៀតចង្អល់ ណាស់ ពីព្រោះវាមិនបានអនុញ្ញាត អោយអ្នកអាច ចូលទៅដល់ការ ពិនិត្យ មើល ពត៌មានអំពី អាសយដ្ឋានស្នាក់នៅរបស់បុគ្គលិកឈេμាះ “សម” ឬក៏ពត៌មានអំពីថ្ងៃខែឆ្នាំកំណើតរបស់  កញា្ញ ឈេμាះ  “គ”   បានដោយងាយស្រួលនោះទេ  គឺត្រូវការអានពីគ្រប់ Array ដែល មានទំនាក់ទំនងជាមួយពត៌មានដែលយើងត្រូវការ ជាមួយនឹងលេខ លំដាប់  (Index) ណាមួយយ៉ាងត្រឹម ត្រូវ។  ក៏ប៉ុន្ដែ, ក្នុងភាសា C  បានអនុញ្ញាតអោយយើងមានលទ្ធភាពអាចធ្វើការ ជាមួយទំរង់ ការងារ ប្រភេទនេះដោយវិធីមួយផ្សេងទៀតដែលមានលក្ខណៈប្រសើជាងការប្រើ Array ដូច ដែលបានរៀបរាប់ មុននេះ  នោះគឺការរៀបចំទំរង់ទិន្នន័យ ថμីមួយ ដោយពាក្យគន្លឹះ struct។

 I. Definition Structure យើងបានស្គាល់បណ្ដាទិន្នន័យ មានទំរង់ ខ្លះៗដូចជា Array, ដែលមានបណ្ដាធាតុ មានប្រភេទទិន្នន័យដូចគ្នា ។ Ex:  int x[100]; ប៉ុន្ដែបើយើងចង់បង្កើតទិន្នន័យមានទំរង់,  ដែល បណ្ដា ធាតុរបស់វាមានប្រភេទខុសគ្នានោះយើងត្រូវ Declaration វាជាទិន្នន័យប្រភេទ struct ។ ហើយអាចហៅទិន្នន័យប្រភេទ struct ថា record ក៏បាន ។

II.   Declaration Struct: ទិន្នន័យប្រភេទ structure ត្រូវ Declaration ដោយ Keyword struct, បន្ទាប់មកជាបណ្ដា

field របស់ struct ។

Ex1: Address រួមមាន លេខផ្ទះ, ឈេμាះផ្លូវ, ទីក្រុង,  ដូច្នេះយើងអាច Declaration Address ជាមួយ

keyword struct ដូចខាងក្រោម ៖

struct Address

{     int home,

char street[20];

char city[15];

}     A, B;

ឬម្យ៉ាងទៀតមិនបាច់មានឈ្នោះរបស់ ; struct ទេ, គឺ Declaration ដោយផ្ទាល ់បណ្ដា Variable A, B

ដូចខាងក្រោម ៖

struct   /* No Name */

{    int home; char street [20]; char city[15];

}    A, B;

Note: ដូច្នេះយើងមាន field បីគឺ Home, Street, City ដែលមាន ប្រភេទទិន្នន័យផ្សេងៗគ្នា ហើយមានទំនាក់ ទំនងជាមួយគ្នា បង្កើតបាន Address . ក្រោយមកយើង Declaration Variable A, B ជា struct .

ª យើងអាច Declaration struct និង Variable ដាក់ផ្សេងពីគ្នាបាន ។

struct Address

{    int home;

char street[20];

char city[15];

};

Declaration Variable :

struct Address A, B;

Ex2: ដើម្បី Declaration រយៈពេល DATE យើងមាន 3field: ថ្ងៃ, ខែ, ឆ្នាំ ។

struct Date  {

unsigned char day; unsigned char month; unsigned int year;

}  date1, deta2;

ឬ struct Date date1, date2

ដោយថ្ងៃ, ខែ, ឆ្នាំ គ្នាចំនួនអវិជ្ជមាន ដូច្នេះយើង Declaration ជា unsigned  ។

Ex3: Declaration   ប្រវត្ដិរូបរបស់បុគ្គលិកម្នាក់រួមមាន ៖ ឈេμាះ,  ថ្ងៃខែឆ្នាំកំណើត, អាស័យដ្ឋាន,

ប្រាក់ខែ … struct Date  {

unsigned char day; unsigned char month; unsigned int year;

};

struct people { char dat;

struct Date Dob;

unsigned char sex;          /*girl = 0, boy = 1*/

struct Address addre;

float salary;

} peopleA, peopleB;

–     ក្នុង Ex3, យើងសង្កេតឃើញថា Declaration struct ក្នុង struct ។

–     បើចង់តាងតំលៃអោយធាតុ Name យើងសរសេរ ៖

peopleA.Name = “Dara”;

–     បើចង់តាងតំលៃអោយធាតុ City គឺសរសេរ ៖

peopleA.Address.City = “Phnom Penh”;

III. Access to ធាតុរបស់ struct:

ជាមួយ Declaration :

struct Address

{     int home;

char street[20];

char city[15];

} A, B;

យើងអាច Access ទៅធាតុរបស់ struct ដូចខាងក្រោមៈ

A.home = 118; A.street = “sihanu”;

A.city  = “Phnom Penh”;

ឬប្រើក្នុង Function:

printf (“Enter Name Street:”); gets (A.street);

 IV.  Declaration Array of struct:

យើងអាច declaration array of struct ដើម្បីផ្ទុកទិន្នន័យបានច្រើន

Ex:  struct people a[100];

ជាការ  declaration  Array    100,  a  មានប្រភេទជា  people  ។  ក៏ដូចជាបណ្ដា  array

ផ្សេងទៀតដែរ,array of struct ក៏ត្រូវមាន index ចាប់ពីលេខ 0 ទៅដែរ ។

ពិនិត្យឧទាហរណ៍ខាងក្រោមៈ

Ex:5    date

{ char Name[80];

int day;

int month;

int year;

}

static struct date dateofbirth [ ] = {     “Data”, 10, 3, 1970,

“Bopha”, 22, 4, 1968,

“Vanna”, 11, 11, 1950 };

ឬ static struct date dateofbirth[5];

deteofbirth[2].Name = “Vanna”;

 V. ឧទាហរណ៍អនុវត្ដន៍ ៖

ឧទាហរណ៍ខាងក្រោមនេះអនុវត្ដន៍នូវអ្វីៗដែលយើងបានរៀនកន្លងមកដូចជា array,        struct, function…

# include <stdio.h>

# include <conio.h>

# define MAX 100 struct Address  {

char  name[30];

int   homenumber;

char  street [20];

char  city[15];

}  addr[MAX];

void  init_list (void);

void  enter (void);

int  menu_select (void);

void  delete1 (void);

void  list (void);

int  find_free (void);

main ( )

{ char choice;

init_list ( );            /* create array of struct */

for (, ,)                   /* loop have no condition */

{ choice = menu_select ( );

switch (choice)

{case  1: enter( ); break;

case  2: delete1 ( ); break;

case  3: list ( ); break;

case  4: exit (0);

}

}    }

function init_list ដើម្បីបង្កេតី

តំលៃរបស់ array Address ។
/* create list of Address */

void init_list (void)

{ register int t;

for (t = 0 ; t < MAX ; ++t)

addr[t].name[0] = ‘\0’;

}

/* create menu selete*/

int  menu_select (void)

{ char s[80] ;

int c ;

printf (“1. Enter Name \n”); printf (“2. Delete Name \n”); printf (“3. List Name \n “); printf (“4. Exit \n”);

do {

printf (“\n Please select your choose:”);

gets(s);

c = atoi(s);

} while (c< 0 || c > 4);

return (c);

}

/*Enter Address into list */

void  enter (void)

{     int slot ;

char s[80] ;

/* find free space in array for access */

slot = find_free ( );

if (slot = = -1)  {

printf (“\n list is full !”);

return ;

}

printf (“Name :”); fflush(stdin); gets (addr[solt].name);

printf (“Home Number :”);

scanf (“%d”, &addr[solt].homenmber)

while (gecthar ( )!=’\n’;

prinft (“Name street :”); gets(addr[solt].street);

printf(“ City 🙂 ; fflush(stdin); gets(addr[slot].city);

}

/*find free space */

int find_free (void)

{  register int t;

for(t = 0;addr[t].name[0] && t<MAX;t++)

if (t = =MAX) return (-1);  /*No free space*/

return(t);

}

ចំណាំ ៖  យើងប្រើតំលៃ –1 ដើម្បីប្រាប់ថាអស់ space ។  តំលៃ1 ជាតំលៃដែល array មិន ប្រើប្រាស់ជា Index

/*Delete*/

void delete1 (void)

{  register int slot;

char s[80];

printf (“´Number of Record # :”); gets(s);

slot = atoi (s);

if (solt >= 0&& slot <MAX)

addr[slot-1].name[0]= ‘\0’;

}

/* Display Data On Screen */

void list (void)

{  register int t;

for (t = 0; t <MAX ; ++t)

{ if (addr[t].name[0])

{  printf (“%s \n”, addr[t].name);

printf (“%d \n”, addr[t].homenumber);

printf (“%s \n, addr[t].street);

printf (“%s \n, addr[t].city);

}

}

printf (“\n\n”);

}

ក្នុង function enter( ), យើងឈើញថា

scanf (“%d”, &addr[slot].homenumber);

while (getchar( ) !=’\n’);

ពេលយើង Read ផ្ទះលេខ, យើងត្រូវប្រើសញ្ញា Address & ដើម្បី Read ។ ចំនុចមួយទៀត យើងត្រូវប្រើ statement while (getchar( ) !=’\n’); ដើម្បីរំលងសញ្ញា Enter ហើយយើងចុះដើមបន្ទាត់ថីμ ។  បើគμាន  statement  នេះ,  នោះ  statement  Read  ម្ដងទៀតនឹងខុស។ បើយើងលុប statement while (gechar( ) !\n’); នោះពេលយើង Read ឈេμាះ street នឹងគμានអ្វីទាំងអស់។

VI. បញ្ផូល  parameter ក្រោមរៀង  struct ទៅអោយ  function :

ពេលបញ្ផូល   parameter   ប្រភេទ   struct   ទៅ   function,   យើងអាចបញ្ផូនបណ្ដា  filed

នីមួយៗរបស់ struct ទៅអោយ struct ។ ឧទាហរណ៏ ខាងក្រោមនឹងអធិប្បាយពីបញ្ឌានេះ។

struct toto

{  char x; int y; float z;

char s[10];

}tata;

 field នីមួយៗរបស់ struct នឹងត្រូវបញ្ផូនទៅអោយ function ដូចខាងក្រោម :

func1 (tata.x);

func2 (tata.y);

func3 (tata.s);            /*បញ្ផូន Address របស់ string s*/

func4 (tata.s[2]);   /*បញ្ផូន value character */

/* យើងអាចបញ្ផូន Address របស់បណ្ទា field ទៅអោយ function  */

func1 (&tata.x);

func2 (&tata.y);

func3 (tata.s)            /*បញ្ផូន Address របស់ string*/

func4 (&tata.s[2]);              /*បញ្ផូន character*/

+ បញ្ផូន parameter ជា struct : Ex7:

#include <stdio.h>

struct type_toto {

int a, b;

};

void f1 (struct type_toto parm);

main ( )

{  struct type_toto arg;

arg. a= 1000;

f1 (arg);

}

void f1 (struct type_toto parm)

{  printf(“%d”, parm.a);

}

VII. Pointer of stuct :

ក្នុងCអនុញ្ញាតិអោយប្រើ Pointer point to struct បាន។

Ex:

struct bal  {

char name[80] ;

} person ;

strcut bal *p;

គឺជា Declaration pointer ប្រភេទ bal (struct),. តែមិនទាន់មាន Address ជាក់ស្ដែងទេ ។ យើងតាង

p = &person ;

ពេលនេះ p ផ្ទុក Address  ជាមួយធាតុរបស់ struct តាមរយៈ pointer point to វានេះ, យើងប្រើប្រាស់ operator ដែលមានសញ្ញា Æ។ ឧបមានចង់ point to field balance,យើងត្រូវសរសេរៈ p Æbalance; Note: ចំពោះការ Access ជាមួយធាតុរបស់ struct តាមរយៈ pointer នោះយើងប្រើសញ្ញា Æ ។

ចំពាះ access ជាមួយធាតុរបស់ struct តាមរយៈ variable ធមμតានោះយើងប្រើសញ្ញា (.) ។

Ex8:  អធិប្បាយពីនាឡិការ  ៖

# include <stdio.h>

# define DELAY 128000 struct my_time     {  int hours;

int minutes; int seconds; int hunds;

};

void display (struct my_time *t); void update (struct my_time *t); void delay (void);

main ( )

{    struct my_time  systime ;

systime.hours = 0;    systime.minutes = 0;

systime.seconds = 0; systime.hunds = 0; textmode(C40); textbackground(1); textcolor(14);clrscr ();

for (; 😉                           /* loop have no condition */

{ update (&systime);

display (&systime);

}

return 0;

}

void display (struct my_time  *t)

{gotoxy(18, 12 ); cprintf (“%02d :”, tÆhours);

gotoxy(21,12);  cprintf (“%02d :”, tÆminutes);

gotoxy(24,12) ; cprintf (“%02d :”, tÆseconds);

gotoxy(27,12);  cprintf (“%02d ”, tÆhunds);

}

void update (struct my_time *t)

{    tÆhunds ++;

if (tÆhunds = = 100)

{  tÆhunds = 0;

t Æseconds ++;

}

if (tÆseconds = = 60)

{  tÆseconds = 0;

t Æminutes ++;

}

if ( tÆminutes = =60)

{  tÆminutes = = 0;

tÆhours ++;

}

if ( tÆhours = = 24) tÆhours = 0 ;

delay ();

}

void delay (void)

{    long int t;

for (t = 1; t < DELAY; ++t);

}

Note : លទ្ឋផលដូចខាងក្រោម  ៖

14 : 02 : 55 : 50

–   យើងអាចប្រែប្រួលតំលៃរបស ់ DELAY ដើម្បីកមμវិធីតំណើរការយឺតៗ

–   ក្នុងផ្នែកខាងដើមនៃកមμវិធី,  យើង Déclaration struct my_time តែមិនទាន់មាន   variable

ជាក់ស្ដែងទេ ។ ក្នុងផ្នែក main( ) យើង Declaration systime ដែលមានតំលៃដើម 00: 00:00 ។ មានន័យថា systime, ដំណើរការតែក្នុង main ( ) តែប ៉ុណ្ណោះ ។

–   Function  update  (  )  ធ្វើអោយប្រែប្រួលតាមរយៈពេល និង  function  display  (  )

ប្រើសំរាប់ display result on screen ។ ក្នុង Function ទាំងពីរសុទ្ឋតែមាន parameter ជា pointer  point  to  my_time  ។    In  Function  update()  និង  display(),  ធាតុ នីមួយៗរបស់ systime ត្រូវបាន Access តាមរយៈ pointer ។ ដោយវាអាច update តាមលៃរយៈពេល ។

VIII. union:union បើយើង Declaration variable ច្រើនជា Function នោះវា ប្រើតែ block memory

តែមួយប៉ុណ្ណោះ, ទោះជានៅរយៈពេលខុសគ្នាក៏ដោយ ៖ ឧទាហរណ៍

union table   {    int number; long address; char code;

}; union table a; union table b; union table c;

ដូច្នេះ Declaration ជា union ធ្វេិីអោយមានការសន្សំសំចៃ memory ។

លំហាត់អនុវត្ដន៍

1.1. ចូរសរសេរកមμវីធីអនុវត្ដន៍ខាងក្រោម

a.   Read form Keyboard នូវ Data នៃ array of struct ដែលមានប្រភេទជា point

ដូចខាងក្រោម ៖

struct point {  int num ; float x ; float y ;

}

ចំនួនធាតុនៃ array ត្រូវកំណត ់ដោយ statement # define b.   Display the Result on screen.

1.2.  សរសេរកមμវីធីខាងលើក្រោមរាង Function : Funtion មួយសំរាប់ Read Data, Function

មួយទៀតសំរាប់ Display ។

2.  សំនួរបន្ថែម ៖

union table a;

2.1.  ចូររកចំនុចខុសក្នុង struct ខាងក្រោម ៖

struct parts

{    int partno;

char descript[20];

float price;

char *ptr;

2.2. ធ្វើដូចម្ដេចដើម្បីសំដែងធាតុ partno របស់ parts. struct inven

{    int partno ;

}

/* struct inven parts; */

struct inven parts;

struct inven *ptr = &parts;

a. part.partno b. ptrÆpartno

c. partno d. a និង b

 

2.3.  ចូរបង្កើតឈេμាះមួយអោយ character ទី៣ នៃ variable name របស់ address ។

struct fullname{

struct   addr


char firstname[20];

char lastname[20];

};

{  struct fullname name ;

char address[60];

char city[4];

}

struct fullname

{       char firstname[20];

char lastname[20];

}

struct addr address;

struct addr   *ptr = &address;

a.   address.namefirstname[2];

b.   ptrÆname.firstname[2];

c.  ចំលើយ a, b សុទ្ឋតែត្រូវ

d.  គμានចំលើយត្រឹមត្រូវទេ ។

 

មេរៀនទី១០: រក្សារទុកទិន្នន័យក្នុង File

មេរៀនទី១០: រក្សារទុកទិន្នន័យក្នុង File

I.   Definition file: File  ជាសំណុំនៃទិន្នន័យ   ដែលមានទំនាក់ ទំនង ជាមួយគ្នា  និងមានប្រភេទដូចគ្នាត្រូវបាន ផ្ដុំបញ្ចូលគ្នាបង្កើតបាន ជា array of data ។ file ត្រូវបានផ្ទុកក្នុង Disk … ។
II.   Analysis file: បណ្ដាជំហ៊ានដើម្បី analysis file រួមមាន ៖

–   Declaration file variable :
–   Open file for read or write :
–   Read file, write file :
–   Close file.
II.1). Declaration file variable: យើងកំណត់ប្រើ    fptr         ជាឈេμាះ  pointer   file ដើម្បីធ្វើជាឧទាហរណ៍ ។  ក្នុងជាក់ ស្ដែង,
យើងអាចជំនួស fptr ដោយឈេμាះណាផ្សេងទៀតក៏បាន ។
Statement Declaration មាន Syntax ដូចខាងក្រោម ៖

 FILE *fptr ;

 – FILE ជា Keyword ជានិច្ចជាកាលត្រូវតែមាន និងសរសេរជាអក្សរ ធំ។
– សញ្ញា * បញ្ជាក់ថា pointer ។

II.2). Open file for write or read : Syntax open file for write:
fptr = fopen (“filename” , “w” );

 Syntax open file  for read :

fptr = fopen (“filename” , “r” );

 ឧទាហរណ៍ៈ បើក file ថμីដើម្បី write data (ដោយ file មានឈេμាះ និង path)

fptr = fopen (“c:\\TC\\ EXAM.TXT”, “w”);

+  ប្រភេទ analysis file មានរាងដូចខាងក្រោម ៖
–  ចំពោះ text file :

“r”     :  បើក file ដែលមានស្រាប់សំរាប់ read (“read only”) ។
“w”   : បើក file ថμីដើម្បី write (“write only”), បើឈេμាះ file ដូចឈេμាះ file ចាស់នោះ file ចាស់ត្រូវបានលប់ចោល ។
“a”    :  បើក file ដែលមានស្រាប់សំរាប់ write ថែមទិន្នន័យ ។
“r+”  :  បើក file ដែលមានស្រាប់សំរាប់ read និង write ។
“w+” :  បើក file ថμីដើម្បី write និង read
“a+” :  បើក file ដែលមានស្រាប់សំរាប់ read និង write ថែមទិន្នន័យឭ
– ចំពោះ binary file : “rb”  : បើក binary file ដែលមានស្រាប់សំរាប់ read, “read only,binary file”.
“ wb”: បើក binary file ថμីដើម្បី write, “writing only, binary file”
“ab”  :  បើក binary file ដែលមានស្រាប់សំរាប់ write data ថែម “r+b” : បើក binary file ដែលមានស្រាប់សំរាប់ read និង write “w+b”: បើក binary file ថμីសំរាប់ read និង write

“a+b” :  បើក binary file ដែលមានស្រាប់ដើម្បី write ថែមទិន្នន័យថμី

II.3). Read file និង Write file ក្នុងជំហ៊ាននេះមានភាព ខុសគ្នា រវាងបណ្ដាប្រភេទរបស់   file   និងប្រភេទ  analysis   file ។ដូច្នេះយើងត្រូវ សិក្សាក្នុងឧទាហរណ៍ជាមួយបណ្ដា function write, read ។

II.4). Close file: Close file ជាការងារចុងក្រោយគេបង្អស់ក្នុងការ analysis file ។ មានរាង ៖

fclose (fptr);
# include <stdio.h>

main ( )

{FILE *fptr;

fptr = fopen (“sample.dat”, “w”);

if (fptr = = NULL) printf (“\n ERROR – Cannot open”);

else      { … /* analysis file */; … fclose (fptr);

}

}

 III. Binary file :

III.1)    ក្រោយពីបើក file ថμីជាមួយ  analysis file “w”(writing), ដំបូងនោះ file ទទេ ព្រោះមិនទាន់ មានធាតុណាទាំងអស់, ពេលនោះ pointer file នឹង point to ចុង file គឺ (EOF)  ខាងក្រោយនេះ ជា ឧទាហរណ៍ បង្កើត file មាន 1០០ ធាតុ ដែលមានតំលៃពី 1 ដល់ 1០០ ។

ឧទាហរណ៍ ៖  បង្កើត file នៃចំនួនគត់ ៖

# include <stdio.h>
# include <conio.h>
main ( )
{  char filename[21];

int i;

long num; FILE *f1;

printf (“\n Name file:”);   scanf (“%20s”, &filename);

f1 = fopen (filename, “wb”);   /*open file for writing only */

/* write 100 number into file */

for ( i = 1; i <= 100; i ++)

fwrite (&i, sizeof (int), 1, f1);

fclose(f1);

}

Note:  fwrite (&i, sizeof (int), 1, f1);

–     Function  នេះមានសកមμភាព  writedataទៅក្នុងfile(file  write)  មានបណ្ដា  parameters

ដូចខាងក្រោម
+  &i: address of  Variable i
+  ទំហំរបស់ data ដែលត្រូវ write ទៅក្នុង file
+  Address of  file
+  ចុងក្រោយគឺ pointer of file
–  fwrite អនុញ្ញាត្ដិអោយ write data ជាច្រើនដែលមានទំហំប៉ុនគ្នា, ទៅក្នុង file បាន ។
+  fopen ( ): អាចមានតំលៃសេμី NULL, ក្នុងករណីមានកំហុសដូចជា disk full  ។

Ex: printf (“Name file:”);  scanf (“%20s”, filename);

f1 = fopen (filename, “wb”);

យើងអាចជំនួសដោយ statement:

f1 = fopen (“Integer.Dat”, “wb”);

 III.2) Read binary file: ដើម្បី Read ធាតុណាមួយរបស់ file ត្រូវមានលក្ខ័ខ័ណៈ តើ file នោះនៅមានធាតុសំរាប់ Read ឬអត់ ?

(pointer  Æ EOF) ។ Function feof ( ) នឹងប្រាប់អោយដឹងៈ បើ Read ដល់ចុង file នោះ feof ( ) =

True ផ្ទុយទៅវិញ feof ()= False ។
វិធានដើម្បី Read file មួយយើងប្រើ ៖

ពេល Read file, ត្រូវ Read ធាតុ file ជាមុនទើបត្រួតពិនិត្យមើល តើធាតុនោះជា EOF ឬអត់ ?

if ((ch = getc (fp)) != EOF)…

ក្នុងនោះ function getc (fp) ជា function Read 1 character ឬ 1 byte របស់ file

ដែលមាន  pointer  fileគឺ  fp។  statement  នេះមានន័យថា  Read  1  character  ពី  file  fp និងពិនិត្យមើលតំលៃរបស់វាសេμី  EOF   ឬ  អត់ ? ឬប្រើ Loop   while ដើម្បីត្រួតពិនិត្យ គ្រប់ធាតុ ទាំងអស់របស់ file ដែលយើង Read . while ((ch = getc (fp)) != EOF) …

នោះនឹង Read ធាតុទាំងអស់របស់ file រហូតដល់ EOF ទើបឈប់ ។

Ex: Read file of integer number :
#include <stdio.h>
main ( )
{     char filename[21];

int  i;

FILE  *f1;

printf (“”\n Name file:”);  scanf (“%20s”, &filename);

f1 = open (filename, “rb”);

while (fread (&i, sizeof (int), 1, f1),  !feof (f1))

printf (“\n%d”, i);

fclose (f1);

}

Note:  Statement

while (fread(&i, sizeof(int),1, f1),!feof(f1))

printf(“\n%d”, i);

អនុវត្ដន៍ការ Read តំលៃ i, ក្រោយមកត្រួតពិិនិត្យមើ់ល EOF ហើយឬនៅ ។

syntax:

while (Expression 1, Expression2) <Actions>;

សមមូលនឹង

do   {  Expression 1;

if (Expression2)  <Action>;

} while (Expression2);

ដូច្នេះក្នុងកមμវិធីខាងលើអាចសរសេរដូចខាងក្រោម ៖

do {     fread (&i, sizeof (int), 1, f1);

if (!feof (f1))

printf (“\n%d”, i);

} while (!feof (f1));

–  ឬ បើយើងដឹងចំនួនធាតុជាមុន នោះយើងសរសេរ

for ( i = 1; i <= 100; i++)

fread (&i, sizeof (int), 1, f1);

–  កុំភ្លេច open file data ប្រភេទ binary “rb” ។

* ឥឡូវយើងធ្វើឧទាហរណ៍ជាក់ស្ដែង: ឧបមាថាមាន file INTEGER.Dat ផ្ទុកចំនួនពី1 ដល់1០០។ យើង Read ធាតុទី1និងទី3នៃ file ខាងលើហើយតាងអោយ Variable A,B។ Exam: Read 3ចំនួនគត់:#include<stedio.h>

#include<conio.h>

main( )

{  int A,B; long num; FILE *f1;

f1=fopen(“Integer.DAT”,”rb”); fread (&A, sizeof (int),1,f1); fread (&B, sizeof (int),1,f1); fread (&B, sizeof (int),1,f1); printf (“\n A=%d”,A);

printf (“\n B=%d”,B);

fclose (f1); getgh( ); return 0;

}

Example: Copy ពី file នៃចំនួនគត់ទៅ file ផ្សេងទៀត។ កមμវិធីសរសេរក្រោមរាង Function:

Ex: copy file of integer:

#include < stdio.h>

#include < conio.h>

main( )

{ char filename1 [21];

char filename2 [21];

int i;

FILE  *f1,*f2;

printf (“Name file source:”); scanf (“%20s”,&filename1);

f1=fopen (filename1,”rb”);

prinf (“Name file destination :”); scanf (“%20s”,&filename2);

f2=fopen (filename2, “wb”);

while (fread(&i, sizeof(int),1,f1),! feof (f1))

{

fwrite (&i, sizeof(int),1,f2);

}

f close (f1); f close (f2); return 0;

}

 III.3/ write-read file ដែលមាន Data ប្រភេទ struct :

Example: បង្កើត file ដែលមានទិន្នន័យជា struct:

#include<stdio.h>

#include<conio.h>

#include<string.h>

#define TRUE 1

char ss[80];

typedef struct {

int day;

int month;

int year;

}   date;

typedef struct {

char name[80] ;

int homenum;

char street[80] ;

char city[30] ;

float salary;

date dob;

}  person;

person read_screen (person poeple);

FILE *fpt;

main( )

{int flag = TRUE;

person poeple;

fpt = fopen (“LIST.DAT”,”wb”);

person. salary = 0;

while (flag)

{     printf (“\n Name:”); gets (people. name);

if (people. name[0]= = ‘\0’)

break;

people = read_screen(people);

fwrite (&people, sizeof (person),1,fpt);

}

fclose (fpt);

}

*/ ——————- */

person read_screen (person  people)

{  printf (“Enter day/ month/ year : ”);

scanf     (“%d%d%d”,    &people.dob.day,           &people.dob.month,

&people.dob.year);

printf (“Home number : ”); scanf (“%d”, &people.homenum);

gets (ss); /* or while (getch ( ) ! = ‘\n’); */

printf (“City : ”);

gets (people.city);

printf (“Street : ”).

gets (people.street);

printf (“Salary :”); scanf (“%f”, &people.salary);

gets (ss);

return (people);

}

Exam: read data from file struct :

មុននឹង  read  file  of  struct  យើងត្រូវដឹង  struct  នោះជាមុនៈ  មាន  field  ណាខ្លះ  ? ប្រភេទទិន្នន័យរបស់ field នីមួយៗ …

# include <stdio.h>

# include <conio.h>

# include <string.h>

#define TRUE 1

typedef struct {  int day;

int month;

int  year;

}  date;

typedef struct {  char name[80]; int homenum; char street[80]; char city[30]; float salary; date dob;

}  person; void write_screen (person); FILE  *fpt;

main ( )

{  person people;

fpt = fopen (“LIST.DAT”, “rb”);

while (fread (&people, sizeof(person), 1, fpt), !feof (fpt))

{     write_screen (people);

}

fclose (fpt);

return 0;

}

void write_screen (person people)

{     printf (“Name :%s \n”, people.name);

printf   (“Date of  birth   :%2d/    %2d/    %2d     \n”, people.dob.day,people.dob.month,

people.dob.year);

printf (“Home number :%d \n”, people homenum);

printf (“Street :%s \n”, people.street);

printf (“City :%s \n”, people.city);

printf (“Salary :%8.2 f\n\n”, people.salary);

}

Note:   ក្នុងឧទាហណ៍ខាងលើ, យើងគប្បីចំណាំការ Declaration និង open file ដើម្បី read ជាមួយ

“rb”, និង open file ដើម្បី write ជាមួយ “wb” ។

IV. Access ដោយផ្ទាល់ទៅធាតុរបស់ file binary :

ក្នុង C ដើម្បី access ដោយផ្ទាល់ទៅធាតុណាមួយរបស់ file យើងប្រើ fseek :

fseek (fptr, No*sizeof(one_record), SEEK_SET);

Note:


 +  fptr: ជា pointer file, វាអាចមានឈេμាះផ្សេងៗ …
+  No:  ជាទីតាំងនៃលេខរៀងរបស់ធាតុក្នុង file ។ (ធាតុទីមួយរបស់ file មានលេខរៀង (index) សេμី 0) តែពេលយើងប្រើគឺ ចាប់ ផ្ដើមពីលេខ ១ ។

+  sizeof(onerecord), ច្រើនតែអនុវត្ដន៍ដោយ function sizeof ( ) ។ ដូច្នេះកន្សោម ៖

No *sizeof(onerecord) ;

+ parameter ចុងក្រោយក្នុង statement មាន៣ ករណីៈ

SEEK_SET (ឬ 0)  រំកិលគណនាទីតាំង access ចាប់ពីដើម file

SEEK_CUR (ឬ 1) រំកិលគណនាពីទីតាំង current pointer file ទៅចុង file ។
SEEK_END (ឬ 2) រំកិលគណនាពីចុង file មកវិញ

* យើងនិងស្រាវជ្រាវការ Access ដោយផ្ទាល់ទៅក្នុង file

+  Read data from Keyboard  និង create new

+  Read again data from file.

+  Update, data …

Ex:    Access ដោយផ្ទាល់, file ដើម្បី Read : ឧបមាយើងមាន file  នៃបណ្ដាចំនួនគត់ នឹងចង់

access ដោយផ្ទាល់ដើម្បី Read  ធាតុទី No :

# include <stdio.h>

#include <conio.h>

main  ( )

{  char filename[21];

int n;

int No;

FILE *f1;

printf (“ Name file:”);  scanf (“ %20s” , filename);

f1 = fopen (filename, “ r” );

while (printf (“No :”),scantf (“ %d”,&No)

{fseek (f1, size(int) *(No-1), SEEK_SET);

fread (&n, sizeof (int), 1, f1);

printf (“ Value find is : %d \n”, n);

}

fclose(f1); getch();

}

Note: ឧទាហរណ៍ខាងលើអនុញ្ញាតិអោយយើង Read ដោយផ្ទាល់ Value នៃធាតុណាមួយក្នុង file ។

Ex:  access ដោយផ្ទាល់ដើម្បី update data:

# include <stdio.h>

#include <conio.h>

main  ( )

{  char filename[21];

int n;

long num;

FILE *f1;

printf (“ Name file :” ); scanf (“ %20s”,filename)

f1 = fopen (filename,” w”);

while (printf (“No :”), scanf(“ %d”, &num),num)

 

{printf (“value update:” );  scanf (“ %d”, &n); fseek (f1,sizeof (int)*(num –1), SEEK_SET); fwrite (&n, sizeof (int), 1,f1);

}

fclose(f1);

}

Ex:  access ដោយផ្ទាល់ : write និង read:

# include <stdio.h>

#include <conio.h>

int main (vod)

{  FILE *strem;

char msg[ ] = “ this is a program for example !”;

char buf[20];

if ((stream = fopen  (“ DUMMY.FIL”, “w+” )) == NULL)

{  fprintf (stderr, “cannot open output file.\n”);

return 1;

}

fwrite (msg,strlen (msg) +1, 1, stream);

fseek (streem, SEEK_SET, 0);

fread (buf,strlen(msg) +1, 1, stream);

printf (“ %s\n”, buf);

fclose (stream);

return 0;

}

 Ex:  update file struct ខាងលើៈ (file LIST.DAT) :

# include <stdio.h>

#include <conio.h>

# define TRUE 1

typedef struct   { int day;

int month;

int year;

}  date;

typedef struct   { char name[80];

int homenum;

char street[80];

char city[30];

float salary;

}  person;

void write_screen (person);

FILE *fpt;

main ( )

{  person  people;

 

int No;

long size, pos;

fpt = fopen (“LIST.DAT”, “rb”);

fseek (fpt, 0, SEEK_END);

size = ftell(fpt);

printf (“No :”); scanf (“%d”, &No);

pos = No *sizeof (person);

if (No < 0 || pos > size)

printf (“\nHave no record in file”);

else

{  fseek (fpt, pos –1, 0);

fread (&people, sizeof (person), 1, fpt);

write_screen (people);

}

}

void write_screen (person people) {dUcxagelI}

 IV.1. Text Files :

បណ្ដាធាតុរបស់ Text file គឺជាបណ្ដា characters, string, text  ។

បណ្ដា Function write ទៅក្នុង text file :

putc (ch, fptr); write 1 character ទៅក្នុង text file

fputs (str, fptr); write string ទៅក្នុង text file

fprintf (fptr,…); សមមូល printf ( )

Ex:  write string នៃបណ្ដា អក្សរធំទៅក្នុង file:

កមμវិធីនេះ Read 1 បន្ទាត់ character ពី keyboard និង write ទៅក្នុង text file:

# include <stdio.h>

main ( )

{  FILE *fpt;

char c;

fpt = fopen (“c:\\tc\\sample.Dat”, “w”);

do {  putc (toupper (c = getchar ( ) ), fpt);

}  while (c! = ‘\n’);

fclose (fpt);

}

ª ចំណាំ  នេះជា Function គណនា text file. ។ Statement putc ប្រាប់អោយយើងដឹងថានេះជា

file text ។ ជា statement write 1 character ទៅក្នុង text file ។

ªStatement openfile :

fpt = fopen (“c:\\tc\\sample.dat”, “w”);

 IV.2.Read data from text file : ដើម្បីបើក file text :

fopen (…, “r”);

ចំណាំ ៖ “r” មានន័យថា Read only

Read data from text file :

ការ Read បណ្ដាធាតុពី file ក្រោយពីបើក file ហើយ ៖

getc (fptr); Read charater form text file

fgets (str, fptr); Read string str ពី text file fptr ។

fscanf ( ); Read បណ្ដា Value ពី text file, សមមូល scanf ( );

# include <stdio.h>

main ( )

{  FILE *fpt;

char c;

if ((fpt = fopen (“C:\\TC\\sample.DAT”, “r”)) == NULL)

printf (“\a\n Erro, Cannot open file”)

else

do { putchar (c = getc (fpt));

}  while (c! = ‘\n’);

fclose (fpt);

}
C C++

IV.3.  លំហាត់អនុវត្ដ ៖

ឧទាហរណ៍ខាងក្រោមអធិប្បាយពីការ write និង Read បណ្ដា Record ទៅក្នុង text file ។

# include <stdio.h>

# include <conio.h>

# include <string.h>

# define TRUE 1

typedef  struct  {  int day;

int month;

int year;

}  date;

typedef struct   {  char name[80]; int homenum; char street[80]; char city[30]; float salary; date dob;

}  person;

person read_screen (person people); void write_file (person people); FILE *fpt;

char ss[80];

main ( )

{  person people;

int flag = TRUE;

fpt = fopen (“LIST.DAT”, “w”);

people.salary = 0;

while (flag)

{  printf (“\n Name:”); gets (people.name);

if (people.name[0] == ‘\0’)

break;

people = read_screen (people);

write_file (people);

}

fclose (fpt);

}

person read_screen (person  people)

{  printf (“Enter day /month/ year:”);

scanf         (“%d%d%d”,         &people.dob.day,         &people.dob.month,

&people.dob.year) ;

printf (“home number :”);

scanf (“%d”, &people.homenum);

gets (ss);      /* or while (getchar ( ) != ‘\n’);

printf (“street:”); gets (people.street); printf (“city:”);  gets (people.city); printf (“salary:”);

scanf (“%f”, &people.salary);

gets (ss);

return (people);  }

void write_file (person people).

{  fprintf      (fpt,      “%d%d%d\n”,      people.dob.day,      people.dob.month,

people.dob.year);

fprintf (fpt, “%d\n”, people.homneum);

fprintf (fpt, “%s\n”, people.street);

fprintf (fpt, “%s\n”, people.city);

fprintf (fpt, “%f\n”, people.salary);

}

IV.4.  បណ្ដាឧទាហរណ៍គណនា text :

ក្នុងផ្នែកនេះយើងសិក្សាពីបណ្ដាឧទាហរណ៍គណនា file text ដូចជា copy file, រាប់ចំនួនបន្ទាត់ទៅក្នុង

text file :

Ex: រាប់ចំនួនបន្ទាត់ទៅក្នុង text file:

# define EOF –1

# define EOL 0x0A     /* or ‘\n’ */

int ch, count;

ch = getch ( ); count = 0;

while (ch != EOF)

{  while (ch != EOL) ch = getchar ( );

count ++;

ch = gatchar ( );

}

ឬសរសេរម្យ៉ាងទៀតខ្លីជាង ៖

# define EOF   –1

# define EOL 0x0A     /* or ‘\n’ */

int ch, count = 0;

ch = getchar ( );

while ((ch = getchar ( )) != EOF)

while ((ch = getchar ( )) != EOL)

cout ++;

Ex:  រាប់ចំនួន character ឬ គណនាទំហំរបស ់ file :

ចូររាប់មើលក្នុង file មួយមានផ្ទុកប៉ុនμាន character ?

# include <stdio.h>

# include <conio.h>

# include < stdlib.h>

main (int argc, char  *argv[ ])

{  int ch;

char filename[20]; FILE *fp;

long count = 0;

printf (“\n Name file :”);  scanf (“%s”,&filename);

fp = fopen (filename, “r”);

while ((ch = getc(fp)) != EOF)

 

{  putc (ch, stdout);         /*Display character on screen);

count ++;

}

fclose (fp);

printf (“file %s have got %ld character.”, filename, count);

return 0;

}

Note:

+ កមμវិធីខាងលើអនុវត្ដន៍តែចំពោះ text file ដែលផ្ទុក character ក្នុងតារាង code ASCII ។

+  ចំនួន character ដែល Display on screen តិចជាងចំនួន byte ជាក់ស្ដែងរបស់ file ។ ព្រោះ

Function getc ( ) មិនរាប់ character, ដើមបន្ទាត់ ‘\r’ ។  function getc ( ) ចាត់ទុក character

‘\r’ និង ‘\n’ តែមួយ character ប៉ុណ្ណោះ ។

ដូច្នេះដើម្បីរាប់អោយត្រឹមត្រូវចំនួន byte ក្នុង file, នោះយើងត្រូវ openfile ដើម្បី Read ជា “rb”:

if ((fp = fopen (argv[1], “rb”)) == NULL)

ពេលនោះ  function  getc  (  )  នឹងមិនបែងចែក  character  ទៀតវាគណនាគ្រប់  character

ទាំងអស់និងរាប់ ចំនួន byte ទាំងអស់ក្នុង file ។

VI. បណ្ដា function គណនា  file របស់ turbo C:

frewind( ): នាំ cursor file ទៅទីតាំងនៃធាតុដំបូងរបស់ file

Ex:      ខាងក្រោមនឹង  Display      ឡើងវិញ  អត្ថន័យរបស់  file   ដែលទើបនឹងបង្កើតឡើង  ។

ដើម្បីធ្វើការងារនេះ ដំបូងត្រូវនាំ cursor file ទៅទីតាំងនៃធាតុតំបូង, បន្ទាប់មកប្រើ function fgets ( )

ដើម្បី Read ឡើងវិញបណ្ដា តំលៃរបស់ file ។

# include <stdio.h>

# include <stdlib.h>

# include < conio.h>

# include <string.h>

main ( )

{  char str[80];

FILE *fp;

if ((fp = fopen (“TEST”, “w+”)) == NULL)

{  printf (“Cannot open file .\n”);

exit (1);

}

do {  printf (“Enter string:”); gets(str);

strcat (str, ‘\n’);                /* add new line */

 

fputs (str, fp);

}  while (*str != ‘\n’);

/* Now Read And Display Data of  file */

frewind (fp);

while (!feof (fp))

{ fgets (str, 79, fp);

printf (str);

}

getch ( );
return 0;

}

+ ferror ( ):

Function ferror ( ) កំណត់ការគណនា file មានកំហុស ឬអត់ ?

– ផ្ដល់តំលៃ TRUE បើមាន error

– ផ្ដល់តំលៃ FALSE បើគμាន error

យើងគប្បីប្រើ ferror ( ) ក្រោយពី statement គណនា file :

–  ch = getc (fp);

if (ferror (fp))…

–  putc (ch,fp);

if (ferror(fp))…

+ remove ( ):

Function remove ( ) នឹង delete file ចេញពី disk ។

fflush (stdin) ;

+  fflush ( ): ប្រើសំរាប់ clear stdin

 VII.  បញ្ជូន parameter ជា   file ទៅអោយ  function :

Ex:  copy file ពីរៈ

# include <stdio.h>

main  (int argc, char  *argv[ ])

{  FILE  *fp;

void filecopy (FILE  *, FILE  *);

if (argc == 1)

filecopy (stdin, stdout);

else

while  ( — argc > 0)

if ((fp = open (* ++ argv, “r”)) == NULL)

{  printf (“Cannot open %s \n”, *argv);

return 1;

}  else  {     filecopy (fp, stdout);

fclose (fp);

}

return 0;

}

void filecopy (FILE  *fpi, FILE  *fpo)

{  int c;

while ((c = getc (fpi)) != EOF)

}

 

យើងអាចសរសេរដោយរបៀបម្យ៉ាងទៀតគឺ ៖

# include <stdio.h>

# include <stdlib.h>

main (int argc, char *argv[ ])

{  FILE *in, *out;

char ch;

if (argc != 3)     { printf (“\n fore got namefile:”);

exit (1);

}

if  ((in = fopen (argv[1], “rb”)) == NULL)

{  printf (“Cannot open source file \n”);

exit (1);

}

if ((out = fopen (argv[2], “wb”)) == NULL)

{    printf (“cannot open destination file.\n”);

exit (1);

}

while (!feof (in))  { ch = getc (in);

if (!feof (in)) putc(ch,out);

}

fclose (in);

fclose (out); gatch ( );

return 0;

}

# include <stdio.h>

# include <stdlib.h>

main (int argc, char *argv[ ])

{  int ch;

FILE *fp;

long count = 0;

if (argc != 2)     {  printf (“use :%s name file, argv[0]);

exit (1);

}

if ((fp = fopen (argv[1], “r”)) == NULL)

{  printf (“Cannot open %s”, argv[1]);

exit (1);

}

while ((ch = getc(fp) != EOF)

{ putc (ch, stdout);

count ++;

}

fclose (fp);

printf (“file% have %ld charaacter”, argv[1], count);

return 0;

}

 

សំនួរ

 1).  តើអាចប្រើ Function gets (fp,…) ដើម្បី Read បណ្ដាចំនួនគត់ក្នុង file F: int *F ?

2).  អាចប្រើកមμវិធី text Editor ដើម្បីមើលអត្ថន័យបណ្ដា file int *F, float *F មានឬអត់ ? ព្រោះអ្វី?
3).  command TYPE, PRINT របស់ Dos អនុវត្ដន៍ជាមួយ file ប្រភេទណា ?

 

លំហាត់

 1).  សរសេរកមμវិធី create file F3, ផ្ទុកបណ្ដាចំនួនគត់, ដោយរបៀបភ្ជាប់ 2 file នៃចំនួនគត់ F1 និង F2ជាមួយគ្នា ។

2).  សរសេរកមμវិធីរាប់ចំនួន character ក្នុង text File មួយឈេμាះ F ។

3).  គូសឬសរសេរកមμវិធីបង្កើត file នៃចំនួនមួយ, ដោយ Read បណ្ដាចំនួនគត់ពី text File មួយទៀត ។

បន្ទាត់ នីមួយៗរបស់ text file អាចមានផ្ទុក ឬគμានផ្ទុក ចំនួនគត់, ឬមានផ្ទុកបណ្ដាចំនួនគត់មួយចំនួន ។

5).   សរសេរកមμវិធីបង្កើត  text file ផ្ទុកឈេμាះ,  អាយុ, អាស្រ័យដ្ឋាន របស់អ្នក ។ ក្រោយមកកមμវិធីនឹង

Read file នេះឡើងវិញដើម្បី print ទៅ printer អត្ថន័យខាងលើ (ដោយមនុស្សម្នាក់នៅលើបន្ទាត់តែ១)។

6).     ក្នុងពេល   open    file    ថμីយើងកំពុង open,   នោះ   file     ចាស់ត្រូវបានលប់ចោល        ។

ចូររកវិធានណាដើម្បីបើជួប   ករណី      នេះអោយវាប្រាប់យើងថា,fileនេះមានស្រាប់នៅលើ   Disk ហើយ,អ្នកក៏ចង់លុបវាចោល ដើម្បីបង្កើត ថμី ឬអត់ ?

7).  សរសេរកមμវិធីគណនាចំនួនបន្ទាត់ដែលមានក្នុង text file មួយ ។

8).  សរសេរកមμវិធី   Display    បណ្ដា  file    ទាំងអស់  ។    ក្រោយ មក យើងអាចលុប  file ណាមួយដែលយើងចង់លុប ។

9).   សរសេរកមμវិធីប្ដូរឈេμាះ file ។ មានន័យថា ត្រូវសរសេរ rename មាន Read parameter ។

10). ឧបមាមាន file text, ដែលបណ្ដាបន្ទាត់នីមួយផ្ទុកពី ១ដល់ ១០០ character ចូរសរសេរកមμវិធីបង្កើត

file ថμីមួយដែលបណ្ដាបន្ទាត់របស់វាផ្ទុកត្រូវ 100 character, បណ្ដា character Read from keyboard

មេរៀនទី១១: Data Structures

មេរៀនទី១១: Data Structures
C C++
I. Say about pointer again : 
pointer ជា variable ផ្ទុក Address (មិនមែនផ្ទុកតំលៃទេ) ដូច្នេះ  *p ជាទិន្នន័យដែលផ្ទុកក្នុង Address p.   ឬនិយាយ ម្យ៉ាងទៀត p ជា pointer point to variable ដែលផ្ទុក value *p  ។
II.  Dynamic variable: បណ្ដា variable  មានប្រភេទទិន្នន័យ, ដែលយើងធ្លាប់សិក្សាកន្លងមកដូចជា Array, int, float …

ហៅថា static  variable  ព្រោះវាត្រូវបានកំណត់និយមន័យជាស្រាច់មុនពេល Declaration  variable  ។ រយៈពេលកកើត static variable គឺជារយៈពេលនៃ ការកកើតនូវកំណាត់កមμវិធីដែលផ្ទុកវាដែរ ។ តែបណ្ដា Variable ក៏អាចត្រូវបានក៏កើតដោយរបៀប dynamic .  មានន័យថា កកើត ឡើងនៅពេលយើង Run កមμវិធី ។ ដូច្នេះ Variable នេះមិន ត្រូវ បានកំណត់និយមន័យជាមុនទេ ។ Variable ប្រភេទនេះហៅថា Dynamic variable  ។

Dynamic  variable  គμានឈេμាះទេ  (ព្រោះការដាក់ឈោμ ះការពិត  គឺការតាងអោយវានូវ Address កំណត់មួយ)   ។  ការបង្កើត Dynamic variable និងលុបវាទៅវិញ ត្រូវអនុវត្ដន៍ដោយផ្នែកបណ្ដា function ដូចជា malloc ( ) និង free ( ) ដែលមានស្រាប់ក្នុង Library  <stdlib.h>  ។  ការ Access ជាមួយ

Dynamic variable ត្រូវអនុវត្ដន៍ដោយផ្អែកបណ្ដា Variable ប្រភេទ pointer (Pointer Variable ) ។ បណ្ដា pointer Variable ត្រូវ កំណត់ ទិន្នន័យ ដូចជា Static Variable ដែរ ។ (មានន័យយថា មានឈេμាះ និងត្រូវ  Declaration  ភ្លាមនៅផ្នែកខាងដើមក្នុងផ្នែក Declaration  Variable  និងត្រូវបានប្រើដើម្បីផ្ទកុ Address របស់បណ្ដា Dynamic Variable ) ។Ex1:  Declaration pointer និងបង្កើត Dynamic Variable:

int *pNumber;    /*Declaration pointer variable*/

pNumber = (int*) malloc (100) ; /*Create Dynamic Variable*/ កំណាត់កមμវិធីខាងលើផ្ដល់អោយយើង  100 bytes ក្នុង memory និងតាង Address of memory នេះទៅអោយ pNumber   .   100 bytes នេះប្រើសំរាប់ផ្ទុក 5០ ចំនួនគត់។                                           បើចង់ បាន memory

អោយត្រឹមត្រូវសំរាប់ 75 ចំនួនគត់, យើងសរសេរដូចខាងក្រោម ៖

int *pNumber;

pNumber = (int*) malloc (75*sizeof (int));

ដូចគ្នាចំពោះបណ្ដាការ Declaration ផ្សេង, យើងសរសេរ ៖

char  *cPtr;
cPtr  = (char *) malloc (l50*sizeof (char));

float *fPtr;

fPtr =  (float*)  malloc (55*sizeof (float));

យើងនិងសិក្សាឧទាហរណ៍ស្ដីអំពិី malloc function ដូចខាងក្រោម ៖

Ex2: ប្រើ Function malloc (memory allocaion)

# include <stdio.h>

# include <conio.h>

# include <string.h>

# include <alloc.h>

# include <process.h>

int main (void)

{    char *str ;    /*allocate memry for string*/

if ((str = ( char *) malloc (10) = = NULL)

{    printf (“\n there isn’t enough memory”)

exit (1);

}

/* copy “Hello” into string */

strcpy (str, “Hello”);

/* free memory */

free (str);
return 0;

}

Note:  ក្នុងឧទាហរណ៍ខាងលើ, យើងបាន Declaration pointer string str ។ បន្ទាប់មកកំណាត់កមμវិធី

if ((str = (char*) malloc (10) = = NULL)

{    printf (“\n there isn’t enough memory”);

exit (1);

}

និងរៀបចំ dynamic  memory  សំរាប់  10  chapters និងក្នុង ដំណាក់ កាលនេះមានការត្រួតពិនិត្យមើល computer មាន memory គ្រប់ គ្រាន់ ឬអត់ ? ដោយរបៀបត្រួតពិនិត្យមើល លទ្ឋផល pointer str មានតំលៃជា NULL ឬអត់ ?

យើងអាចប្រើ function farmalloc ដើម្បីផ្ដល់នូវ memory ធំជាង malloc ។

Function exit (1) យកចេញពី file < process.h> Statement (char *) malloc (10)

យើងយល់ថា  រៀបចំផ្ដល់  dynamic  memory  ប្រភេទ  char  និង  លទ្ឋផលរបស់វាជា  Address តំបូងរបស់  memory  .  Function  នេះអនុវត្ដន៍ចំពោះប្រភេតទិន្នន័យ ៖  int,  float,  long,  char, double ….
C C++លទ្ឋផលរបស់ statement នេះជានិច្ចជាកាល ជា address មួយ  និងជា Address ដំបូងរបស់ memory ដែលត្រូវផ្ដល់, ក្នុងនោះ data type ជាទិន្នន័យ ។

 Syntax: (datatype*)

ជាប្រភេទ  pointer  ។  ឧទាហរណ៍    (float)  n  មានន័យថា  convert  n  អោយទៅជាចំនួនពិត  ។ (datatype *) convert ជាប្រភេទ pointer point to datatype ។ ដូច្នេះយើងអាចសរសេរដូចខាងក្រោម ៖
pointer malloc(sizeof(memory))

 ក្នុងការណ៍ចង់បង្កើត  Dynamic  memory  អោយប្រភេទទិន្នន័យ  មិនមែនជា  int,  float,  long, double, ពោលគឹប្រភេទ ទីន្នន័យដែលយើងជាអ្នកបង្កើត, យើងត្រូវប្រើ function calloc ( ) .
Syntax:
(datatype*) calloc (n, sizeof (object));

Ex:

struct   persont  {

char name[80];

int age;

char Address[25];

};

struct person *ptr; /*  Declaration  pointer  person  */   ហើយយើងបង្កើត memory

សំរាប់អោយ 10 នាក់ ដូចខាងក្រោម ៖
calloc (10, sizeof (struct  person));

 Ex3:   ប្រើ Function calloc អោយ string :

# include <stdio.h>

# include <alloc.h>

# include <string.h>

int main (void)

{    char *str = NULL ;

/* allocate memory for string */

str = (char *) calloc (10, sizeof (char));

/* copy “Hello” into string */

strcpy (str, “Hello”);

/* display string */

printf (“\n String is %s \n”str);

 

/* free memory */

free (str);

return 0;

}

Function realloc ( ) ជា function បង្កើតឡើងវិញនូវ memory :
(datatype *) realloc (buf_ptr, newsize);

ក្នុងនោះ buf_ptr ជា pointer កំពុង point to memory ដែលត្រូវ បានបង្កើត ផ្ដល់អោយពីលើកមុន។ newsize ជាទំហំថμី ដែលត្រូវ បង្កើត និងផ្ដល់ អាចធំជាង ឬតូចជាងមុន ។

Ex4:

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

int main (void)

{      char  *str ;

/* allocate memory for string */

str = (char *) malloc (10);

strcpy (str, “Hello”);

printf (“ \n string %s \n Address %p \n”, str, str);

str = (char*) realloc (str,20);

printf (\n string %s \n New Address %p \n”str, str);

free (str);

return 0;

}

III. Heap memory និងរបៀបបង្កើត  Dynamic variable :

បណ្ដា dynamic variable ដែលបង្កើតឡើងដោយ malloc ត្រូវបាន C រៀបទៅក្នុង Block free memory ហៅថា HEAP  ។ ភាសា C គ្រប់ គ្រង Heap តាមរយៈ pointer of Heap គឺ HeapPtr  ។ pointer of Heap ជានិច្ចជាកាល point to bype free ដំបូងរបស់ Block free memory របស់ Heap ។ រាល់ពេល call malloc ( ), pointer  of Heap ត្រូវបាន ផ្លាស់ទីតាំងផ្នែកខាងលើនៃ block free memory បណ្ដា byte មួយចំនួនសមមូល នឹងទំហំរបស់ dynamic variable ដែលទើប បង្កើត បាន។ ចំពោះអ្នកសរសេរកមμវិធី, Heap គឺជាមូកដ្ឋានគ្រឹះដែល ត្រូវក្ដាប់អោយបាន ។

C C++Ex5:  រកចំនួន prime

 # include <stdio.h>

# include <conio.h>

main ( )

{long  *primes = NULL,  *start = NULL,  *open = NULL, trial = 0;

int  i = 0, found = 0; total = 0;

 printf (“\n How many primes :”); scanf (“%d”, &total);

primes = (long*) malloc (total*sizeof (long));

if (primes = = NULL)

{printf (“\n there isn’t enough memory !!”);

return 0;

}

/*  3 primes តំបូងដែលយើងដឹង */

*primes = 2;

*(primes+1) = 3;

*(primes+2) = 5;

open = primes + 3;  /* យក Address free បន្ដរបន្ទាប់ទៀត */

trial = 5;

do  {      trial + =2;  /* យកតំៃ់បន្ដបន្ទាប់ទៀតដើម្បីត្រួតពិនិត្យ */

start = primes;  /* start point to ផ្នែកដំបូងរបស់prime */

found = 0;

for (i = 0; i < open-primes;  i++)

if (found = (trial % *start ++) = = 0) break;

if (found = = 0)  /* រកឃើញចំនួនថμី */

*open ++ = trial;

}      while (open – primes < = total);

for (i = 0; i <5 *(total /5); i+ = 5) /*display 5 លេខម្ដង */

printf (“\n%12ld %12ld %12ld %12ld %12ld”,  *(primes + i),

* (primes +i + 1), *(primes + i +2), *(primes +i +3),

*(primes +i + 4));
printf (“\n”);

for (i = total – (total%5);  i < total; i++ )

printf (“%12d”, (primes +i ));   /*display ផ្នែកនៅសល់ */

}

The Result is

C C++IV.  Linked List : ពេលយើងចង់បង្កើត List មួយ, ឧទាហរណ៍ List of Employee, ហើយយើងដឹងចំនួន មនុស្សពិតប្រាកដ នោះយើងអាច ប្រើ Array of struct ដើម្បីបង្កើត ព្រោះវាមានលក្ខណៈងាយស្រួល ។ តែបើយើងមិនស្គាល់ចំនួនមនុស្សជាមុននោះ យើងគប្បីប្រើ Dynamic Variable, ព្រោះវាមានលកμ្ខណៈ ក្នុងការសន្សំសំចៃ memory  (ពេល ណាយើងត្រូវការទើបយើងបង្កើតវាមកប្រើ) ។ Memory ប្រើ សំរាប់ static Variable ទាំងអស់ក្នុង computer  IBM_PC គឺមានតែ 64KB ពោលគឺមួយ Segment ។

 a/   Create a Linked List: ចូរសរសេរកមμវិធីបង្កើត Linked List នៃ employee មួយ

Ex:

# include <stdio.h>

# include <conio.h>

# include <alloc.h>

struct employee  { char name[30];

int  age;

struct employee  *next;

};

main ( )

{    struct employee  *last; struct employee  *ptr; char name[30];

last = NULL;

/*  Read form Keyboard to List */

do  {  printf (“\n name :”); gets (name);

if (name[0] != ‘\0’)

{ ptr = calloc  (1, sizeof (struct employee ));

/*Read Value of employee */

strcpy (ptrÆname, name); /*ptrÆname = name */

printf (“\n Age :”);  scanf (“%d”, &ptrÆage);

while (getchar ( ) != ‘\n’);

ptrÆnext = last;

last = ptr;

}

}  while (name[0] != ‘\0’);

/*  control and read again to list */ printf (“\n\n List of Employee :”); ptr = last;

while (ptr != NULL )

{ printf (“Name : %s \n”, ptrÆname);

printf (“Age : %d \n\n”, ptrÆage);

ptr = ptrÆnext;   /* ptr point to next record */

} getch ( ); return 0;

}

Explain:  ឧបមាយើង Read បញ្ចូលតាមលំដាប់ ៖ Mr one, 1 age, Mr two, 2 age…

last គឹជា pointer Variable, ជានិច្ចជាកាល point to last of list ។   ពេលចាប់ផ្ដើម Run program គឺយើងតាង

 last = NULL មានន័យថា List Empty ។
C C++C C++Loop ទី២ៈ ptr = calloc (1, sizeof (struct employye));

strcpy (ptrÆname, name);

printf (“Age :”), scanf (“%d”, &ptrÆage);

while (getchar ( ) != ‘\n’);
C C++ptr Æ next = last;

last = ptr;

C C++Linked   List ដូចខាងលើហៅថា  LIFO  (Last  In,  First Out)     ហៅថា  Stack(ចូលមុនចេញក្រោយ, ចូលក្រោយចេញមុន) ។
Name : MrOne
Age   : 1

Name: Mr two

Age  : 2

List of Employee: Name : Mr Two

Age    :  2

Name : Mr One

Age    : 1

b/   Insert : ពេលនេះយើងចង់ថែមធាតុថμីទី៣  (Mr Three, Age 3) ទៅកណ្ដាលធាតុពីមុនៈ (ឧបមាថាយើងប្រើ last ជៅ pointer point to last of list ដូចខាងលើ )

struct employee  *Q;

Q = calloc (1, sizeof (struct employee));

strcpy (QÆname, “Three”); QÆAge = 3;

/* find position to insert */

ptr = last;

while ((ptr != NULL) && (strcmp (ptrÆname, “Mr Two”)))

ptr = ptrÆnext;

QÆnext = ptrÆnext;

ptrÆnext = Q;

C C++c/   Function Create List : ក្នុង  ផ្នែកខាងលើ,  យើងបានបង្កើត  Linked   List  ដូចក្នុងឧទាហរណ៍,  យើងចង់  updat វាថែម ទៀត ដោយ ប្រើ Function create List :

 Void create_list (struct people  ** first);

ក្នុងនោះយើងប្រើ first ជៅ pointer point to pointer point to ធាតុ មួយ របស់ list   ។ មានន័យថាយើងថែមធាតុថμី  (New record) មួយទៅក្នុង list របស់យើងត្រង់ទីតាំងដែល pointer first មុននេះ កំពុង point to នោះ ។

Ex7:  Function create list :

# include <stdio.h>

# include <conio.h>

# include <stdlib.h>

# include <alloc.h>

struct person    {char name[30];

int age;

struct person *next;

};

void create_list (struct person **first);

main ( )

{struct person  *last;

create_list (&last);

printf (“\n\n List of Employee : \n”);

ptr = last;

while (ptr!= NULL)

{printf (“Name :%s \n”, ptrÆname);

printf (“age :%d \n\n”, ptrÆage);

ptr = ptrÆnext;   /* ptr point to next record */

}

getch ( );

return 0;

 }

void create_list (struct person  **alast)

 {    struct person  *ptr;

 char name[30];

*alast = NULL;

do  {printf (“\n Name :”); gets(name);

 if (name[0]; != ‘\0’)

 { ptr = colloc (1, sizeof(struct person));

strcpy (ptrÆname, name);

printf (“Age :”);

scanf (“%d”, &ptrÆage); while (getchar ( ) != ‘\n’); ptr Æ next =  *alast;

*alast = ptr;

}

}

while (name[0] != ‘\0’);

}

 d/  Delete :

ផ្ទុយពី insert, ពោលគឺលុបមួយ Record ចេញពី List, ។    ឧទាហរណ៍ ចង់លុប record ដែលមានឈេμាះ Tree ចេញពី list ពេលនោះ យើងត្រូវ ប្រើ Q ក្នុងពេលរក Record ដែលមានឈេμាះ Three ។ ពេលរកឃើញហើយយើងលុបវាចេញ ដោយរបៀប ពីរយ៉ាងខុសគ្នា ។

Struct  person *Q, *P;

/*  Search record for delete */ P = last; name = “three”;

while ((P != NULL ) && (strcmp (PÆname, name )))

{    Q = P;

P = PÆnext ;

 }

/* delete */

if ( P == last ) last = PÆnext;

else QÆnext = PÆnext;

 e/  Parameter is a pointer dynamic :

dynamic Variable អាចប្រើជា Parameter  របស់ subprogram បាន, ឧទាហរណ៍ យើងសរសេរ Function Insert  ដូចខាងក្រោមៈ

void insert (person  * Q);

{ …

} ;

យើងអាចសរសេរ Function មួយដែលមានលទ្ឋផលជា pointer ។

* person TT (peron *last);

{    struct person  *p1,  *p2;

p1 = last;

last = NULL;

do  { p2 = p1Ænext; p1Ænext = last; last = p1;

p1 = p2;

} while (p1 == NULL );

return last;

};

+  មុនពេលហៅ Q = TT (last);

C C+++  ក្រោយពីហៅ Q = TT (last); Q

C C++f/ ប្រភេទទិន្នន័យ FIFO :FIFO (First In First Out) ជាប្រភេទ Memory ដែលទិន្នន័យណាចូលមុន ចេញមុន ចូលក្រោយ ចេញក្រោយ។

 Ex8:

# include <stdio.h>

# include <conio.h>

# include <alloc.h>

# include <stdlib.h>

struct  person  {char name[30];

int age;

struct  person  *next;

 }  people;

 main ( )

{    struct person  *last, *first, *ptr;

char name[30];

first = NULL;

do  {prinf (“\n Name :”); gets (name);

if (strcmp (name, “”))         /* create new record */

{ptr = colloc (1, sizeof (struct person));

strcpy (ptr Æ name, name );

printf (“Age : “);  scanf (“%d”, &ptr Æ age);

ptr Æ next = NULL;

if (first != NULL)  last Æ next = ptr;

else first = ptr;

last = ptr;

while (getchar ( ) != ‘\n’);

};

} while (name[0] != ‘\0’);

C C++

/* Record FIFO again */

ptr = first;

while (ptr != NULL)

{printf (“%s\n”, ptr Æ name);

printf (“%d\n”, ptr Æ age);

ptr = ptr Æ next;

};

}

 

សំនួរ

 1.    ឧបមាមាន x និង y មានប្រភេទជា pointer ដូចគ្នា ។ សួរថា ប្រមាណវិធីខាងក្រោម ៖

x = y ;

និង *x = *y ;

តើសមមូលនឹងគ្នាឬអត ់ ? (ចូរពន្យល ់) ?

2.     អធិប្បាយសកមμភាពរបស ់  FIFO  ដោយគូសកំនូសបំព្រួញជាមួយ  Algorithm  delete  និង

insert ។

3.     ចូរ print Address របស់ Variable ណាមួយមកលើ screen ។

4.     សរសេរកមμវិធីអធិប្បាយពីការបង្កើត Linked list

5.     ចូរពិនិត្យកមμវិធីខាងក្រោមមានកំហុសអ្វីខ្លះ ? ចូរកែកំហុស ?

struct   Myrecord { int  Num; Myrecord *next;

};

 struct   Myrecord  *Head, * Tail, *T;

{    /* ឧបមាយើងបានបង្កើត linked list 20 node, ដែល Head និង Tail point to node

ដំបូងនិង node ចុងក្រោយ ។ យើងត្រូវលុប node ទាំងអស់ក្នុងពេលតែមួយ */
T = Head;

while (T != NULL)

{Dsiplose (Head);

Head = Head Æ Next; T = Head;

};

Head NULL; Tail NULL; T NULL;

}

មេរៀនទី១២: ក្រាភិច GRAPHIC

មេរៀនទី១២: ក្រាភិច GRAPHIC
C C++
I.  សញ្ញាណទូទៅនៃ  GRAPHIC :
ការសំដែងទិន្នន័យមកលើ  SCREEN  ក្នុងTurbo  C  មានរបបពីរ  គឺ  ៖Text  ModeនឹងGraph Mode ។ Graph  Mode  មិនមែនជាខ្នាតគំរូរបស់គ្រប់ភាសា និង ម៉ាស៊ីនកុំព្យូទ័រទេ។ ព្រោះការគូសក្រាហ្វិចលើ Screen, អាស្រ័យ ដោយ ប្រភេទកុំព្យូទ័រនីមួយៗ, អាស្រ័យដោយប្រភេទ Screen នីមួយៗ ,,,,,។ ដើម្បីគូសរូប, ផាត់ពណ៍រូបភាព,,,,នៅលើកុំព្យូទ័រ,យើងត្រូវប្ដូរចរន្ដអគ្គសនីបញ្ជា Screen ពីText ModeទៅGraph Mode។

កុំព្យូទ័រ, IBM – PC/XT /AT សព្វថ្ងៃមានច្រើនប្រភេទខុសគ្នាដូចខាងក្រោម ៖
–  CGA : Color Graphic Adater : ចរន្ដអគ្គិសនីបញ្ជា Screen Color
+ (640 * 200) (មានអាប់ស៊ីស 640 Pixel, មានអរដោនេ 200Pixel ) មានពីរពណ៍
+ (320*200) មានបួនពណ៍ ។
–  MGDA : Monochrome Graphic Display Adapter ឬ Hercule :
ចរន្ដអគ្គិសនីបញ្ជា Screenស-ខេμៅ (monochrome),

+ 720 * 348 (មានអាប់ស៊ីស 720Pixel,មានអរដោនេ 348Pixel )
−    EGA : Enhanced Graphic Adapter : ចរន្ដអគ្គិសនីបញ្ជា Screen Color
+ 640 * 350 និងអាចជ្រើសរើសបាន ១៦ពណ៍ ។
–  VGA : Video Graphic Array : 640 * 480
Super VGA : 1024 * 768 : អាចជ្រើសរើសបានដល់ ២៥៦ ពណ៍។

II.  បណ្ដា  FILE របស់ Graphic : ពេលប្រើ Graphic ជាមួយ Turbo C នៅលើ Disk យើងត្រូវ Copy បណ្ដា File សំខាន់ៗ របស់ Graphic ដូចខាងក្រោម ៖

*.TPU
*.
BGI
*.CHR

នឹងនៅដើមកមμវិធី យើងត្រូវ Proto Type ដើម្បីប្រើ GRAPH.TPU ដូចខាងក្រោម ៖

# include<graphics.h>
+  បណ្ដា  File  *.BGI  (BGI  :  Borland  Graphic  Interface  )  គឺជាបណ្ដា  File
ផ្ទុកបណ្ដាឃ្លាបញ្ជា Screen ផ្សេងគ្នាដូចជា ៖

CGA.BGI ; EGAVGA.BGI ; HERC.BGI ;
+  បណ្ដា  File  *.CHR  ជាបណ្ដា  File  ផ្ទុកបណ្ដាឃ្លាបញ្ជាសំរាប់គូសប្រភេទអក្សរក្នុង Graphic។

ដូចជាបណ្ដា File ខាងក្រោមនេះ ៖

GOTH.CHR  (អក្សរ Gothic) LITT.CHR (Small Font) SANS.CHR (អក្សរ Sons Serif) TRIP.CHR (អក្សរធំជាង៣ដង ,Triplex)

ដើម្បីងាយយល់របៀបប្រើក្រាហ្វិច, យើងពិនិត្យ  ឧទាហរណ៍គូស បន្នាត់ពីមុំកែងខាងលើផ្នែក ខាងឆ្វេងចុះមក មុំកែង ខាងក្រោម  ផ្នែកខាងស្ដាំ ៖

# include<graphics.h>
# include<conio.h>

main()
{ int gd=DETECT, gm ,errorcode ; initgraph(&gd,&gm,”C:\\TC\\BGI”); errorcode =graphresult () ; if(errorcode != grOk())
{  printf(“ Graphics error : %s \n “,grapherrormsg(errorcode));
printf(“ Press any key to halt : “);  getch();
exit(1);
}
moveto(0,0) ;       (* នាំ Cursor Graph ទៅចំនុចមុំកែងខាងលើ,ផ្នែកខាងឆ្វេង *)
lineto(getmaxx(),getmaxy() ) ;     (* គូសបន្ទាត់ *)
getch();
closegraph();
}
Statement initgraph មានទំរង់ Declaration ដូចខាងក្រោម ៖

initgraph( &graphdriver , &graphmode , driverpath ) ;

គឺជា Statement បង្កើត (Greate Graphics) ក្រាហ្វិច ក្នុងនោះ ៖

+ graphdriver ផ្ទុកតំលៃកំណត់ប្រភេទ Screen :

0  DETECT  3  EGA           6  IBM8514  9    VGA
1  CGA           4  EGA 64     7  HercMono 10  PC3270
2  MCGA       5  RGAMono 8  ATT 400
+graphmode  ផ្ទុកតំលៃកំណត់ Mode  ក្រាហ្វិច ។
+driverpath ប្រាប់អោយ Turbo C ស្គាល់ Directory ដែលផ្ទុកបណ្ដា File បញ្ជាក្រាហ្វិច ។ តារាងខាងក្រោមនេះបង្ហាញឈោះរបស់បណ្ដាតំលៃរបស់ GraphDriver,graphMode :

graphdriver graphmode
CGA CGAc0,1,2,3,4 320 * 200 CGA
CGAHi 640 * 200 CGA
MCGA MCGA0,,1,,2,,3 320 * 200
MCGAMed 320 * 200
MCGAHi 640 * 480
EGA EGALo 640 * 200  Ù CGA
EGAHi 640 * 350
EGA64 EGA64 Lo 640 * 200 Ù CGA
EGA64 Li 640 * 350
EGAMono EGAMono Hi 640 * 350
VGA VGA Lo 640 * 200
VGA Med 640 * 350
VGA Hi 640 * 480
HercMono HercMonoHi 720 * 348
ATT400 ATT400 C0,1,2,3 320 * 200
ATT 400 Med 640 * 400
ATT 400 Hi 640 * 400
PC3270 PC 3270 Hi 720 * 350
IBM8514 IBM8514 Lo 640 * 480 ,, 256COLOR
IBM8514 Hi 1024 * 768 ,, 256COLOR

Statement initgraph មាន Variable 2 គឺ : &gd, &gm ។មុននេះ បើសិនជា graphdriver ត្រូវបានកំនត់ ដោយតំលៃ DETECT នោះ initgraph នឹងកំនត់យក graphdriver និង graphmode  ដែលល្អ បំផុត  (មើលក្នុង តារាង ខាង លើ)។ លទ្ធផលនឹងផ្ដល់អោយ  &gd,  &gm សមមូលនឹង graph diver, graphmode ។ ក្នុងករណី Screen មាន Mode ច្រើនប្រភេទខុសគ្នា, យើងអាច ជ្រើសរើស gaphdrver, GraphMode សមរម្យ ដោយមិន ប្រើ របៀបកំនត់តំលៃអោយ Gd = DETECT;តែយើងកំណត់ តំលៃ សមរម្យអោយ gd និង gm មុនពេលហៅ initgraph ។

Ex :   gd = EGA ;    gm = EGAHi ;

initgraph(&Gd,&Gm, “ C:\\ TC\\BGI” ) ;

graphgesult គឺជា Function របស់ Tur bo C ,វាអោយយើងដឹង ពី ស្ថានភាពរបស់ Graphic ។

Function មានតំលៃដូច ក្នុងតារាងខាងក្រោនេះ ៖

ឈេμាះ

តំលៃ

RbePT kMhus

grOk()

0

OK, គμានកំហុស
grNoInitGraph()

-1

មិនទាន់ដំណើរការបាន
grNotDetected()

-2

អត់មានផ្នែក HardWareGraph
grFileNotFound()

-3

អត់រកឃើញបណ្ដា File បញ្ជា

Graph

III. បណ្ដាStatement ប្រើជាមួយGraph :
a, moveto(x,y) ;

គឹជា  Statement  បញ្ជូនទីតាំង  CP(Current-Position)  ទៅចំនុច ដែលមានកូអរដោនេ X,Y។ Cursor ក្នុង Screen graph កំណត់ ដោយ កូអរដោនេ វាអត់មានចំនុចភ្លឺលោតភ្លឹបភ្លេតៗដូចក្នុង ScreenText ទេ ។
C C++អនុគមន៍ getx(), gety() ផ្ដល់នូវកូអរដោនេនៃ Cursor-Graph.

b,lineto (x,y); គឺជា Statement គូសបន្ទាត់ត្រង់ពីទីតាំង Cursor-Graph បច្ចុប្បន្នទៅចំនុចដែលមានកូអរដោនេ (X,Y)  បន្ទាប់ពី គូសរួច Cursor-Graph ស្ថិតនៅទីតាំងថμីដែលមានកូអរដោនេ (X,Y)

Function getmaxx(),getmaxy(),ប្រើដើម្បីគណនាចំនួនចំនុច អតិបរមាតាមអក័្ស អាប់ស៊ីសនិងអ័ក្ស អរដោនេ ។ មានន័យ ថា, ជាកូអរដោនេចំនុចនៃ មុំកែងខាង ក្រោម ផ្នែកខាងស្ដាំ។

Ex ចំពោះ EGA Screen,  នោះ getmaxx = 639, getmaxy = 349 ។
+ដើម្បីរក្សា Screen-Graph ក្នុងការពិនិត្យមើលលទ្ធផលយើងប្រើ Statement getch() ។
+ដើម្បីបញ្ជប់ Graph Mode យើងប្រើ Statement closesgraph() ;

 IV. Function  គូសចំនុច   ៖

Function  គូសចំនុចមានលក្ខណៈជាមូលដ្ឋាន, ព្រោះចំនុចបង្កើតបាន ជារូបភាពផ្សេងៗទ្យេត ។

putpixel(int x, int y ,int  color) ;

គូសចំនុចភ្លឺត្រង់ទីតាំងដែលមានកូអរដោនេ (X,Y) មានពណ៍ជា Color ។

getpixel( int x, int y ) ;

ជា Function បង្ហាញប្រាប់ពណ៍បច្ចុប្បន្នត្រង់ចំនុច (X,Y) ។

V. Function គូសបន្ទាត់ត្រង់  ៖

line(int  x1, int  y1, int  x2, int  y2 ) ;

ជា Function គូសបន្ទាត់ត្រង់ពីចំនុចដែលមានកូអរដោនេ (X1,Y1) ទៅចំនុច (X2,Y2)។ វាមិនអាស្រ័យទៅនឹង ទីតាំងនៃ CP ( Current-Position) ។ ក្រោយពីគូសរួច CPនឹងស្ថិតនៅត្រង់ចំនុច (X2,Y2) , ពេលនោះ LineTo(X,Y) នឹង គូសបន្ទាត់ពីទីតាំង CP ទៅចំនុច (X,Y) ។

linerel( int dx, int dy ) ;

ជា Function គូសអង្កត់ត្រង់ពីទីតាំង CP ទៅចំនុចថμីដែលមានកូអរដោនេ (X + dx, Y + dy)។

ក្រោយពីគូសរួច , CP ស្ថិតនៅចំនុចថ្នី (X+dx,Y+dy)។

 VI. Function គូសរង្វង់   ៖

circle(int x, int y , int R ) ;

ជា Function គូសរង្វង់ដែលមានផ្ចិតត្រង់ចំនុន (X,Y), មានកាំ R ។

pieslice( int x, int y , int start, int end ,int R ) ;

ជា Function គូសផ្ទែនៃរង្វង់ ។

ellipse(int x, int y , int start , int end ,int dx , int dy) ;

ជា Function គូស Ellipse ។

 VII.  សំដែងអត្ដបទលើ  SCREEN GRAPH-MODE :

ក្នុង graphmode, Statement  printf() នឹង cprintf()  មិនស្របនឹង ScreenGraph

ទេព្រោះវាប្រើខ្នាតកូអរដោនេ ជាចំនួន character ។

យើងមាន Function ពីរសំរាប់សំដែងអត្ដបទលើ ScreenGraph :

–     outtext (char  *st) ;

សំដែងអត្ដន័យរបស់ St ត្រង់ចំនុច CP (Current Position) នៅលើ ScreenGraph ។

–     outtextxy ( int x,  int  y , char  *st ) ;សំដែងអត្ដន័យរបស់ St ត្រង់ចំនុច (X,Y) នៅលើ ScreenGraph  ។ ដូច្នេះ outtextxy

សមមូលនឹង Command ពីខាងក្រោម ៖

+ moveto (x,y) ;

+ outtext (*st) ;

–     settextstyle (font, direction, charsize) ;

កំណត់ប្រភេទអក្សរជាមួយ ៖

+ប្រភេទ Font អក្សរ ៖

– DefaultFont = 0 ;

-TriplexFont = 1 ;

– SmallFont = 2 ;

– SansSerifFont = 3 ;

– GothicFont = 4;

+Direction : HorizDir = 0 ; VertDir = 1 ;

+ CharSize :

CharSize ទទួលតំលៃពី ១ ដល់ ១០, ជាមេគុណដើម្បីពង្រីកតួអក្សរ ។

–     restorecrtmode() ;

Function នេះប្រើសំរាប់ត្រលប់ទៅ TextMode បណ្ដោះអសន្ន ។

–     setgraphmode() ;

Function នេះប្រើសំរាប់ត្រលប់ទៅ GrapgMode វិញ ។

–     closegraph() ;

Function នេះប្រើសំរាប់បិទ GrapgMode ហើយត្រលប់ទៅ TextMode វិញ ។

 VIII.  Procedure គូសចតុកោណកែង  ៖

–     rectangle(int x1, int  y1, int  x2, int  y2 ) ;

គូសចតុកោណកែងដែលមាន (X1,Y1)  ជាកូអរដោនេនៃចំនុច មុំកែង ខាងលើផ្នែកខាងឆ្វេង, និង

(X2,Y2) ជា កូអរដោនេនៃចំនុចមុំកែងខាងក្រោមផ្នែកខាងស្ដាំ ។

–     bar(int  x1, int y1, int  x2, int  y2 ) ;

គូសចតុកោណកែងតែមានផាត់ពណ៍នៅផ្ទៃខាងក្នុង ។

bar() ខុសពី rectangle() ត្រង់ rectangle() គ្រាន់តែគូស ជ្រុង របស់ចតុកោណកែងប៉ុណ្ណោះវាអត់ផាត់ពណ៍ ខាង ក្នុងទេ ។-     drawpoly( int   NumPoints  ,int    PolyPoints) ;

ជា Function គូសពហុកោណ, ត្រីកោណ ……។

-polypoints : ជាប៉ារ៉ាមែត្រអត់ប្រភេទ, វាផ្ទុកកូអរដោនេ នៃ បណ្ដាកំពូលរបស់ពហុកោណ ។

-numpoints : បង្ហាញចំនួនកូអរដោនេក្នុង PolyPoints ( ជាចំនួន​កំពូលរបស់ពហុកោណ ) ។ កូអរដោនេមួយមាន តំលៃពីរជាប្រភេទ int។ តំលៃមួយជាអាប់ស៊ីស X, និងតំលៃមួយទ្យេតជាអរដោនេ Y។

ចំណាំ ៖  ដើម្បីគូសពហុកោណដែលមាន N ជ្រុង, យើងត្រូវផ្ដល់ N+1 កូអរដោនេទៅ DrawPoly ។

Example :

# include<graphics.h>

# include<stdlib.h>

#include<conio.h>

main()

{  int gd=DETECT, gm, errorcode;

int poly={20,240,620,20,590,460,320,240,20,240} ;

initgraph(&gd,&gm.”C:\\TC\\BGI”);

errorcode = graphresult();

if (errorcode != grOk())

{ printf(“Graphics error : %s\n”,grapherrormsg(errorcode));

printf(“ Press any key to halt “);

getch();

exit(1);

} drawpoly(5,poly); getch(); closegraph(); return 0;

}

IX.  កំណត់ពណ៍រូបភាព  ៖

* setfillstyle ( int Pattern, int  Color) ;

ក្នុងនោះ Pattern ជាចំនួនគត់ពី ០ ដល់ ១២ ដែលមានឈេμាះ និងតំលៃដែលបានកំណត់និយមយ័មហើយ ៖

EmptyFill       = 0 ;       { ពណ៍ខ្នៅ } SolidFill   = 1 ;     { ពណ៍ក្រម៉ៅប្រផេះ }

LineFill          = 2 ;       { – – -}

LtSlashFill    = 3 ;       { / / / }

SlashFill        = 4 ;       {/ / / ដែលមានបន្ទាត់តូច } BkSlashFill = 5 ;     {\ \ \ ដែលមានបន្ទាតក្រាស់់}

LtBkSlashFill = 6 ;      {\ \ \ }

HatchFill  = 7 ;   {Light Hatch Fill} XHatchFill   = 8 ;     {Heavy cross hatch Fill} InterLeaveFill  = 9 ;      {Interleaving line Fill} WideDotFill  = 10 ;   {widely spaced dot Fill}

CloseDotFill = 11 ;    {Closely Spaced dot Fill} UserFill = 12 ;  {ផាត់តាមពណ៍របស់ User បង្កើត}

Example :

# include<graphics.h>

# include<conio.h>

# include<stdlib.h>

main()

{int gd=0, gm maxx,maxy ;

char pattern[8]={0x00, 0x70, 0x20, 0x27, 0x25, 0x27,0x04,0x04} ;

initgraph(&gd, &gm, “C:\\TC\\BGI”); maxx=getmaxx(); maxy=getmaxy(); setcolor(getmaxcolor()); setfillpattern(pattern, getmaxcolor()); bar(0, 0, maxx, maxy);

getch(); getfillpattern(pattern); pattern[4] -= 1 ; pattern[5] -= 3 ; pattern[6] +=3 ; pattern[7] -= 4 ;

setfillpattern(pattern,getmaxcolor());

bar(0, 0, max, maxy );

getch ();

closegraph();

}

 * floodfill(int X, int Y, int Border) ;

យើងប្រើ function នេះដើម្បីផាត់ពណ៍អោយចតុកោណ, ត្រីកោណ, ពហុកោណ……….,ចំនុច (X,Y) ត្រូវស្ថិត នៅក្នុងផ្ទៃុ នៃ ចតុកោណ។ ពណ៍ដែលផាត់នោះត្រូវបានបង្កើតឡើងដោយ setfillstyle ឬ setfillpattern ។ Border (មានតំលៃពី ០ ដល់ ១៥) ជាពណ៍របស់ជ្រុង ។

បើចំនុច  (X,Y)  ស្ថិតនៅក្នុងផ្ទៃចតុកោណ,  នោះផ្នែកខាងក្នុង ចតុកោណ  ត្រូវបានផាត់ពណ៍  តែបើចំណុច

(X,Y) នៅក្រៅ ចតុកោណវិញនោះគឺផ្នែកខាងក្រៅចតុកោណត្រូវបានផាត់ពណ៍ ។

 * fillpoly(  NumPoints ,  PolyPoints) ;

គូសពហុកោណហើយមានផាត់ពណ៍ផ្នែកខាងក្នុង ។

+ PolyPoints : ជាប៉ារ៉ាមែត្រគ្នានប្រភេទវា ផ្ទុកកូអរដោនេបណ្ដាកំពូលរបស់ពហុកោណ ។

+NumPoints: ប្រាប់ចំនួនកូអរដោនេក្នុង PolyPoints។ (គឺជាចំនួន កំពូលរបស់ពហុកោណ) ។ កូអរដោនេ  មួយ  មាន  តំលៃពីរ  (word  :  តំលៃX  និង  តំលៃY)  ។  FillPoly ផាត់ពណ៍ពហុកោណដោយប្រើ ពណ៍ដែលបង្កើតដោយ SetFillStyle ឬ SetFillPattern ។ ចំនែកជ្រុងរបស់ពហុកោណ, ត្រូវបានគូសជាមួយ ប្រភេទ បន្ទាត់ និង ពណ៍ ដែលបង្កើតឡើងដោយ SetLineStyle ។

 X.  ViewPort : Viewport  ជាតំបន់ចតុកោណកែងមួយនោលើ  Screen  ដែលយើងអាចអនុវត្ដបណ្ដា  Procedure

របស់ Graphic នៅក្នុង នោះ ហាក់បីដូចជា Screen តូចមួយ ។

setviewport (int X1,int Y1,int X2,int Y2, Clip) ;

ជា  Function  កំណត់  ViewPort  មួយនៅលើ  Screen  ជាមួយ  (X1,Y1,X2,Y2) ជាកូអរដោនេរបស់ ViewPort ។ ក្រោយ ពីហៅ esetviewport , កូអរដោនេ (0,0) នៃបណ្ដា Statement គូសនឹង ក្លាយជាមុំកែង ខាងលើ ផ្នែកខាងឆ្វេងរបស់ ViewPort  គឺ (X1,Y1) ។

ប៉ារ៉ាមែត្រ  Clip    អាចមានតំលៃ  True  =    clipon  : អនុញ្ញាតិ អោយមើលឃើញបណ្ដាបន្នាត់ដែលគូសចេញក្រៅ                                            ViewPort  ,   ចំណែក    clipoff នឹងមិនអាចមើលឃើញ បន្នាត់ដែល គូសចេញក្រៅ ViewPort ។

C C++

យើងអាចផ្លាស់ប្ដូរ ViewPort នៅគ្រប់កន្លៃងក្នុងកមμវិធី ដើម្បី បានកូអរដោនេគូស និង តំបន់គូសសមស្រប។

ឧទាហរណ៍គូសក្រាហ្វិចរបស់សមីការដែលមានមុំ កូអរដោនេនៅ កណ្ដាល SCREEN :

setviewport (getmaxx() / 2, getmaxy() / 2, getmaxx(), getmaxy(), 1

) ;

 XI.  បណ្ដាអនុគមន៍ផ្សេងទៀត  ៖

*setlinestyle(int LineStyle,int Pattern,int Thickness);

ជា Function សំរាប់កំនត់រាងអោយបន្ទាត់

* bar3d (int x1, int y1 ,int x2 ,int y2, int depth, top );

ជា Function សំរាប់គូសចតុកោណប៉ោងក្នុងលំហរ ។

XII.  កាត់រូប,   បិទរូប  និង  បង្កើតរូបភាពដែលមានចលនា  ៖

រក្សាទុករូបភាព  ៖

ដើម្បីរក្សាទុករូបភាពណាមួយ, យើងត្រូវប្រើ Block Memory     មួយដែល មានរាងជា ចតុកោណកែងពទ្ធ៍ជុំវិញ រូបភាពនោះ ។ ក្រោយ មកយើងរក្សាផ្ទៃក្រលាចតុកោណកែងនោះ។ដើម្បីគណនាទំហំ Block Memory រាង ចតុកោណ កែងផ្ទុករូបភាពនោះ, យើងប្រើ Function មានស្រាប់ គឺ ៖

+ imagesize(int X1, int  Y1,int  X2 , int  Y2 ) ;

ដើម្បីរ្យេបចំ Memory រក្សាទុករូបភាព,យើងប្រើ Function នេះបង្កើត Dynamic Variable

មិនកំនត់ ប្រភេទ ។

+ getimage(int  X1,int Y1,int  X2, int  Y2 , *PBitMap) ;

ជា Procedure ដើម្បី Copy បណ្ដាចំនុចនៃរូបភាពនៅលើ   Screen ដែលស្ថិតក្នុងចតុកោណ (X1,Y1,X2,Y2) ចូលទៅ ក្នុង Memory ដែលត្រូវ PBitMap ជាអ្នក Index, ដោយប្រើ Procedure GetMem ខាងលើ ។

+ putimage(int X, int Y , *PBitMap , int  CopyMode) ; រំដោះរូបភាពដែលយើងបាន Copy ដោយ GetImage, មកលើ Screen ត្រង់ចំនុច (X,Y)។ ក្នុងនោះ CopyMode ជាប្រភេទ Copy រូបភាពមកលើ Screen :

Copy = 0

XORPut = 1

ORPut = 2

ANDPut = 3

NOTPut = 4

* ដើម្បីបង្កើតរូបភាពមានចលនា ក្នុង GraphMode :

– គូសរូប, Copy រូបនោះចូលទៅក្នុង DynamicVariable :

– បង្កើត (Delay) ។

– លុបរូបនោះ, រំដោះរូបភាពឡើងវិញដោយប្រើ putimage();

–  គូសរូបភាពនៅទីតាំងថ្នី ។

# include<graphics.h>

# include<conio.h>

# include<stdlib.h>

# include<alloc.h>

# include<stdio.h>

void save_screen(void far *buf[4]); void restore_screen(void far *buf[4]); int maxx, maxy ;

int main(void)

{ int gd=DETECT, gm ,errorcode ;

void far *ptr[4];

initgraph(&gd,&gm,”c:\\tc\\bgi”); erorcode = graphresult(); if(errorcode != grOk())

{printf(“ Graphics error : %s\n”,grapherrormsg(errorcode));

printf(“Press any key to halt:“);

getch();

exit(1);

}

maxx=getmaxx(); maxy=getmaxy(); rectangle(0,0,maxx,maxy); line(0,0,maxx,maxy); line(0,maxy,maxx,0); save_screen(ptr);

getch(); cleardevice(); restore_screen(); getch(); closegraph(); return 0;

}

void save_screen(void far *buf[4])

{ unsigned side;

int ystart = 0 ,yend , yincr , block ;

yincr = (maxy+1)/4;

yend = yincr;

size = imagesize(0,ystart,maxx,yend);

for(block=0; block<=3;block++)

{

if ((buf[block]=farmalloc(size))== NULL)

{closegraph();

printf(“Error ! not enough heap space in save_screen()”);

exit(1);

}

getimage(0,ystart,maxx,yend,buf[block]);

ystart = yend + 1;

yend += yincr +1;

}

}

void restore_screen(void far *buf[4])

{

int ystart = 0 , yend, yincr , block;

yincr = (maxy+1)/4;

yend = yincr;

for (block=0;block<=3;block++)

{

putimag(0,ystart,buf[block],COPY_PUT);

farfree(buf[block]);

ystart = yend + 1;

yend +=yincr + 1;

}

}

មេរៀនទី១៣: សរសេរកម្មវិធី C

មេរៀនទី១៣: សរសេរកម្មវិធី C WRITING PROGRAM WITH C++

I. Introduction to C++ Language:

C/C++    Programming      Language   ជាភាសាកម វμ ិធីទូទៅមួយដែលស្ថិតនៅក្នុង ភាសាកមវμ ិធីកំរិតខ្ពស់ (  High  Level  Programming  Language)  ។  គេបង្កើត  C ដើម្បីសរសេរ System program  គេថា C  ជាភាសា ដើម កំណើតរបស់ UNIX  Operating System។ C/C++  ត្រូវបានគេចាត់ទុកជា ភាសាមួយ មាន ប្រជាប្រិយក្នុងការសរសេរភា្ជប់ Application ជាមួយនិង System ដោយភាសា C/C++ ជាភាសាកំរិតខ្ពស់ (High Level Language) និង មាន Compiler បកប្រែពាក្យ បញ្ជាអោយទៅជាភាសា ម៉ាស៊ីន រួច មកជាភាសាដែលអាចអានបានដោយភាសារបស់មនុស្ស។ C មិន អាស្រ័យ តែ នៅលើ O.S(Operating System) រឺ ម៉ាស៊ីនណាមួយ ដោយឡែកឡើយ មាននយ័ថា C ត្រូវបានគេយកទៅប្រើប្រាស់ ជាមួយ O.S និង ម៉ាស៊ីនផ្សេងៗតាម Object របស់វា។

ឆ្នាំ  1970   លោក Ken  Thompson  បានរៀបចំភាសា   B     Language ដែលមានឥទ្ធិពលនៅលើ Basic Computer Programming Language ដែលបង្កើតដោយ លោក Martin Richard។
ឆ្នាំ 1972 លោក Dennis Ritchie បានធ្វើការកែប្រែ B Programming Language អោយទៅជា C Programming Language នៅឯ Bell Telephone Laboratories។
ឆ្នាំ 1978 លោក Brain W Kernighen និង Dennis Ritchie បានបោះពុម្ពសៀវភៅ The C Programming Language (First edition) ។ ឆ្នាំ 1982 ទើបគេបង្កើត ANSI(American National Standard Institute) ដោយផ្ដើម សរសេរ នៅ  អនុគមន៍ដែល  ជា  Standard  Library  បញ្ចូលទៅក្នុង  Compiler ដើម្បីប្រើប្រាស់ជា ទូទៅរហូតមកដល់សព្វថ្ងៃនេះ។ នៅឆ្នាំ  1988  គេចាប់ផ្ដើមបង្កើត  OOP( Object Oreinted    Programming)

ដោយលោក Brjare Stron Stup នៅឯ Bell Laboratories ដែលក្នុងគោលបំណងដើម្បីបង្កើតនូវ Application Wizard និង System Programming។

II. ទំរង់ទូទៅនៃC++:

#include<iostream.h>//Header file/Preprocessor/Library

int main(){//ចំនុចចាប់ផ្ដើមនៃកមμវិធី
statement1;
statement2;       Block of statement
………….;
return 0;//បញ្ជាក់ថាដំណើរការដល់ទីបញ្ចប់

}// ចំនុចបញ្ចប់នៃកមμវិធី

#include<iostream.h>//Header file/Preprocessor/Library

void main(){//ចំនុចចាប់ផ្ដើមនៃកមμវិធី

statement1;

statement2;       Block of statement

………….;

}// ចំនុចបញ្ចប់នៃកមμវិធី

បើកកមμវិធី C/C++:

– C:\> TC\Bin\Tc.exe

– Compiler: Alt +F9

– Run (Make EXE): Ctrl +F9

– Copy: Ctrl+Insert

– Past: Shift+Insert
– Cut: Shift+Delete
C C++III. Feature of iostream.h: iostream.h (Input/ Output Stream library) ជា Standard header file/ Standard library សំរាប់ Input/ Output stream ដែលមានមុខងារជាអ្នកបក ស្រាយ ការបញ្ចេញ និង ការបញ្ចូល ទិន្នន័យ។ វាផ្ទុក function cin សំរាប់ បញ្ចូលទិន្នន័យតាមរយះ Keyboard និង function cout សំរាប់ការ បញ្ចេញទិន្នន័យនៅលើ Screen ។

Ex:

cout<< “Hello world!”<<endl;

cout>>x;

IV. អនុគមន៍getch( ):

ប្រើសំរាប់ទប់ Screen output ដើម្បីអោយយើងអាចពិនិត្យលទ្ធផល (Result) នៃកមμវិធីនៅពេលដែលយើង ដំណើរការកមμវិធី ។ អនុគមន៍ getch( ) ស្ថិត នៅ library conio.h (Console Input/Output library) ។

 V. Input and Output function:

cout<< “String”/Variables; ប្រើសំរាប់បង្ហាញ string ឬ តំលៃមកលើ Screen ។

Ex:       int x=10;
cout<< “x=”<<x;
cin>>Var1,var2,var3, …; ប្រើសំរាប់បញ្ចូលទិន្ននយ័តាមរយះ Keyboard

ទៅអោយ var1,var2,…

Ex:       int x;

cin>>x;

VI. Data Type:
VI.1. Definition of Data-Type:
ជាការកំណត់លក្ខណះទៅលើអថេរ (Variables) និមួយៗ ដែលបាន ប្រកាស។
VI.2. Type of Data-Type: Data type មានច្រើនប្រភេទដូចជាៈ

–     Scalars type
–     Structure type
–     Pointer type
C C++

Keyword Byte Limited
Char 1 -128 ដល់ 128
Int 2 -32768 ដល់ 32768
Long 4 -2147483648 ដល់ 2147483648
Float 4 3,4 .10-38 ដល់ 3,4 .1038
Double 8 1,7.10-308 ដល់ 1,7.10308
Unsigned int 2 0 ដល់ 65535

Note: អនុគមន៍ Sizeof()ប្រើសំរាប់ផ្ដល់ទំហំនៃប្រភេទរបស់ទិន្ននយ័ (Data type

)ផ្ដល់តំលៃជាចំនួន integer។

Syntax:

int sizeof(Data-Type/var);

 Ex:

 cout<<“Size of Integer=”<< sizeof(int);

Output:

Size of Integer=2

 VII. Variables:

7.1. Definition of Variable: ជាអថេរ ឬ Address ប្រើសំរាប់រក្សានូវតំលៃជាបណ្ដោះអាសន្នក្នុង Memory នៅពេលកមμវិធីដំណើរការ (Run time) ។ តំលៃនេះត្រូវបានបាត់បង់ទៅវិញនៅពេលគេឈប់ដំណើរការ កមμវិធី (Stop Run) ។
7.2. Syntax:

Ex:

int x,y;


Data-type VarName1, VarName2, …, VarName n;

float a,b,z;

7.3. Assignment Statement: ជាការផ្ទេរតំលៃទៅអោយអថេរ (Variable) ។

Ex1:

– int x;

x=20;

– int y=30;

Ex1: សរសេរ Program ដើម្បីគណនា Y=4×5 + 2×2 + 3x + 1

#include<iostream.h>

#include<math.h>

#include<conio.h> void main(){ clrscr();

float x, y;

cout<< “Please Input x=”; cin>>x; y=4*pow(x,5)+2*pow(x,2)+3*x+1;

cout<< “y=”<<y<<endl;
getch( );

}

VIII. Constants:
VIII.1. Definition of Constants:

ជាតំលៃដែលមិនភ្លាស់ប្ដូរក្នុងពេលកមវμ ិធីដំណើរការ (Process) ។ គេអាចផ្លាស់ ប្ដូរតំលៃវាបានតែតាមរយះ Source codeតែប៉ុណ្ណោះ។

VIII.2. Memory Constants: ត្រូវបានគេប្រកាសដោយ Keyword const

Ex:      const int num=100;

const float y=20.00;

VIII.3. Define Constants: ជាការបង្កើត Constant តាមរយះការប្រើ # (Signal number) និង Keyword define សំរាប់កំណត់ពី Pre-Processor ក្នុងកមμវិធី។

Ex1:

#define PI       3.14

Ex2: កមវμ ិធីសំរាប់ គណនាក្រលាផ្ទៃរង្វង់ៈ

#include<iostream.h>
#include<conio.h>
#define  PI      3.14 void main(){ clrscr();

float radius, circle_area;

cout<< “Please Input radius of Circle=”;

cin>>radius;

circle_area=PI * (radius * radius);

cout<< “Circle Area =”<<circle_area<<endl;

getch();

}

IX. Comments and Escape Code:

– Comments: ជារការធ្វើកំណត់សំគាល់នៅក្នុងកមμវិធី។ វាមិនមាន

ដំណើរការទេនៅពេល Run Time។

នៅក្នុង C ++ មាន Comments ពីរគឺៈ

–     // One Line

–     /* Multiple Line    */

– Escape Code:

– \n : New line

– \t : Move one tab

– \a : Beeb

– \\ : \

– \r  : Move cursor to the first of line

– \” : ”

Ex:

// This program used to change dollars to riels

#include<iostream.h>

#include<conio.h> void main(){ clrscr();

const riel=4000;

float dollar, result;

cout<< “\n Enter Dollar you have=”;

cin>>dollar;

result =dollar * riel;

cout<< “After dollar to riel=”<<result<<endl;

getch();

}

X. Predefined Manipulate function: ជាបណ្ដាអនុគមន៍មួយចំនួនត្រូវបានគេប្រើសំរាប់ធ្វើការកែប្រែការ បញ្ចញ និង បញ្ចូលទិន្នន័យ។ បណ្ដាអនុគមន៍ទាំងនោះមានៈ

X.1. endl: ជា output manipulate function ប្រើសំរាប់ចុះដើមបន្ទាត់ថμី។

Ex: cout<< “Area=”<<area<<end<< “Population=”<<pop<<endl;

X.2. hex, dec and oct: ប្រើសំរាប់បំលែងប្រពន្ធ័គោលៈ

– hex : ជាប្រពន្ធ័គោល 16

– dec : ជាប្រពន្ធ័គោល 10

– oct : ជាប្រពន្ធ័គោល 8

Ex:

//Convert to hex, dec, oct;

#include<iostream.h>

#include<conio.h> void main(){ clrscr();

int num;

cout<< “Enter num=”;

cin>>num;

cout<< “Decimal=”<<dec<<num<<endl;

cout<< “Octal=”<<oct<<num<<endl;

cout<< “Hexadecimal=”<<hex <<num<<endl;

getch();

}

X.3. Setbase(base): ប្រើសំរាប់បំលែងប្រពន្ធ័គោលតាមរយះ base (8, 10, 16);

ដែលវាស្ថិតនៅក្នុង header file <iomanip.h>

Ex:

//Convert to hex, dec, oct;

#include<iostream.h>

#include<conio.h> void main(){ clrscr();

int num;

cout<< “Enter num=”;

cin>>num;

cout<< “Decimal=”<<setbase(10)<<num<<endl;

cout<< “Octal=”<<setbase(8)<<num<<endl;

cout<< “Hexadecimal=”<<setbase(16)<<num<<endl;

getch();

}

10.4. setw(): ប្រើសំរាប់កំណត់ទំហំបង្ហាញមកលើ Screen ។

Ex:

cout<< setw(4)<< “Web”<<setw(5)<< “Site”; Output:

9Web9Site

 10.5. setfill(): ប្រើសំរាប់បំពេញកន្លែង Space នៅពេល Output

ដោយនិមិត្ដសញ្ញាណាមួយ។

Ex:

cout<<setfill(‘*’);cout<< setw(4)<< “Web”<<setw(5)<< “Site”; Output:

*Web*Site

10.6. setprecision(): ប្រើសំរាប់កំណត់ក្រោយក្បៀសចំពោះទិន្ននយ័ប្រភេទ float or double ។

Ex:

float a;

a=7/3;

cout<< “a=”setprecision(2)<<a<<endl; Output:

a=2.33

XI. Operators: នៅក្នុង C ++ មានប្រមាណវិធីផ្សេងៗមួយចំនួនដែលគេប្រើញឹកញាប់ដូចជាៈ

XI.1. Arithmetic Operators:

Operators

Meaning

Example

+

Addition c = a + b;

Subtraction c = a – b;

*

Multiplication c = a * b;

/

Division c = a / b ;

%

Modulo c = a % b;

 Ex:


 int a=20, b=40, c;c= a+ b;

cout<< “c=”<<c<<endl;

 

XI.2. Assignment Operators:

Operators Meaning/Example

=

a = 10;

+ =

a + = 10; a = a + 10;

– =

a – = 10; a = a – 10;

/ =

a / = 10; a = a / 10;

* =

a * = 10; a = a * 10;

% =

a % = 10; a = a % 10;

>> =

n >> = 1; n = n >> 1;

<<=

n << = 1; n = n<<1;

XI.3. Comparison and Logical Operators:

Operators Meaning

<

Less than

>

Greater than

<=

Less than or equal to

>=

Greater than or equal to

= =

Equal to

!=

Not equal to

&&

Logical AND

||

Logical OR

!

Not

Ex:

– Logical AND (&&):

X

Y

X && Y

1

1

1

1

0

0

0

1

0

0

0

0

– Logical OR (||):

X

Y

X || Y

1

1

1

1

0

1

0

1

1

0

0

0

XI.4. Bit-wise Operators:

Operators Meaning

&

Bit wise AND

|

Bit wise OR

^

Bit wise XOR

>>

Bit wise Right Shift

<<

Bit wise Left Shift

~

Bit wise Complement

Ex:

– Bit wise AND (&):

X

Y

X & Y

0101

0110

0100

0110

0010

0010

1111

0001

0001

0001

0000

0000

– Bit wise OR (|):

X

Y

X | Y

0101

0010

0111

0110

0010

0110

1111

0001

1111

0001

0000

0001

– Bit wise XOR (^):

X

Y

X^Y

0101

0010

0111

0110

0011

0101

1111

0001

1110

0001

0000

0001

– Bit wise Complement (~):

X

Y

~X

~Y

00001011 11111111 11110100 00000000

XI. 5. Special Operators:

– Unary Operator: ជា Operator ដែលត្រូវការ Operant តែមួយគត់។

Ex:

++ i;

— i;

i ++;

i–;

– Ternary Operator (?): ជា Operator លក្ខខណ្ឌ័ ដែលមានបី Operants។

Syntax:  Operant1 ? Operant2 : Operant3; Ex:

MAX= (a>b) ? a : b; MIN=(a>b) ? a : b;

cout<< “Max=”<<MAX<<endl;

cout<< “Min=”<<MIN;

 XII. Type Conversion:

ដំបូងអថេរខ្លះត្រូវបានប្រកាសជា Integer ប៉ុន្ដែជួនកាលវាអាចមាន លទ្ធភាព ទទួលយកនូវចំនួនទសភាគ (float) បាន ដែរតាម ទំរង ខាងក្រោមៈ

Var1= (Data-type Var1) Var2; Ex1:

int x;
float y;
x=(int)y;

Ex2:
int x;
float y;
y=x;

13. អនុគមន៍ Math ដែ់លមាននៅក្នុង Preprocessor directive <math.h>:

Functions Result Data Type Description
abs(i) int | i |
sin(d) double Sin(d)
cos(d) double Cos(d)
tang(d) double Tang(d)
exp(d) double Exp(d)
log(d) double Log(d)
pow(x1,x2) double Pow(d)
flour(d) double Flour(d)
ceil(d) double Ceil(d)
fmod(d1,d2) double Fmod(d1,d2)
sqrt(d) double Sqrt(d)
random(d) void Random(d)

14. អនុគមន៍ដែលមាននៅក្នុង <ctype.h>:

Functions Result DataType Description
toascii (ch) int Convert ch to Ascii code
tolower (ch) char Convert ch to lowercharacter
toupper(ch) char Convert ch to uppercharacter

Ex:       #include<stdio.h>

#include<conio.h>

#include<math.h>

main( ){

clrscr( );

float a;

int result;

printf(“Please, Input a=”);

scanf(” %f”,&a); result =abs(a); textcolor(6);

cprintf(“Result are =%d”,result);

getch( );

return 0;

}

Exercises:

1.   Write program to calculate Sum of Three number?

2.   They have output on the screen as follow: W*e*l*C*o*m*e***to***Learn***C++**Programming**Language! Write program that output above?

3.   Write program to calculate area of Rectangle?

4.   Write program to calculate f(x)= axn + bxn-2 + c

5.   Using Ternary operator, write program to find Min and Max of two numbers?

6.   Using setbase() function, write program to convert to hexadecimal and octal number?

7.   Write program to change Riels to Dollars?

មេរៀនទី១៤: អនុវត្តលំហាត់ Array

មេរៀនទី១៤:  អនុវត្តលំហាត់ Array

គណនា​ Address របស់​ Array តាម​ Column major order
C C++
សូម​​ជួយ​ប្រាប់​​ផងបើ​​ កម្ម​វិធី​ដែល​ខ្ញុំ​សរសេរ​មាន​កំហុស​!!

#include<iostream.h>
#include<conio.h>
void Pi(int p[],int i,int Ub[],int Lb[]);
void main()
{    int Lo,n,c;
char ch;
cout<<“********************\n”;
cout<<“*Column major order*\n”;
cout<<“********************\n\n”;
do
{
cout<<“Enter dimension:”;
cin>>n;
int *s=new int[n],*s1=new int[n];
cout<<“Enter c word:”;
cin>>c;
cout<<“Enter start address(Lo)=”;
cin>>Lo;
cout<<“Enter size of array from left to right(Ex:a[3][5][6]) :”;
for(int i=0;i
cin>>s1[i];
cout<<“Enter index that want to find:\n”;
for(i=0;i
{    cout<<“s[“<<i<<“]=”;
cin>>s[i];
}
int *Lb=new int[n],*Ub=new int[n];
for(i=0;i
{    Lb[i]=0;
Ub[i]=s1[i]-1;
}
i=0;
int *p=new int[n];
i=n-1;
Pi(p,i,Ub,Lb);
int result;
result=Lo;
for(int j=0;j<=n-1;j++)
result=result+(p[j]*(s[j]-Lb[j])*c);
cout<<“The result is address:”<<result;
cout<<“\nPress r to restart or anykey to exit:”;
ch=getch();
clrscr();
}while(ch==’r’||ch==’R’);
}
void Pi(int p[],int i,int Ub[],int Lb[])
{    p[0]=1;
for(int k=1;k<=i;k++)
{  p[k]=1;
for(int j=k-1;j>=0;j–)
p[k]=p[k]*(Ub[j]-Lb[j]+1);
}
}

កូដ​អំពី​ការ​បោះ​លេខ​​ Random ដោយ​មិន​ជាន់​តំលៃ​គ្នា

វា​និង​ធ្វើ​ការ​ Random ពី​លេខ​១ ដល់​ r*c តែ​វា​ process យូរ​បន្តិច

#include<iostream.h>
#include<stdlib.h>
void main()
{    int b[100],e[100],a[10][10],t=0,j,i,r,c;
cout<<“Enter r:”;    cin>>r;
cout<<“Enter c:”; cin>>c;
for(i=0;i<100;i++)
b[i]=0;
for(i=0;i
{    again:
randomize();
e[i]=random(10000)%(r*c+1);
for(int j=0;j<=i;j++)
if(b[j]!=e[i])    t++;
else    goto again;
if(t<=i)
{  t=0;
goto again;
}
t=0;
b[i]=e[i];
}
int cre=0;
for(i=0;i<r;i++)
for(j=0;j<c;j++)
{    a[i][j]=e[cre];
cre++;
cout<<endl<<a[i][j];
}
}

បំលែង​លេខ​ពី​ Decimal ទៅ​ជា​ Binary ដោយ​ប្រើ​លក្ខណៈ​ Stack
C C++
សូម​បញ្ជាក់​ថា​ maxstack =50

#include<iostream.h>
#include<conio.h>
#include<stdio.h>
#define maxstack 50
struct stack
{    int top;
int info[maxstack];
};
void initialize(stack *st)
{    st->top=-1;
}
int fullstack(stack *st)
{    return (st->top==maxstack-1);
}
int emptystack(stack *st)
{    return (st->top==-1);
}
void push(stack *st,int item)
{    if(fullstack(st))
cout<<“\nStack overflow”;
else
{    st->top=st->top+1;
st->info[st->top]=item;
}
}
int pop(stack *st)
{    int element;
if(emptystack(st))
{    cout<<“\nStack underflow”;
return 0;
}
else
{    element=st->info[st->top];
st->top=st->top-1;
return element;
}
}
void main()
{    int a[50],num;
struct stack st;
int pos;
char ch;
do
{  clrscr();
cout<<“Enter decimal number:”;
cin>>num;
pos=0;
while(num!=0)
{    a[pos]=num%2;
num=num/2;
pos++;
}
a[pos]=-1;
initialize(&st);
pos=0;
while(a[pos]!=-1)
{    push(&st,a[pos]);
pos++;
}
cout<<“Binary number:”;
while(st.top!=-1)
cout<<pop(&st);
cout<<“\nDo you want to restart?(Y/N):”;
ch=getch();
}while(ch==’y’||ch==’Y’);
}

 

បំលែងរយៈពេល ភាសាC program

C C++

//នេះជាកម្មវិធីសំរាប់ធ្វើការគណនារយៈពេល​ ម៉ោង នាទី រឺ វិនាទី ដែលយើងបានបញ្ចូល

//ទៅជាចំនួនសរុបនៃ នាទី រឺ វិនាទី រឺ ម៉ោង

#include<stdio.h>
#include<conio.h>
void main()
{
long int h,mn,c,d,f,g;
int e;
clrscr();
printf(“Enter 1 to Convert Hour to mn and s\n”);
printf(“Enter 2 to Convert mn to Hour and s\n”);
printf(“Enter 3 to Convert s to mn and Hour\n”);
printf(“Please enter the number=”);scanf(“%d”,&e);
clrscr();
if(e==1)
{    printf(“Input Hour=”);scanf(“%ld”,&h);
printf(“Input Minute=”);scanf(“%ld”,&mn);
c=(h*60)+mn;
d=c*60;
printf(“=>%ldh%ldmn=%ldmn=%lds”,h,mn,c,d);
}
if(e==2)
{    printf(“Input Minute=”);scanf(“%ld”,&mn);
c=mn/60;
d=mn%60;
f=mn*60;
printf(“=>%ldmn=%ldh%ldmn=%lds”,mn,c,d,f);
}
if(e==3)
{    printf(“Input s=”);scanf(“%ld”,&c);
mn=c/60;
h=mn/60;
d=mn%60;
g=c%60;
printf(“=>%lds=%ldh%ldmn%lds=%ldmn%lds”,c,h,d,g,mn,g);

}
if(e>3||e<1)
goto exit;

getch();
exit:
}

//បញ្ចប់

 

បង្ហាញរូបភាព ភាសា C
C C++

//នេះគ្រាន់តែជាការសរសេរលេងសំរាប់បង្ហាញរូបភាពជាការេដែលរីកពីតូចទៅធំតែប៉ុណ្ណោះ

#include<stdio.h>
#include<conio.h>
#include<dos.h>
#include<graphics.h>
void main()
{
int x,i,j,nn,n,e,y,i1,j1,e1,k,color1,color2,w1,w2;
clrscr();
n=1;
while(!kbhit())
{
for(i=1;i<=n;i++)
{    gotoxy(x=40-i,y=0+i);
for(j=1;j<=i;j++)
{       color1=j;
textcolor(color1);
cprintf(“*”);
color1++;
}
for(e=1;e<i;e++)
{       color2=j;
textcolor(color2-2);
cprintf(“*”);
j–;
}
cprintf(“\n\r”);
}
k=1;
for(i1=i-1;i1>=1;i1–)
{
gotoxy(x+k,y+k);
for(j1=1;j1<=i1-1;j1++)
{       color1=j1;
textcolor(color1);
cprintf(“*”);
color1++;
}
for(e1=1;e1
{       color2=j1;
textcolor(color2-2);
cprintf(“*”);
j1–;
}
cprintf(“\n\r”);
k++;
}

delay(100);

n++;
if(n>=25)
{

n=1;
}

clrscr();
}

getch();
}

//ចប់

 

ចែកកត្តាបឋម ភាសា C
C C++
//នេះគឺជាcode សំរាប់​ធ្វើការចែកលេខជាកត្តាបឋម

#include<stdio.h>
#include<conio.h>
void main()
{
int i=1,d=2,n,a[20],j=2;
clrscr();
printf(“Enter number=”);scanf(“%d”,&n);
while(n>=d)
{
while(n%d==0)
{
a[i]=n/d;

printf(“%d³”,n);

printf(“%d\n”,d);

n=a[i];
i++;
j++;
}

d++;
}

printf(“1³”);
getch();
}

//បញ្ចប់

 


 

 

មេរៀនទី១៥: អនុវត្តបង្កើតហ្គេម

មេរៀនទី១៥អនុវត្ត បង្កើតហ្គេម

ហ្គេមចាក់លេខ(ចាក់អាប៉ោង) ភាសាC
C C++
//ពេលដំនើរការGame នេះវានិងអោយយើងបញ្ចូលនូវ សំរាប់ ធ្វើការលេង|
//បើចង់ដាក់ទឹកប្រាក់ធ្វើការភ្នាល់ គឺគ្រាន់តែចុចសញ្ញា +(បន្ថែម) រឺ – (បន្ថយ)
//បើចង់Selectយកលេខណាមួយយើងប្រើ w,a,s,d រួចចុច Enter

#include<stdio.h>
#include<conio.h>
#include<process.h>
#include<dos.h>
#include<stdlib.h>
void main()
{
int col=1,k;
long int imon=0,tmon;
char ch,ch1;
clrscr();
printf(“Enter Total money=”);scanf(“%ld”,&tmon);
clrscr();
do
{       gotoxy(2,40);printf(“Press ESC to exit!”);
gotoxy(50,2);printf(“Total money=%ld$”,tmon);
gotoxy(50,4);printf(“Input  money=%ld$”,imon);
textbackground(RED);
gotoxy(5,5);cprintf(“1″);
gotoxy(9,5);cprintf(“2″);
gotoxy(13,5);cprintf(“3″);
gotoxy(5,9);cprintf(“4″);
gotoxy(9,9);cprintf(“5″);
gotoxy(13,9);cprintf(“6″);
textbackground(BLACK);
switch(col)
{    case 1:    gotoxy(5,5);cprintf(“1″);break;
case 2:    gotoxy(9,5);cprintf(“2″);break;
case 3:    gotoxy(13,5);cprintf(“3″);break;
case 4:    gotoxy(5,9);cprintf(“4″);break;
case 5:    gotoxy(9,9);cprintf(“5″);break;
case 6:    gotoxy(13,9);cprintf(“6″);break;
}
input:
ch=getch();
if(ch==’s’||ch==’a’||ch==’d’||ch==’w’)
{
switch(ch)
{    case ‘s’:      if(col==1)    col=4;
else if(col==2)    col=5;
else if(col==3)    col=6;
else if(col==4)    col=1;
else if(col==5)    col=2;
else        col=3;
break;

case ‘a’:    if(col==1)    col=3;
else if(col==2)    col=1;
else if(col==3)    col=2;
else if(col==4)    col=6;
else if(col==5)    col=4;
else        col=5;
break;

case ‘d’:    if(col==1)    col=2;
else if(col==2)    col=3;
else if(col==3)    col=1;
else if(col==4)    col=5;
else if(col==5)    col=6;
else        col=4;
break;

case ‘w’:    if(col==1)    col=4;
else if(col==2)    col=5;
else if(col==3)    col=6;
else if(col==4)    col=1;
else if(col==5)    col=2;
else        col=3;
break;
}
}
else if(ch==’+’||ch==’-‘)
{
if(tmon==0&&imon==0)
goto exit2;
else
{    if(tmon>0)
{    if(imon>0)
{    if(imon==0)
{    imon++;
tmon–;
}
else if(ch==’+’)
{    imon++;
tmon–;
}
else
{    imon–;
tmon++;
}
}
else
{    if(ch==’+’)
{    imon++;
tmon–;
}
}
}
else
{    if(ch==’-‘)
{    tmon++;
imon–;
}
}

}

}
else if(ch==27)
exit(0);
else if (ch==13)
{    int i=1,count=1;
for(;;i++)
{       if(i>6)i=1;
gotoxy(20,20);
printf(“Number is %d”,i);
delay(100);
count++;
if(count==20)
{    randomize();
i=random(7);
if(i==0)
i++;
gotoxy(20,20);
textbackground(DARKGRAY);
cprintf(“Number is %d”,i);
delay(200);
break;
}
}
gotoxy(20,22);
textcolor(WHITE);
if(col==i)
{    tmon=tmon+imon*4;
printf(“You win! %ld$”,4*imon);
imon=0;
}
else
{    printf(“You lose!”);
imon=0;
}
gotoxy(20,24);
printf(“Press ‘SPACE’ to play again!”);
again:
ch1=getch();
if(ch1==32)
goto again1;
else if(ch1==27)
exit(0);
else
goto again;
}
else
goto input;
again1:
clrscr();
}while(!kbhit());
exit2:
gotoxy(25,6);
printf(“Don’t have $$ press anykey to exit!”);
getch();
}

//បញ្ចប់

ហ្គេមចងចាំ
C C++
នេះ​គឺ​ជា​ហ្គេម​តំ​រូវ​អោយ​យើង​ធ្វើ​ការ​​រក​គូ​របស់លេខ​​! ​ លេខ​០​ទាំង​អស់​នេះ​តំ​ណាង​ប្រ​អប់​ដែល​មិន​ទាន់​បាន​បើក​ បើ​យើង​ចង់​បើក​វា​យើង​គ្រាន់​តែ​ចុច​ enter វា​និង​បង្ហាញ​នូវ​លេខ​ដែល​មាន​នៅ​ខាង​ក្នុង​ប្រ​អប់​នោះ​ជា​មិន​ខាន់​ ការ​បើក​ប្រ​អប់​ចំ​នួន​២​លើក​ ​បើ​ការ​បើក​លើ​ក​ទី​១​ និង​លើក​ទី​២​មាន​លេខ​មិន​ដូច​គ្នា​ទេ​ វា​និង​បិទ​​លេខ​ដែល​បង្ហាញ​នោះ​ទៅ​វិញ​ដោយ​បង្ហាញ​លេខ​០ តែ​បើ​​ការ​បើក​ទាំង​២​លើក​មាន​លេខ​ដូច​គ្នា​ វា​និង​បង្ហាញ​លេខ​នោះ​​រហូត​។

ពេល​ដែល​យើង​ចាប់​ផ្តើម​លេង​ វា​និង​បង្ហាញ​លេខ​ដែល​មាន​នៅ​ក្នុង​គ្រប់​ប្រ​អប់​បន្តិច​សិន​រួច​ហើយ​ទើប​​ចាប់​ផ្តើម​លេង

ចំ​ណាំៈ​ ដើម្បី​ធ្វើ​ការ​ move យើង​ប្រើ​ w,a,s,d យើង​ត្រូវ​លេង​វា​តាម​tc មិន​ត្រូវ​បើ​ក​ការ​ file exeទេវា​ត្រូវ​ការ​​ screen ធំ​

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<dos.h>
void main()
{       clrscr();
int r=10,c=10,i,j,b[10][10],x=0,y=0,count=0,x1,x2,y1,y2,win=0;
char ch=27;
_setcursortype(_NOCURSOR);
char level[3][10]={“Easy”,”Medium”,”Hard”},levelch;
int levelmove=0;
do
{    for(i=0;i<3;i++)
if(levelmove==i)
{    textcolor(RED);
cprintf(“\n\n\r\r%s”,level[i]);
}
else
{    textcolor(WHITE);
cprintf(“\n\n\r\r%s”,level[i]);
}
levelch=getch();
switch(levelch)
{    case ‘w’:    levelmove–;break;
case ‘s’:    levelmove++;break;
case 13:        goto daro;
}
if(levelmove>=3)
levelmove=0;
if(levelmove<0)
levelmove=2;
clrscr();
}while(1);
daro:
int a[10][10];
if(levelmove==0)
{    int  a0[10][10]={    {1,5,1,5,2,4,1,2,1,5},
{1,3,3,2,4,5,1,3,1,3},
{2,2,4,2,5,3,5,5,2,4},
{1,1,3,5,4,2,1,3,5,5},
{2,3,3,1,4,2,1,3,1,5},
{1,2,4,3,4,1,3,4,2,4},
{3,2,4,5,1,2,3,3,2,1},
{2,4,2,5,3,4,5,4,1,4},
{4,3,5,4,5,3,2,1,5,5},
{2,2,4,5,3,4,4,1,3,5},
};
for(i=0;i<10;i++)
for(j=0;j<10;j++)
a[i][j]=a0[i][j];
}
else if(levelmove==1)
{     int     a1[10][10]={    {4,2,1,5,4,4,5,4,7,5},
{2,3,4,2,1,5,4,3,5,6},
{3,5,4,2,1,3,5,3,4,1},
{6,7,3,5,1,4,3,2,2,5},
{6,4,7,3,5,6,1,2,6,4},
{7,3,2,6,6,7,1,6,4,2},
{6,5,6,7,7,1,7,1,6,1},
{7,4,7,5,5,1,6,3,3,2},
{6,1,2,7,2,1,7,2,3,3},
{7,1,5,7,6,1,1,2,4,3},
};
for(i=0;i<10;i++)
for(j=0;j<10;j++)
a[i][j]=a1[i][j];
}
else if(levelmove==2)
{      int    a2[10][10]={    {6,1,5,4,3,9,5,10,6,2},
{10,3,3,6,9,9,8,2,5,3},
{7,4,3,4,2,10,4,3,2,5},
{2,1,6,10,9,1,5,1,4,5},
{7,3,8,1,7,2,10,4,5,6},
{6,4,3,5,8,1,10,1,4,5},
{7,8,6,5,1,2,10,3,6,8},
{1,2,7,2,8,9,6,10,4,9},
{9,9,7,10,2,7,3,7,8,7},
{8,1,8,7,9,8,6,4,9,10},
};
for(i=0;i<10;i++)
for(j=0;j<10;j++)
a[i][j]=a2[i][j];
}
clrscr();
for(i=0;i
{    for(j=0;j<c;j++)
{          b[i][j]=0;
printf(“%5d”,a[i][j]);
}
printf(“\n\n\n\n”);
}
delay(1000);
clrscr();
do
{        for(i=0;i<r;i++)
for(j=0;j<c;j++)
if(a[i][j]==b[i][j])
win++;
if(win==(c*r))
{      clrscr();
textcolor(RED+128);
cprintf(“Congratulation \n\rYou win!”);
cprintf(“\n\rThank for playing”);
cprintf(“\n\rPress any key to exit”);
getch();
exit(1);
}
else
win=0;
for(i=0;i<r;i++)
{    for(j=0;j<c;j++)
if(i==x&&j==y)
{    textcolor(RED);
cprintf(“%5d”,b[i][j]);
}
else
{       textcolor(WHITE);
cprintf(“%5d”,b[i][j]);
}
printf(“\n\n\n\n”);
}

ch=getch();
switch(ch)
{
case ‘d’:y++;
break;
case ‘s’:x++;
break;
case ‘a’:y–;
break;
case ‘w’:x–;
break;
case 13: if(count==0&&b[x][y]==0)
{    count=1;
x1=x;y1=y;
b[x][y]=a[x][y];
}
else if(count==1&&b[x][y]==0)
{      if(x1==x&&y1==y)
break;
b[x][y]=a[x][y];
clrscr();
for(i=0;i<r;i++)
{    for(j=0;j<c;j++)
if(x==i&&y==j)
{    textcolor(RED);
cprintf(“%5d”,b[i][j]);
}
else
{    textcolor(WHITE);
cprintf(“%5d”,b[i][j]);
}
printf(“\n\n\n\n”);
}
delay(400);
if(b[x1][y1]!=b[x][y])
{    b[x1][y1]=0;
b[x][y]=0;
}
count=0;
}

break;
}
if(y<0)   y=c-1;
if(y>c-1) y=0;
if(x<0)   x=r-1;
if(x>r-1) x=0;
clrscr();
}while(ch!=27);
getch();
}

 

ហ្គេមតំរៀបលេខ ភាសាC
C C++
//ទាំងនេះជាហ្គេមតំរៀបលេខដែលសរសេរក្នុងភាសាC ពេលចាប់ផ្តើមលេងវានិងអោយយើង

//វាយលេខចំនួនជួរឈរនិងជួរដេក រួចចាប់ផ្តើមលេង។ លេខត្រូវបានតំរៀបដោយ​ random

//បើ​អ្នក​តំរៀប​លេខ​នោះ​តាម​លំដាប់​កើនចប់​សព្វ​គ្រប់​នោះ​អ្នក​​​និងឈ្នះដោយ​បង្ហាញ​ message យើងអាចធ្វើការរំកិលលេខដោយប្រើ w,a,s,d

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<dos.h>
void ran(int [20][20],int r,int c);
void main()
{
int a[20][20],r,c,i,j;
again:
clrscr();
printf(“Please enter rows:”);
scanf(“%d”,&r);
printf(“Please enter colums:”);
scanf(“%d”,&c);
ran(a,r,c);
clrscr();
char ch;
do
{    clrscr();
printf(“To EXIT press ‘ESC’!\ta=left,w=up,s=down,d=right\n\n\n”);
for( i=0;i
{    for( j=0;j<c;j++)
{    if(a[i][j]==0)
printf(”     “);
else
printf(“%5d”,a[i][j]);
}
printf(“\n\n\n”);
}
int z=1;
for(i=0;i
for(j=0;j<c;j++)
if(z==a[i][j])
z++;
else
goto a;
a:
if(z==(r*c))
{    printf(“You win!”);
printf(“\nDo u want to play again(y/n):”);
ch=getch();
if(ch==’y’||ch==’Y’)
goto again;
else
goto exit1;
}
ch=getch();
if(ch==’a’||ch==’d’||ch==’s’||ch==’w’)
{    switch(ch)
{    case ‘a’:    for(i=0;i
for(j=0;j<c;j++)
if(a[i][j]==0)
{    if(j==(c-1))
goto exit;
else
{    a[i][j]=a[i][j+1];
a[i][j+1]=0;
}
goto exit;
}
break;
case ‘d’:    for(i=0;i
for(j=0;j<c;j++)
if(a[i][j]==0)
{       if(j==0)
goto exit;
else
{    a[i][j]=a[i][j-1];
a[i][j-1]=0;
}
goto exit;
}
break;
case ‘w’:    for(i=0;i
for(j=0;j<c;j++)
if(a[i][j]==0)
{
if(i==(r-1))
goto exit;
else
{    a[i][j]=a[i+1][j];
a[i+1][j]=0;
}
goto exit;
}
break;
case ‘s’:    for(i=0;i
{    for(j=0;j<c;j++)
if(a[i][j]==0)
{       if(i==0)
goto exit;
else
{    a[i][j]=a[i-1][j];
a[i-1][j]=0;
}
goto exit;
}
}
break;
}
exit:
}
}
while(ch!=27);
getch();
exit1:
}
void ran(int a[20][20],int r,int c)
{  printf(“Please wait while loading….”);
int b[100],e[100],t=0,j,i;
for(i=0;i<100;i++)
b[i]=0;
for(i=0;i<r*c;i++)
{    again:
randomize();
e[i]=random(10000)%(r*c+1);
for(int j=0;j<=i;j++)
if(b[j]!=e[i])    t++;
else    goto again;
if(t<=i)
{  t=0;
goto again;
}
t=0;
b[i]=e[i];
}
int cre=0,r1,c1,max=r*c;
for(i=0;i<r;i++)
for(j=0;j<c;j++)
{    a[i][j]=e[cre];
cre++;
}
for(i=0;i<r;i++)
for(j=0;j<c;j++)
if(max==a[i][j])
{    r1=i;
c1=j;
}
a[r1][c1]=0;
}

 

លេងត្ររ(OX) នៅលើ Turbo C

C C++

/*នេះជាGame ត្រូវមានអ្នកលេង២នាក់ ពេលចាប់ផ្តើមវា វាអោយយើងវាឈ្មោះរួចអោយយើងជ្រើសរើសការលេង មាន២យ៉ាងគឺ

ការលេងមានម៉ោងកំណត់ និងមិនមានម៉ោងកំណត់។

ចំណាំ​​​ ដើម្បីធ្វើការរំកិលយើងប្រើ w,a,s,d រួចលេងពេលដាក់គ្រាប់ចុច Enter ហើយយើងត្រូវប្រើប្រាស់ turbo C លេង វាត្រូរការscreen ធំ មិនត្រូវបើកតាមfile exe ទេ*/

#include<stdio.h>
#include<dos.h>
#include<conio.h>
void main()
{    clrscr();
int row=16,col=16,i,j,x=1,y=1,time,time1;
char player1[50],player2[50],ch;
textcolor(WHITE);cprintf(“Player1 is:”);
textcolor(RED);  cprintf(“o”);
textcolor(WHITE);cprintf(“\n\rPlayer2 is:”);
textcolor(BLUE); cprintf(“x”);
textcolor(WHITE);
cprintf(“\n\n\r\rEnter player1’s name:”);gets(player1);
cprintf(“\n\n\r\rEnter player2’s name:”);gets(player2);
cprintf(“\n\n\r\rChose type of play:”);
cprintf(“\n\rPress 1:Play with limit time”);
cprintf(“\n\rPress 2:Play without limit”);
ch=getch();
if(ch==’1′)
{    clrscr();
cprintf(“\n\n\r\rMaximum time is 9999s if u set larger than 9999s.”);
cprintf(“\n\rTime is automatically set 9999s.”);
cprintf(“\n\n\r\rPlease Set time=”);
scanf(“%d”,&time1);
if(time1>9999)
time1=9999;
}
restart:
time=time1;
char A[100][100],turn=’o’;
_setcursortype(_NOCURSOR);
for(i=1;i<=row;i++)
for(j=1;j<=col;j++)
A[i][j]=’ ‘;
clrscr();

char move;
do
{
switch(move)
{    case ‘w’:y–;break;
case ‘s’:y++;break;
case ‘a’:x–;break;
case ‘d’:x++;break;
case 13 :if(A[x][y]==’o’||A[x][y]==’x’)
break;
if(turn==’o’)
{      time=time1;
turn=’x’;
A[x][y]=’o’;
break;
}
else
{      time=time1;
turn=’o’;
A[x][y]=’x’;
break;
}
defult:     break;
}
if(x>col)x=1;
if(x<1)x=col;
if(y>row)y=1;
if(y<1)y=row;
clrscr();

for(i=1;i<=row;i++)
{          for(j=1;j<=col;j++)
{    if(x==i&&y==j)
textcolor(GREEN);
else
textcolor(7);

gotoxy(i*3,j*3);
cprintf(“³ ³”);
gotoxy((i*3),(j*3)-1);
cprintf(“ÚÄ¿”);
gotoxy(i*3,(j*3)+1);
cprintf(“ÀÄÙ”);
gotoxy((i*3)+1,j*3);
if(A[i][j]==’o’)
{       textcolor(RED);
cprintf(“%c”,A[i][j]);
}
if(A[i][j]==’x’)
{       textcolor(BLUE);
cprintf(“%c”,A[i][j]);
}
}
}

gotoxy(51,49);
textcolor(RED);
cprintf(“Note:To restart play=Press ‘r’”);

if(turn==’o’)
{    textcolor(RED);
gotoxy(55,25);
cprintf(“%s turn!”,player1);
}
else
{       textcolor(RED);
gotoxy(55,25);
cprintf(“%s turn!”,player2);
}
textcolor(YELLOW);
gotoxy(55,3);
cprintf(“Player1’s name:%s”,player1);
gotoxy(55,4);
textcolor(WHITE);cprintf(“Player1:”);
textcolor(RED);  cprintf(“o”);
textcolor(YELLOW);
gotoxy(55,48);
cprintf(“Player2’s name:%s”,player2);
gotoxy(55,47);
textcolor(WHITE);cprintf(“Player2:”);
textcolor(BLUE); cprintf(“x”);
if(ch==’1′)
while(!kbhit())
{          gotoxy(55,27);
textcolor(YELLOW);
if(time>=10)
if(time>=100)
if(time>=1000)
cprintf(“Time left:%d”,time);
else
cprintf(“Time left:0%d”,time);
else
cprintf(“Time left:00%d”,time);
else
cprintf(“Time left:000%d”,time);

delay(700);
time–;
if(time<=0)
{       gotoxy(55,27);
textcolor(YELLOW);
cprintf(“Time left:000%d”,time);
gotoxy(55,28);
textcolor(YELLOW);
cprintf(“Game over!”);
gotoxy(55,29);
if(turn==’o’)
cprintf(“The Winner is: %s”,player2);
else
cprintf(“The Winner is: %s”,player1);
gotoxy(55,30);
cprintf(“Press any key to restart!”);
getch();

goto restart;
}
}
move=getch();
if(move==’r’)
goto restart;
}while(move!=27);
}


 

មេរៀនទី១៦: បង្ហាញម៉ោង ភាសា C

មេរៀនទី១៦បង្ហាញម៉ោង ភាសា C

1111111111111

//នេះជាកម្មវិធីសំរាប់បង្ហាញម៉ោងរបស់computer ពេលចូលកម្មវិធីនេះវានិងអោយធ្វើការរើសយកប្រភេទម៉ោងជា 24h រឺ 12h

#include<stdio.h>
#include<conio.h>
#include<dos.h>
void showtime();
char AP;
int i,x=10,hour1,hour2,sec1,sec2,min1,min2,hund1,hund2;
struct time d;
int count;
void aa()
{
while(!kbhit())
{
gettime(&d);
clrscr();
if(count==0)
{    hour1=d.ti_hour/10;
hour2=d.ti_hour%10;
x=3;i=hour1;showtime();
x=10;i=hour2;showtime();
}
else
{    if(d.ti_hour>12)
{
AP=’p’;
d.ti_hour=d.ti_hour-12;
hour1=d.ti_hour/10;
hour2=d.ti_hour%10;
x=3;i=hour1;showtime();
x=10;i=hour2;showtime();
}
else
{
AP=’a’;
hour1=d.ti_hour/10;
hour2=d.ti_hour%10;
x=3;i=hour1;showtime();
x=10;i=hour2;showtime();
}
}
gotoxy(16,7);
textcolor(RED);
cprintf(“Ü”);
gotoxy(16,11);
cprintf(“Ü”);
min1=d.ti_min/10;
min2=d.ti_min%10;
x=18;i=min1;showtime();
x=25;i=min2;showtime();
gotoxy(31,7);
textcolor(RED);
cprintf(“Ü”);
gotoxy(31,11);
cprintf(“Ü”);
sec1=d.ti_sec/10;
sec2=d.ti_sec%10;
x=33;i=sec1;showtime();
x=40;i=sec2;showtime();
gotoxy(46,7);
textcolor(RED);
cprintf(“Ü”);
gotoxy(46,11);
cprintf(“Ü”);
hund1=d.ti_hund/10;
hund2=d.ti_hund%10;
x=48;i=hund1;showtime();
x=55;i=hund2;showtime();
if(count!=0)
{
if(AP==’p’)
{
gotoxy(15,15);
printf(“Ü Ü Ü”);
gotoxy(15,16);
printf(“Ü   Ü”);
gotoxy(15,17);
printf(“Ü   Ü”);
gotoxy(15,18);
printf(“Ü   Ü”);
gotoxy(15,19);
printf(“Ü Ü Ü”);
gotoxy(15,20);
printf(“Ü    “);
gotoxy(15,21);
printf(“Ü    “);
gotoxy(15,22);
printf(“Ü    “);
gotoxy(15,23);
printf(“Ü    “);

}
else
{    gotoxy(15,15);
printf(“Ü Ü Ü”);
gotoxy(15,16);
printf(“Ü   Ü”);
gotoxy(15,17);
printf(“Ü   Ü”);
gotoxy(15,18);
printf(“Ü   Ü”);
gotoxy(15,19);
printf(“Ü Ü Ü”);
gotoxy(15,20);
printf(“Ü   Ü”);
gotoxy(15,21);
printf(“Ü   Ü”);
gotoxy(15,22);
printf(“Ü   Ü”);
gotoxy(15,23);
printf(“Ü   Ü”);
}
gotoxy(21,15);
printf(“Ü Ü Ü Ü Ü”);
gotoxy(21,16);
printf(“Ü   Ü   Ü”);
gotoxy(21,17);
printf(“Ü   Ü   Ü”);
gotoxy(21,18);
printf(“Ü   Ü   Ü”);
gotoxy(21,19);
printf(“Ü   Ü   Ü”);
gotoxy(21,20);
printf(“Ü   Ü   Ü”);
gotoxy(21,21);
printf(“Ü   Ü   Ü”);
gotoxy(21,22);
printf(“Ü   Ü   Ü”);
gotoxy(21,23);
printf(“Ü   Ü   Ü”);
}
delay(100);
clrscr();
}
}
void main()
{
char ch;
clrscr();
printf(“Enter ‘1’ show 24h”);
printf(“\nEnter ‘2’ show 12h”);
printf(“\nPlease choose:”);
ch=getch();
switch(ch)
{
case ‘1’:count=0;
aa();
case ‘2’:count=1;
aa();
}

getch();
}
void showtime()
{       textcolor(GREEN);

switch(i)
{
case 0: gotoxy(x,5);
cprintf(“Ü Ü Ü”);
gotoxy(x,6);
cprintf(“Ü   Ü”);
gotoxy(x,7);
cprintf(“Ü   Ü”);
gotoxy(x,8);
cprintf(“Ü   Ü”);
gotoxy(x,9);
cprintf(“Ü   Ü”);
gotoxy(x,10);
cprintf(“Ü   Ü”);
gotoxy(x,11);
cprintf(“Ü   Ü”);
gotoxy(x,12);
cprintf(“Ü   Ü”);
gotoxy(x,13);
cprintf(“Ü Ü Ü”);
break;
case 1: gotoxy(x,5);
cprintf(”   ÜÜ”);
gotoxy(x,6);
cprintf(”  Ü Ü”);
gotoxy(x,7);
cprintf(” Ü  Ü”);
gotoxy(x,8);
cprintf(“Ü   Ü”);
gotoxy(x,9);
cprintf(”    Ü”);
gotoxy(x,10);
cprintf(”    Ü”);
gotoxy(x,11);
cprintf(”    Ü”);
gotoxy(x,12);
cprintf(”    Ü”);
gotoxy(x,13);
cprintf(”    Ü”);
break;
case 2: gotoxy(x,5);
cprintf(“Ü Ü Ü”);
gotoxy(x,6);
cprintf(”    Ü”);
gotoxy(x,7);
cprintf(”    Ü”);
gotoxy(x,8);
cprintf(”    Ü”);
gotoxy(x,9);
cprintf(“Ü Ü Ü”);
gotoxy(x,10);
cprintf(“Ü    “);
gotoxy(x,11);
cprintf(“Ü    “);
gotoxy(x,12);
cprintf(“Ü    “);
gotoxy(x,13);
cprintf(“Ü Ü Ü”);
break;
case 3: gotoxy(x,5);
cprintf(“Ü Ü Ü”);
gotoxy(x,6);
cprintf(”    Ü”);
gotoxy(x,7);
cprintf(”    Ü”);
gotoxy(x,8);
cprintf(”    Ü”);
gotoxy(x,9);
cprintf(“Ü Ü Ü”);
gotoxy(x,10);
cprintf(”    Ü”);
gotoxy(x,11);
cprintf(”    Ü”);
gotoxy(x,12);
cprintf(”    Ü”);
gotoxy(x,13);
cprintf(“Ü Ü Ü”);
break;
case 4: gotoxy(x,5);
cprintf(“Ü   Ü”);
gotoxy(x,6);
cprintf(“Ü   Ü”);
gotoxy(x,7);
cprintf(“Ü   Ü”);
gotoxy(x,8);
cprintf(“Ü   Ü”);
gotoxy(x,9);
cprintf(“Ü Ü Ü”);
gotoxy(x,10);
cprintf(”    Ü”);
gotoxy(x,11);
cprintf(”    Ü”);
gotoxy(x,12);
cprintf(”    Ü”);
gotoxy(x,13);
cprintf(”    Ü”);
break;
case 5: gotoxy(x,5);
cprintf(“Ü Ü Ü”);
gotoxy(x,6);
cprintf(“Ü    “);
gotoxy(x,7);
cprintf(“Ü    “);
gotoxy(x,8);
cprintf(“Ü    “);
gotoxy(x,9);
cprintf(“Ü Ü Ü”);
gotoxy(x,10);
cprintf(”    Ü”);
gotoxy(x,11);
cprintf(”    Ü”);
gotoxy(x,12);
cprintf(”    Ü”);
gotoxy(x,13);
cprintf(“Ü Ü Ü”);
break;
case 6: gotoxy(x,5);
cprintf(“Ü Ü Ü”);
gotoxy(x,6);
cprintf(“Ü    “);
gotoxy(x,7);
cprintf(“Ü    “);
gotoxy(x,8);
cprintf(“Ü    “);
gotoxy(x,9);
cprintf(“Ü Ü Ü”);
gotoxy(x,10);
cprintf(“Ü   Ü”);
gotoxy(x,11);
cprintf(“Ü   Ü”);
gotoxy(x,12);
cprintf(“Ü   Ü”);
gotoxy(x,13);
cprintf(“Ü Ü Ü”);
break;
case 7: gotoxy(x,5);
cprintf(“Ü Ü Ü”);
gotoxy(x,6);
cprintf(”    Ü”);
gotoxy(x,7);
cprintf(”    Ü”);
gotoxy(x,8);
cprintf(”    Ü”);
gotoxy(x,9);
cprintf(”    Ü”);
gotoxy(x,10);
cprintf(”    Ü”);
gotoxy(x,11);
cprintf(”    Ü”);
gotoxy(x,12);
cprintf(”    Ü”);
gotoxy(x,13);
cprintf(”    Ü”);
break;
case 8: gotoxy(x,5);
cprintf(“Ü Ü Ü”);
gotoxy(x,6);
cprintf(“Ü   Ü”);
gotoxy(x,7);
cprintf(“Ü   Ü”);
gotoxy(x,8);
cprintf(“Ü   Ü”);
gotoxy(x,9);
cprintf(“Ü Ü Ü”);
gotoxy(x,10);
cprintf(“Ü   Ü”);
gotoxy(x,11);
cprintf(“Ü   Ü”);
gotoxy(x,12);
cprintf(“Ü   Ü”);
gotoxy(x,13);
cprintf(“Ü Ü Ü”);
break;
case 9: gotoxy(x,5);
cprintf(“Ü Ü Ü”);
gotoxy(x,6);
cprintf(“Ü   Ü”);
gotoxy(x,7);
cprintf(“Ü   Ü”);
gotoxy(x,8);
cprintf(“Ü   Ü”);
gotoxy(x,9);
cprintf(“Ü Ü Ü”);
gotoxy(x,10);
cprintf(”    Ü”);
gotoxy(x,11);
cprintf(”    Ü”);
gotoxy(x,12);
cprintf(”    Ü”);
gotoxy(x,13);
cprintf(“Ü Ü Ü”);
break;

}
}

//បញ្ចប់

មេរៀនទី១៧: ទាយមនុស្សតាមឈ្មោះ

មេរៀនទី១៧អនុវត្ត ទាយចរិតលក្ខណៈមនុស្សតាមឈ្មោះ

C C++

#include<stdio.h>

#include<conio.h>

#include<process.h>
#include<ctype.h>
void main()
{    again:
clrscr();
int i,n,num[50],sum=0,j,number;
char ch;
char a[50];
gotoxy(1,1);
printf(“Enter your name:”);
for(i=1;i<=1000;i++)
{
scanf(“%c”,&a[i]);
if(a[i]==10)
break;
}
j=i-1;
for(i=1;i<=j;i++)
{
if(a[i]==’a’||a[i]==’A’||a[i]==’j’||a[i]==’J’||a[i]==’s’||a[i]==’S’)
num[i]=1;
else if(a[i]==’b’||a[i]==’B’||a[i]==’k’||a[i]==’K’||a[i]==’t’||a[i]==’T’)
num[i]=2;
else if(a[i]==’c’||a[i]==’C’||a[i]==’l’||a[i]==’L’||a[i]==’u’||a[i]==’U’)
num[i]=3;
else if(a[i]==’d’||a[i]==’D’||a[i]==’m’||a[i]==’M’||a[i]==’v’||a[i]==’V’)
num[i]=4;
else if(a[i]==’e’||a[i]==’E’||a[i]==’n’||a[i]==’N’||a[i]==’w’||a[i]==’W’)
num[i]=5;
else if(a[i]==’f’||a[i]==’F’||a[i]==’o’||a[i]==’O’||a[i]==’x’||a[i]==’X’)
num[i]=6;
else if(a[i]==’g’||a[i]==’G’||a[i]==’p’||a[i]==’P’||a[i]==’y’||a[i]==’Y’)
num[i]=7;
else if(a[i]==’h’||a[i]==’H’||a[i]==’q’||a[i]==’Q’||a[i]==’z’||a[i]==’Z’)
num[i]=8;
else if(a[i]==’i’||a[i]==’I’||a[i]==’r’||a[i]==’R’)
num[i]=9;
else
num[i]=0;
}
for(i=1;i<=j;i++)
{
sum=sum+num[i];
}
printf(“\nSum=%d”,sum);
if(sum<=9)
number=sum;
else
for(i=1;i<=sum;i++)
{    if(sum-(9*i)>0&&sum-(9*i)<=9)
number=sum-(9*i);
}
printf(”  => Number=%d\n”,number);
if(number==1)
printf(“\n1.ONES\n\nOnes are the most confident and determined of all the numbers.They can do anything when they want to.Ones hate people telling them what to do,but they like telling other people what to do.”);
else if(number==2)
printf(“\n2.TWOS\n\nTwos are kind,shy,thoughtful and polite.They love animals,reading and staying at home.They usually feel really happpy or sad.”);
else if(number==3)
printf(“\n3.THREES\n\nThrees are certainly not lazy.They always do their work on time and still have lots of free time for hobbies.They’re also honest,sensible,reliable and patient with other people.”);
else if(number==4)
printf(“\n4.FOURS\n\nFours are quick and clever,and they can make people laugh.They’re not shy about saying what they think,but people don’t always like what they say.”);
else if(number==5)
printf(“\n5.FIVES\n\nFives are quicker than most people.They’re more intelligent too.They’re interested in lots of different things and are very friendly.They love travel and trying new things.”);
else if(number==6)
printf(“\n6.SIXES\n\nSixes are the happiest and the most optimistic of all the numbers.They find something good even when things are bad.They’ve got lots of friend because they’re so nice.”);
else if(number==7)
printf(“\n7.SEVENS\n\nSevens are clever,serious and quiet,and usually have only one or two close friends.They like being alone.They don’t like noisy crowds and large groups of people.Sevens love animals and the countryside.”);
else if(number==8)
printf(“\n8.EIGTHS\n\nEights are sensible,reliable and nice.In fact, they’re sometimes too kind to other people.They work hard and try hard at their hobbies.”);
else if(number==9)
printf(“\n9.NINES\n\nNines are clever and imaginative,but they’re sometimes lazy.They like having fun,and they are fun to be with.People usually like nines a lot,but nines are not always kind to other people.”);
else
printf(“\nUnkown!”);
printf(“\n\n\nRestart(y/n):”);
again1:
ch=toupper(getch());
if(ch==’Y’)
{       clrscr();
goto again;
}
else if(ch==’N’)
exit(1);
else
goto again1;
getch();
}

//បញ្ចប់

មេរៀនទី១៨: អនុវត្ត រូបផ្កាយ

មេរៀនទី១៨អនុវត្ត រូបផ្កាយ

C C++//នេះគ្រាន់តែជាការសរសេរលេងបង្ហាញរូបភាពផ្កាយដែលរីកពីតូចទៅធំចុះឡើងៗតែប៉ុណ្ណោះ

#include<stdio.h>
#include<conio.h>
#include<dos.h>
void main()
{
int i,e,j,k,m,n,b,c,d,f,x=40,y=20,i1=1;
clrscr();
n=1;
while(!kbhit())
{
for(i=1;i<=n;i++)
{
gotoxy(x,y);
textcolor(i1);
cprintf(“*”);
for(e=1;e<=i;e++)
{    gotoxy(x-i,y);
textcolor(i1);
cprintf(“*”);
}
for(j=1;j<=i;j++)
{    gotoxy(x+i,y);
textcolor(i1);
cprintf(“*”);
}
for(k=1;k<=i;k++)
{    gotoxy(x,y-i);
textcolor(i1);
cprintf(“*”);
}
for(m=1;m<=i;m++)
{    gotoxy(x,y+i);
textcolor(i1);
cprintf(“*”);
}

for(b=1;b<=i;b++)
{    gotoxy(x-i,y+i);
textcolor(i1);
cprintf(“*”);
}
for(c=1;c<=i;c++)
{    gotoxy(x+i,y+i);
textcolor(i1);
cprintf(“*”);
}
for(d=1;d<=i;d++)
{    gotoxy(x-i,y-i);
textcolor(i1);
cprintf(“*”);
}
for(f=1;f<=i;f++)
{    gotoxy(x+i,y-i);
textcolor(i1);
cprintf(“*”);
}
i1++;
if(i1==16)
i1=1;
}

n++;

if(n==20)
{    n=1;

}

delay(100);
clrscr();

}
getch();
}

//បញ្ចប់