ផ្នែកទី២៖ ភាសា C សម្រាប់ MikroC

 

1-   ភាសា

មៃក្រូខុនត្រូល័រអនុវត្តកម្មវិធីដែលរក្សាទុកក្នុង Flash Memory ។ កម្មវិធីនោះផ្សំឡើងដោយទិន្នន័យ គោលពីរដែលមៃក្រូខុនត្រូល័រអាចយល់បាន ឫគេហៅថាភាសាម៉ាស៊ីន ។ ភាសាម៉ាស៊ីនមានទម្រង់ជាគោ លពីរ ប៉ុន្តែជាទូទៅគេតាងវាជាគោល 16 ដើម្បីឲ្យខ្លី ហើយអ្នកសរសេរកម្មវិធីមិនងាយនឹងយល់ភាសាម៉ា ស៊ីនទេ ។ ដូចនេះគេតាងភាសាម៉ាស៊ីនជានិមិត្តសញ្ញាដែលមានអត្ថន័យគ្រប់គ្រាន់ហើយអាចយល់បាន គេហៅថាភាសា Assembly ។ ភាសា Assembly មានប្រវែងខុសៗគ្នា ឧទាហរណ៍៖ 12-bit 14-bit ឫ 16-bit ជាដើម ហើយខុសៗគ្នាទៅតាមស្ថាបត្យកម្មនៃមៃក្រូខុនត្រូល័រនីមួយៗ ។ ពាក្យបញ្ជា (instruction) ជាធាតុនៃភាសា Assembly ។ពាក្យបញ្ជាទាំង អស់នៃមៃក្រូខុនត្រូល័រមួយ គេហៅថាសំនុំនៃពាក្យបញ្ជា (Instructions Set) ។ ចំពោះ PIC16 ឧទាហ រណ៍ PIC16F887 មានសំនុំពាក្យបញ្ជាចំនួន 35 និងប្រវែងនៃពាក្យបញ្ជានីមួយគឺ 14-bit ដូចៗគ្នា ។

pic-microcontrollers-programming-in-c-chapter-02-image-1

យើងសរសេរកម្មវិធីឲ្យមៃក្រូខុនត្រូល័រនៅក្នុងកុំព្យូទ័រ (Personal Computer) ដោយប្រើ Compiler ។ Compiler គឺកម្មវិធីមានតួរនាទីបំលែងកម្មវិធីដែលយើងសរសេរជាភាសា Assembly ឲ្យទៅជាភាសា របស់ម៉ាស៊ីននៃមៃក្រូខុនត្រូល័រ ។ ជាទូទៅគេហៅ Compiler សម្រាប់ភាសា Assembly ថា Assembler ។

pic-microcontrollers-programming-in-c-chapter-02-image-2

ភាសា Assembly មានទំនាក់ទំនងដោយផ្ទាល់ទៅនឹងដំណើរការខាងក្នុងរបស់មៃក្រូខុនត្រូល័រ ដូចជា ការផ្ទេរទិន្នន័យពីថតទិន្នន័យមួយទៅថតទិន្នន័យមួយ ការបញ្ជាទៅ ALU ឲ្យធ្វើប្រមាណវិធីនព្វន្តជាដើម។ ការសរសេរកម្មវិធីក្នុងភាសា Assembly ចំនេញទំហំ ROM កម្មវិធីមានល្បឿនប្រតិបត្តិការលឿន ។ ប៉ុន្តែ ការសរសេរកម្មវិធីក្នុងកម្មវិធីនេះចំណាយពេលកាន់តែយូរ និងកាន់តែស្មុគស្មាញប្រសិនបើទំហំការងារ កាន់ តែធំ ។

pic-microcontrollers-programming-in-c-chapter-02-image-4

ដើម្បីសម្រួលដល់ការសរសេរកម្មវិធីសម្រាប់មៃក្រូខុនត្រូល័រ ក្រុមហ៊ុនផលិត និងអ្នកបង្កើត Compiler ព្យាយ៊ាមបង្កើត Compiler ដែលប្រើភាសាកម្រិតខ្ពស់ជាងនេះដើម្បីសរសេរកម្មវិធី ។ នាពេលបច្ចុប្បន្នភា សា C ជាភាសាដែលគេប្រើយ៉ាងទូលំទូលាយបំផុតក្នុងពិភពមៃក្រូខុនត្រូល័រ ។ ភាសា C មានភាពងាយ ស្រួលសរសេរ មិនសូវស្មុគស្មាញ ប៉ុន្តវាត្រូវការទំហំ ROM ធំ បើប្រៀបធៀបទៅនឹងភាសា Assembly ។

pic-microcontrollers-programming-in-c-chapter-02-image-5

C Compiler ជាកម្មវិធីដែលដំណើរការនៅក្នុងកុំព្យូទ័រ ហើយវាមានតួនាទីសម្រាប់បំលែងកម្មវិធីជា ភាសា C ឲ្យទៅជាភាសាម៉ាស៊ីន ។ ទោះបីជាយើងសរសេរយើងសរសេរជាភាសាស៊ីក៏ដោយ ក៏ Compiler ត្រូវបំលែងពីភាសាស៊ី ឲ្យទៅជាភាសា Assembly សិនទើបបំលែងទៅជាភាសាម៉ាស៊ីនចុងក្រោយបង្អស់។

pic-microcontrollers-programming-in-c-chapter-02-image-6

2-   មូលដ្ឋាននៃភាសា C

ជាទូទៅសម្រាប់អ្នកសរសេរកម្មវិធី មុននឹងសរសេរកម្មវិធីគេត្រូវរៀបចំផែនការ ហើយបំបែកផែនការ នេះជាចំណែកតូចៗ និងទៅតាមជំហ៊ានៗ ។ ឧទាហរណ៍យើងចង់សរសេរកម្មវិធីសម្រាប់អានសីតុណ្ហ ភាពពីសេនស័រ ហើយបង្ហាញស៊ីតុណ្ហភាពទៅក្នុងអេក្រង់ ។

pic-microcontrollers-programming-in-c-chapter-02-image-9

យើងត្រូវបំបែកការងារនេះទៅតាមជំហ៊ានៗ ដូចខាងក្រោម៖

  • កំណត់ និងបើកប្លុក ADC
  • អានតម្លៃអាណាឡូកពីសេនស័រសីតុណ្ហភាព
  • គណនាសីតុណ្ហភាព
  • ផ្ទេរទិន្នន័យនៃសីតុណ្ហភាព ទៅកាន់អេក្រង់ ។

ចំណាំ៖ កម្មវិធី MikroC មានតួនាទីបំលែងភាសា C ឲ្យទៅជាភាសាម៉ាស៊ីន ។ ភាសាស៊ីដែលសរសេរនៅ ក្នុងមៃក្រូស៊ីមានទម្រង់ និងអនុលោមទៅតាមស្តង់ដារួមនៃភាសាស៊ី ។ ប៉ុន្តែកូដក្នុងមៃក្រូស៊ីទាំងអស់មិន សុទ្ធតែអាចសរសេរក្នុង Compiler ផ្សេងនៅក្នុងម៉ាស៊ីនកុំព្យូទ័របានទេ ។

  • COMMENTS

Comments ជាកំណត់ហេតុ ឫការកំណត់ចំណាំសម្រាប់អ្នកសរសេរកម្មវិធី ដូចជាសំគាល់ថ្ងៃខែ គោលបំណងនៃកម្មវិធី ឫដំណើរការនៃប្លុកនីមួយៗជាដើម ។ Comments មិនត្រូវបានរាប់បញ្ចូលទៅ ក្នុងកម្មវិធីពេលយើង Compile ទេ ។

ការសរសេរ Comment មានពីររបៀគឺ៖

  • single-line comment ៖ ចាប់ផ្តើមសញ្ញាស្លាស់ពីរដង //

ឧទាហរណ៍៖

// this is a comment of a test program

// write your code below

// start timer0

  • Multiple-lines comment ៖ ផ្តើមដោយសញ្ញា /* និងបញ្ចប់ដោយសញ្ញា */

ឧទាហរណ៍៖

/* A program to demonstrate external interrupt */

/* C Program Demo

A program for finding odd integer or even integer

written by Mr. Sambo Jai

Date: 25 December 2015

*/

  • ប្រភេទទិន្នន័យ

ខាងក្រោមជាប្រភេទទិន្នន័យដែលកម្មវិធីមៃក្រូស៊ី រួមជាមួយទំហំ និងដែនកំណត់ ។

ប្រភេទ ពិពណ៌នា ទំហំ (ចំនួន bits) ដែនកំណត់
bit Bit type 1-bit 0 ឫ 1
sbit Bit type 1-bit 0 ឫ 1
char Characer 8 0 ទៅ 255
signed char Signed 8 -128 ទៅ 127
Unsigned short int Unsigned Short integer 8 0 ទៅ 255
short int Signed short integer 8 -128 ទៅ 127
int Integer 16 -32768 ទៅ 32767
unsigned int Unsigned integer 16 0 ទៅ 65535
long signed Long integer 32 -2147483648 ទៅ 2147483647
unsigned long i unsigned long integer 32 0 ទៅ 4294967295
float Floationg point 32 ±1.17549435082 x 10-38 ទៅ

±6.80564774407 x 1038

double Double Precision Floating point 32 ±1.17549435082 x 10-38 ទៅ

±6.80564774407 x 1038

2-3 អថេរ (Variable)

អថេរជាកន្លែងរក្សាទុកទិន្នន័យ ហើយតម្លៃនៃទិន្នន័យនេះអាចមានការប្រែប្រួលនៅពេលកម្មវិធីដំ ណើរការ ដូចជាការលុបទិន្នន័យ ការកើនតម្លៃ ឫប្រមាណវិធីទៅលើទិន្នន័យជាដើម ។

ជាទូទៅយើងប្រកាសទិន្នន័យដូចខាងក្រោម៖

ប្រភេទទិន្នន័យ ឈ្មោះនៃទិន្នន័យ

ឧទាហរណ៍៖   int temperature;

                   char grade;

ម្យ៉ាងទៀតយើងអាចផ្តល់តម្លៃដើមឲ្យអថេរនៅពេលប្រកាស៖

unsigned short int speed=0;

char RCV=’C’;

ក្រឹតក្រមខ្លះសម្រាប់ការប្រកាសអថេរ៖

  • ឈ្មោះនៃអថេរជាតួរអក្សរពី A ដល់ Z ពី a ដល់ z ពីលេខ 0 ដល់ 9 ប្រើសញ្ញា _ ជំនួសឲ្យការ ដកឃ្លា
  • មិនត្រូវមានតួរលេខនៅខ្ទង់ដំបូងគេទេ
  • ពាក្យមួយចំនួនមិនត្រូវបានអនុញ្ញាតឲ្យប្រើជាឈ្មោះរបស់អថេរទេ ។ ពាក្យនោះគេហៅថា Keywords មានដូចខាងក្រោម៖
ពាក្យគន្លឹះក្នុងមៃក្រូស៊ី
absolute data if return typedef
asm default inline rx typeid
at delete int sfr typename
auto do io short union
bit double long signed unsigned
bool else mutable sizeof using
break enum namespace static virtual
case explicit operator struct void
catch extern org switch volatile
char false pascal template while
class float private this
code for protected throw
const friend public true
continue goto register try

2-4 Pointer

Pointer ជាអថេរប្រភេទពិសេសមានតួនាទីរក្សាទុកនូវអាស័យដ្ឋាននៃអថេរផ្សេង ។ យើងអាចនិយាយ បានថា Pointer ចង្អុរទៅកាន់អថេរផ្សេង ។ យើងប្រកាស Pointer ដូចខាងក្រោម៖

ប្រភេទអថេរ   ឈ្មោះនៃPointer;

ឧទាហរណ៍៖

unsigned int *multiplex;     // ប្រកាស pointer ឈ្មោះ multiplex

multiplex = &display1;        // multiplex រក្សាទុកអាស័យដ្ឋាននៃអថេរឈ្មោះ Display

 

ដើម្បីផ្តល់តម្លៃថ្មីឲ្យ pointer យើងត្រូវដាក់សញ្ញាផ្កាយ * នៅពីមុខឈ្មោះនៃ Pointer៖

ឧទាហរណ៍៖

*multiplex=6;           // យើងផ្តល់តម្លៃឲ្យអថេរ display1=6

ស្រដៀងគ្នានេះដែរដើម្បីអានតម្លៃពីអថេរដែលយើងបានចង្អុលទៅយើងត្រូវសរសេរដូចខាងក្រោម៖

ឧទាហរណ៍៖

temp=*multiplex;    //  ផ្ទេរតម្លៃពីអថេរ display1 ទៅឲ្យ temp

2-5 ចំនួនថេរ (Constant)

ចំនួនថេរគឺជាតម្លៃលេខដែលតម្លៃរបស់វាត្រូវបានកំណត់រួចទុកជាមុន ហើយមិនអាចប្រែប្រួលឫកែ តម្រូវនៅពេលកម្មវិធីដំណើរការទេ ។ ខុសពីអថេរដែលរក្សាតម្លៃទុកនៅក្នុង RAM ចំនួនថេររក្សាតម្លៃរបស់ វាទុកនៅក្នុង ROM ដើម្បីសន្សំសំចៃផ្ទៃ RAM ។

  • Integer Constants
ទម្រង់ (Format) បុព្វបទ(prefix) ឧទាហរណ៍
Decimal const MAX = 100;
Hexadecimal 0x ឫ 0X const MAX = 0xFF;
Octal 0 const MAX = 016
Binary 0b ឫ 0B const MAX = 0b11011101
  • Floating Point Constant

ចំនួនថេរជាតំលៃទស្សភាគត្រូវប្រកាសដូចខាងក្រោម ។ អក្សរ e ឫ E តំណាងឲ្យដប់ស្វ័យគុណ ៖

const T_MAX = 32.60;       // Declare Temperature T_MAX

const T_MAX1 = 32.26E1;   // Another declaration

  • Character Constants (ASCII)

ចំនួនថេរជាតួរអក្សរ តួរអក្សរដែលត្រូវផ្តល់ឲ្យត្រូវដាក់ក្នុងសញ្ញា ‘  ‘ ។

ឧទាហរណ៍៖

const class1 = ‘A’;         // ផ្តល់កូដ ASCII A ទៅឲ្យចំនួនថេរ class1

const class2 = ‘B’;         // ផ្តល់កូដ ASCII B ទៅឲ្យចំនួនថេរ class2

  • String Constants

ចំនួនថេរដែលបង្កើតឡើងដោយសេរ៊ីនៃតួរអក្សរដែលគេហៅថា String ។ ចំនួនថេរជា String ត្រូវ ស្ថិតនៅក្នុងសញ្ញា “  “ ។

ឧទាហរណ៍៖

const message_1 =  “ Press START Button”;

const message_2 = “ Press STOP Button”;

const message_2 = “ Press OK Button”;

  • Enumerated constants

Enumerated Constant ជាចំនួនថេរពិសេសមួយ យើងប្រើវាដើម្បីឲ្យកូដដែលយើងសរសេរងាយ យល់ ។ Enum ជំនួសតម្លៃលេខរៀង ដោយនិមិត្តសញ្ញាដែលយើងអាចយល់បាន ។

ឧទាហរណ៍៖

enum MOTORS { UP , DOWN , LEFT , RIGHT } ;       // constants of motor

ក្នុងឧទាហរណ៍ខាងលើ Compiler នឹងជំនួស UP ដោយលេខ 0 DOWN ដោយលេខ 1 LEFT ដោយលេខ 2 និង RIGHT ដោយលេខ 3 ។

2-6 OPERATORS OPERATIONS និង EXPRESSIONS

ការី (OPERATOR) មានច្រើនដូចជា ការីនព្វន្ត (arithmetic Operator) ការីឡូស៊ីក (logical operator)និងការីផ្សេងៗទៀត ។

  • ការីនព្វន្ត
ការី ប្រមាណវិធី
+ បូក
ដក
* គុណ
/ ចែក
% សំណល់
  • ការីផ្តល់តម្លៃ (សញ្ញា = ) (assignment operator)
ការី ឧទាហរណ៍
កន្សោម (expression) សមមូល
+= a+=8 a=a+8
-= a-=8 a=a-8
*= a*=8 a=a*8
/= a/=8 a=a/8
%= a%=8 a=a%8
  • ការីបង្កើន និងបន្ថយតម្លៃ (increment and decrement operator)
ការី ឧទាហរណ៍ ពិពណ៌នា
++ ++a អថេរ a កើនតម្លៃ 1
a++
–b អថេរ b ថយតម្លៃ 1
b–
  • ការីប្រៀបធៀប (Rational Operators)

ការីប្រៀបធៀបប្រើសម្រាប់ប្រៀបធៀបរវាងអថេរពីរ ។ ប្រសិនបើកន្សោម(Expression)នោះពិត វានឹងបោះតម្លៃ 1 បើមិនដូចច្នេះទេ វានឹងបោះតម្លៃ 0 ។

ការី អត្ថន័យ ឧទាហរណ៍
> ធំជាង b > a
=> ជំជាងឫស្មើរ a >= 5
< តូចជាង a < b
<= តូចជាង ឫស្មើរ a <= b
== ស្មើរ a == 6
!= មិនស្មើរ a != b
  • ការីឡូស៊ីក (Logic Operater)

នៅក្នុងភាសាស៊ី មានការីឡូស៊ីកបីគឺ៖ AND (និង) OR (ឫ) និង NOT (ផ្ទុយ) ។ ក្នុងតត្កវិទ្យាគេតាង ធាតុពិត(TRUE) ដោយ 1 និងធាតុមិនពិត (False) ដោយ 0 ។

ការី AND
 && A B លទ្ធផល

(A&&B)

0 0 0
0 1 0
1 0 0
1 1 1
ការី OR
|| A B លទ្ធផល

(A||B)

0 0 0
0 1 1
1 0 1
1 1 1
ការី NOT
! A លទ្ធផល (NOT A )
0 1
1 0

2-7 Bitwise Operators

ការីនេះធ្វើប្រមាណវិធីទៅលើទិន្នន័យម្តងមួយ bit ម្តងមួយ bit ។ ជាទូទៅគេច្រើនប្រើការីប្រភេទនេះ សម្រាប់កែតម្រូវប៊ីតនៅក្នុងអថេរ ។

ការី អត្ថន័យ ឧទាហរណ៍ លទ្ធផល
~ Bitwise complement (ផ្ទុយ) a = ~ b ; b = 11110000 a = 00001111
<< រំកិលទៅខាងឆ្វេង a = b << 2; b = 11110011 a = 11001100
>> រំកិលទៅខាងស្តាំ a = b >> 2; b = 11110011 a = 00111100
& Bitwise AND c = a & b a = 11100011

b = 11001100

c = 11000000
| Bitwise OR c = a | b a = 11100011

b = 11001100

c = 111011111
^ Bitwise XOR c = a ^ b a = 11100011

b = 11001100

c = 00101111

2-8 Conditional Operator

លក្ខណជាធាតុផ្សំយ៉ាងសាមញ្ញក្នុងកម្មវិធី ។ ពេលខ្លះយើងត្រូវការធ្វើប្រមាណវិធីទៅតាមលក្ខណនី មួយៗដែលបានកំណត់ ។

  • if

វាមានទំម្រង់ដូចខាងក្រោម៖

if(expression) operation;

ប្រសិនបើ expression នៅក្នុង if ពិតនោះ operation នឹងត្រូវប្រតិបត្ត ។

  • if-else

វាមានទម្រង់ដូចខាងក្រោម៖

if(expression) operation1;

else    operation2;

ប្រសិនបើ expression ពិតនោះ operation1 នឹងត្រូវប្រតិបត្ត បើពុំដូចច្នោះទេ operation2 នឹងត្រូវ ប្រតិបត្ត ។ ជារឿយៗ ក្នុងលក្ខណនីមួយៗមាន operation ច្រើនដូចនេះគេត្រូវប្រើសញ្ញា {} ដើម្បីផ្តុំ operation ទាំងនោះ ។

យើងអាចជំនួស if-else ដោយការី ? ដូចខាងក្រោម៖

(expression1)?expression2 : expression3

ប្រសិនបើ expression1 ពិត នោះលទ្ធផលនៃប្រមាណវិធីទាំងមូលគឺជាតម្លៃនៃ expression2 បើមិន ដូចច្នោះទេលទ្ធផលនៃប្រមាណវិធីទាំងមូលគឺជាតម្លៃនៃ Expression3 ។

ឧទាហរណ៍៖

maximum= (a>b)? a : b;

ក្នុងឧទាហរណ៍ខាងលើប្រសិនបើ a ពិតជាធំជាង b មែននោះលទ្ធផលគឺជ្រើសរើសយក a បើមិនដូច ច្នោះទេគឺជ្រើសរើស b ។

  • Switch

នៅពេលយើងត្រូវការជ្រើសរើសលក្ខណច្រើន អ្នកសរសេរកម្មវិធីច្រើនប្រើប្រាស់ Switch ព្រោះវាមាន សណ្តាប់ធ្នាប់ជាង និងងាយស្រួលយល់។

Switch មានទម្រង់ដូចខាងក្រោម៖

switch(selector)           // selector is int or char type

{    

      case constant1:

               operation1;    // operation1 is executed if selector and constant1 are equal

               break;

      case constant2:

               operation2;   // operation2 is executed if selector and constant2 are equal

               break;

      default:

               operation;     // operation is executed if no constant is equal to selector

               break;

}

switch ដំណើរការដូចតទៅ៖

  • selector ត្រូវបានអនុវត្តដំបូងគេ ហើយវាត្រូវបានប្រៀបធៀបនឹង constant1 ។
  • ប្រសិនបើ selector និង constant1 ស្មើរគ្នានោះ statement នៅក្នុង case ត្រូវបានអនុវត្ត រហូតដល់ break ទើបចាកចេញ ។
  • ប្រសិនបើ selector និង constant1 មិនស្មើរគ្នាទេ វានឹងប្រៀបធៀប selector ទៅនឹង constant2 ប្រសិនបើវាស្មើរគ្នានោះ statement នៅក្នុង case ត្រូវបានអនុវត្ត ។
  • ប្រសិនបើ selector មិនស្មើរគ្នាទៅនឹង constant ណាមួយទេនោះវានឹងអនុវត្ត default ។

2-9 LOOP

  • while loop មានទម្រង់ដូចខាងក្រោម៖

while(expression) {

     commands;

}

ក្នុងនេះ commands ត្រូវបានអនុវត្តម្តងហើយម្តងទៀត រហូតដល់ expression នៅក្នុង while មិន ពិត ។ ក្នុងករណីដែល expression មិនពិតនោះប្លុកទាំងប៉ុន្មានរបស់ while ត្រូវបានរំលងចោល ។

ឧទាហរណ៍៖

while(Button==1) {

LED=1;

}

  • for loop

for loop មានទម្រង់ដូចខាងក្រោម៖

for(initial_expression; condition_expression;increment_expression)

      operation;

initial_expression ជាការផ្តល់តម្លៃឲ្យតំបូងឲ្យអថេរ ហើយតម្លៃនោះត្រូវបានប្រៀបធៀបទៅនឹង លក្ខណ condition_expression សិនមុននឹង loop ដំណើរការ ។ increment_condition ជាការកើន តម្លៃឲ្យអថេរ ។ loop នឹងដំណើរការម្តងហើយម្តងទៀត លុះដល់ condition_expression មិនពិត ។

ឧទារហណ៍៖

for(k=1;k<5;k++)           // k is increment 5 time

operation;               // so this operation is repeated 5 time

  • do-while loop

do-while loop ធ្វើការម្តងហើយទើបពិនិត្យមើលលក្ខណ check_condtion ។ ប្រសិនបើ check_condtion ពិត វានៅតែបន្ត បើពុំដូចច្នោះទេវានឹងចាកចេញពី loop ។

វាមានទម្រង់ដូចខាងក្រោម៖

do

operation;

while(check_condtion);

ឧទាហរណ៍៖

a=0;

do

a=a+1;      // increment a by one

while(a<10);       // a is increment until 9 before exiting the loop

2-10 ARRAY

Array ជាបណ្តុំនៃអថេរដែលមាប្រភេទដូចៗគ្នា ។ ការប្រកាស array មានទម្រង់ដូចខាងក្រោម៖

type array_name [number_of_element];

ឧទាហរណ៍៖

unsigned char days[7]={1,2,3,4,5,6,7};

ក្នុងឧទាហរណ៍ខាងលើធាតុនីមួយៗ របស់ array ឈ្មោះ days មានដូចជា៖

ធាតុទី០៖    days[0]=1;

ធាតុទី១៖    days[1]=2;

——————————-

ធាតុទី៦៖    days[6]=7;

ដូចគ្នានេះ យើងអាចប្រកាស Array នៃ character ដូចខាងក្រោម៖

const char msg[] = “TEST”;

const char txt_box[]= { ‘T’ , ‘e’ , ‘s’ , ‘ t ‘ , ‘\n’ } ;

2-11 Two-dimensional Array

Array ប្រភេទនេះមានលក្ខណៈដូចគ្នានឹងម៉ាទ្រីស ដែលមានជួរដេក (row ) និងជួរឈរ (column) យើងប្រកាសវាដូចខាងក្រោម៖

type array_nam [rows][columns];

ឧទាហរណ៍៖

int Table [3][4];    // Table has 3 rows and 4 columns

int Temp_data[2][3]={ {3,42,1} , {2,15,3} };

តារាងខាងក្រោមបង្ហាញពីធាតុនីមួយៗ នៃ Temp_data៖

3 42 1
2 15 3

2-12 អនុគមន៍ (Functions)

នៅក្នុងកម្មវិធីប្លុកនៃ expression ជាច្រើន ។ ប្រសិនបើកម្មវិធីមានភាពស្មុគស្មាញយើងត្រូវបំបែកវា ជាប្លុកតូចៗ ឫកម្មវិធីរង(subprogram)ជាច្រើន ។ គេតែងហៅ Function ថាជាកម្មវិធីរង ដែលបោះ តម្លៃត្រលប់មកកម្មវិធីមេ (main) វិញទៅតាមប៉ារ៉ាម៉ែត្រដែលបានដាក់ចូល ។ យើងអាចបោះតម្លៃចេញ ពីអនុគមន៍ដោយប្រើ Expression ។ បើតាមលក្ខណៈបច្ចេកទេស គេថាអនុគមន៍គឺជាបណ្តុំនៃ Epression ។

ជាទូទៅការប្រកាសអនុគមន៍ត្រូវមានធាតុដូចខាងក្រោម៖

  • Function name (ឈ្មោះនៃអនុគមន៍)
  • Function body (តួរខ្លួននៃអនុគមន៍)
  • list of parameters (តារាងនៃប៉ារ៉ាមែត្រ)
  • Declaration of parameters (ការប្រកាសប៉ារ៉ាម៉ែត្រ)
  • type of function result (ប្រភេទនៃលទ្ធផល ឫតម្លៃដែលបោះមក)

យើងប្រកាសវាដូចខាងក្រោម៖

type function_nam (list_of_parameters);

 

  • Function Defination

ការកំណត់តួនាទីនៃអនុគមន៍ បង្កើតឡើងដោយ៖ ការប្រកាសអនុគមន៍ និងតួរខ្លួននៃអនុគមន៍ ។ តួរខ្លួននៃអនុគមន៍គឺជាបណ្តុំនៃ statements ហើយខ័ណ្ឌចែកដោយសញ្ញា {} ។ អនុគមន៍អាចបោះតម្លៃ ត្រលប់មកកម្មវិធីមេ ឫក៏មិនបោះតម្លៃត្រលប់ ។ អនុគមន៍ដែលមិនបោះតម្លៃត្រលប់ជាប្រភេទ void ។

ទម្រង់នៃការកំណត់អនុគមន៍៖

type_of_result function_name (type argument1, type argument2,….)

{   

     command1;

     command2;

}

 

ដើម្បីបោះតម្លៃត្រលប់មកកម្មវិធីធំ យើងត្រូវប្រើ return statement ។ return statement មាន ទម្រង់៖ return [expression];

ឧទាហរណ៍៖

            /* function max returns greater one of its 2 arguments: */

int max(int x, int y)

{

return (x>=y) ? x : y;

}

  • ការហៅអនុគមន៍មកប្រើ (Function Call)

ក្រោយពេលប្រកាសនិងកំណត់អនុគមន៍រួចរាល់ហើយ យើងអាចហៅអនុគមន៍មកប្រើតាមរបៀបខាង ក្រោម៖            function_name(expression_1,….,expression_n);

ឧទាហរណ៍៖ max(3,5);

Advertisements
This entry was posted in MikroC for 8-bit PICMicro and tagged , , , , , , , , , , , . Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s