C/C++...ម ម នទ ៜ អ ព ភ ស C/C++ C ឬ C++ ជ Programming Language ដ លស មស ស រ ប បម ក ត ក មវធ ម ក មល ក ព ព *ទ ម នព

មេម ៀនទ១ អពភាសា 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’ ;

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

* មបើច 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

I. ពបមេទទនានយ

I.1. នយេនយ ទនានយ (Data) េជាបណាា ពតមានដែលមានពតែច ជា អតាបទ

តនលមលខ សមល ន បភាព សដែមពកាេទ េយ ដែលក ពយទ ោចមធវើកា ពបាសសយទកទ ឬអន វតាន កា ងា ណាេយជាេយវាបាន។ I.2.

ពបមេទទនាយ (Data Type) កា ភាសា 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

មយើោចស មស បណាា 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

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 មនាោះពតវបញច បមដឋយសញញា ( ប ។

ពនតយ ឧទ ខាមពកាេ ៖េ នាតនល 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 នវតនល ខ ម ើយេ នា ៖

មេម ៀនទ៥: វល 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 ពតវបានបងាា ញ

បដនាេមដឋយ បខាមពកាេ ៖

ចណា ៖

ច បនាា តេμ ានសញញា ច ចមកបៀស (;) មទ (េែចគាា ជា េយកា ពបកាស 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 េជាបាារាា ដេពតដែលពតវបញច លតនលមោយវា។

= = = = = * = = = = =

Posted in មេម ៀន, មេម ៀន C Programming |

មេម ៀនទ៧: Array & Pointer

Posted on by TEAV Chhun Nan (ទនាកទន ផាយរ ាកេម 077778647-

070778647)

មេម ៀនទ៨: 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 ។

មបើច 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 ែច បខាមពកាេ ៖

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

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

េកែលមពលមនោះ អាកពបាកែជាបានែោាចាស ម ើយអព មបៀបពបកាសអមថ សរាបផា កពេបពបមេទទនានយ ែចជាពបមេទ ចននេត (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

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);

}

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

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 ….

លទាផល បស 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 េជាេកដឋា នពេោះដែល ពតវកាា បមោយបាន ។

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

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 ។

+

Loop ទ២ ៈ ptr = calloc (1, sizeof (struct employye));

strcpy (ptrÆname, name);

printf (“Age :”), scanf (“%d”, &ptrÆage);

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

ptr Æ next =

last;

last = ptr;

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/

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);

+

មពកាយពមៅ Q = TT (last); Q

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’);

/* 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;

}

Posted in មេម ៀន, មេម ៀន C Programming |

មេម ៀនទ១២: ពកាេច GRAPHIC

Posted on by TEAV Chhun Nan (ទនាកទន ផាយរ ាកេម 077778647-

070778647)

មេម ៀនទ១២: ពកាេច GRAPHIC

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 មទ ។

អន េេន 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 ។

មយើោចផទេ សបា 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;

}

}