មេរៀនទី០១៖ អញ្ញតិ (Variables) ក្នុងភាសា C និងរបៀបប្រើប្រាស់

អញ្ញតិ (Variables) ក្នុងភាសា C៖ ការប្រកាស ការផ្ដល់តម្លៃ និងការប្រើប្រាស់

១. សេចក្ដីផ្ដើម

នៅក្នុងការសរសេរកម្មវិធី កម្មវិធីត្រូវការកន្លែងនៅក្នុងអង្គចងចាំ ដើម្បីរក្សាទុកទិន្នន័យផ្សេងៗ ដូចជា ឈ្មោះ អាយុ ពិន្ទុ តម្លៃទំនិញ ឬស្ថានភាពពិត និងមិនពិត។ កន្លែងផ្ទុកទិន្នន័យដែលមានឈ្មោះ និងត្រូវបានបង្កើតនៅក្នុងអង្គចងចាំនេះ ហៅថា អញ្ញតិ (Variable)។

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

យើងអាចប្រៀបធៀបអញ្ញតិទៅនឹងប្រអប់ផ្ទុកទិន្នន័យមួយ ដែលមានធាតុសំខាន់ៗដូចខាងក្រោម៖

• ប្រភេទទិន្នន័យ (Data Type)៖ កំណត់ប្រភេទទិន្នន័យដែលអញ្ញតិអាចផ្ទុកបាន។
• ឈ្មោះអញ្ញតិ (Variable Name)៖ ប្រើសម្រាប់សម្គាល់ និងយោងទៅកាន់ទិន្នន័យ។
• តម្លៃ (Value)៖ ទិន្នន័យដែលកំពុងផ្ទុកនៅក្នុងអញ្ញតិ។
• អាសយដ្ឋានអង្គចងចាំ (Memory Address)៖ ទីតាំងពិតប្រាកដរបស់អញ្ញតិនៅក្នុង RAM។

ឧទាហរណ៍

int score = 80;

បន្ទាត់កូដនេះអាចពន្យល់បានដូចខាងក្រោម៖

• int ជាប្រភេទទិន្នន័យចំនួនគត់។
• score ជាឈ្មោះអញ្ញតិ។
• 80 ជាតម្លៃដំបូង។
• = ជាប្រមាណវិធីផ្ដល់តម្លៃ (Assignment Operator) ដែលយកតម្លៃនៅខាងស្ដាំទៅផ្ដល់ឱ្យអញ្ញតិនៅខាងឆ្វេង។

ក្នុងភាសា C សញ្ញា = មិនមានន័យថា «ស្មើគ្នា» ដូចក្នុងគណិតវិទ្យាទេ។ ការប្រៀបធៀបថាតម្លៃពីរស្មើគ្នាឬអត់ ត្រូវប្រើ ==។

លំហូរនៃការប្រើអញ្ញតិ

ប្រកាស → កំណត់តម្លៃដំបូង → ប្រើប្រាស់ → ផ្លាស់ប្ដូរតម្លៃ

ឈ្មោះ និងប្រភេទរបស់អញ្ញតិនៅដដែល ប៉ុន្តែតម្លៃដែលផ្ទុកនៅក្នុងវាអាចផ្លាស់ប្ដូរបាន។

---

២. គោលបំណងសិក្សា

ក្រោយបញ្ចប់មេរៀននេះ អ្នកសិក្សាអាច៖

1. ពន្យល់អត្ថន័យ និងតួនាទីរបស់អញ្ញតិបានត្រឹមត្រូវ។
2. បែងចែករវាង Declaration, Initialization និង Assignment បាន។
3. ជ្រើសរើសប្រភេទទិន្នន័យមូលដ្ឋានឱ្យសមស្របនឹងតម្លៃ។
4. ដាក់ឈ្មោះអញ្ញតិតាមច្បាប់ និងអនុសាសន៍សរសេរកូដល្អ។
5. បញ្ចូល និងបង្ហាញតម្លៃដោយប្រើ scanf() និង printf()។
6. ធ្វើបច្ចុប្បន្នភាពតម្លៃដោយប្រើប្រមាណវិធីផ្សេងៗ។
7. សម្គាល់វិសាលភាព (Scope) និងអាយុកាល (Lifetime) របស់អញ្ញតិ។
8. រកឃើញ និងកែកំហុសដែលកើតពីការប្រើអញ្ញតិមិនត្រឹមត្រូវ។

---

៣. វាក្យសព្ទសំខាន់ៗ

ពាក្យបច្ចេកទេស	ពាក្យខ្មែរ	អត្ថន័យខ្លី
Variable	អញ្ញតិ (អថេរ)	ឈ្មោះតំណាងឱ្យទីតាំងផ្ទុកតម្លៃក្នុងអង្គចងចាំ ហើយតម្លៃអាចផ្លាស់ប្ដូរបាន
Data Type	ប្រភេទទិន្នន័យ	កំណត់ប្រភេទ ដែនតម្លៃ និងរបៀបបកស្រាយទិន្នន័យ
Declaration	ការប្រកាស	ប្រាប់ Compiler អំពីប្រភេទ និងឈ្មោះអញ្ញតិ
Initialization	ការកំណត់តម្លៃដំបូង	ផ្ដល់តម្លៃនៅពេលប្រកាសអញ្ញតិ
Assignment	ការផ្ដល់តម្លៃ	ផ្ដល់ ឬផ្លាស់ប្ដូរតម្លៃក្រោយការប្រកាស
Identifier	អត្តសញ្ញាណសម្គាល់	ឈ្មោះដែលអ្នកសរសេរកម្មវិធីកំណត់ឱ្យអញ្ញតិ អនុគមន៍ ឬធាតុផ្សេងៗ
Scope	វិសាលភាព	តំបន់កូដដែលអាចយោងទៅឈ្មោះអញ្ញតិបាន
Lifetime	អាយុកាល	រយៈពេលដែលអញ្ញតិមានវត្តមាននៅក្នុងអង្គចងចាំ

---

៤. រូបមន្តទូទៅនៃការប្រកាសអញ្ញតិ

រូបមន្តទូទៅ៖

data_type variable_name;

ឧទាហរណ៍៖

int age;
float price;
double distance;
char grade;

ការប្រកាសនេះប្រាប់ Compiler ឱ្យរៀបចំកន្លែងនៅក្នុងអង្គចងចាំតាមប្រភេទទិន្នន័យ និងភ្ជាប់ទីតាំងនោះជាមួយឈ្មោះអញ្ញតិ។

ទោះជាយ៉ាងណា អញ្ញតិមូលដ្ឋានដែលប្រកាសនៅក្នុងអនុគមន៍ដោយមិនកំណត់តម្លៃដំបូង អាចមានតម្លៃមិនកំណត់ (Indeterminate Value)។ ដូច្នេះ មិនគួរអានតម្លៃរបស់វាមុនពេលផ្ដល់តម្លៃឡើយ។

int age;           // ប្រកាស ប៉ុន្តែមិនទាន់កំណត់តម្លៃ
age = 20;          // ផ្ដល់តម្លៃក្រោយការប្រកាស

int score = 80;    // ប្រកាស និងកំណត់តម្លៃដំបូង

៤.១ ភាពខុសគ្នារវាង Declaration, Initialization និង Assignment

កូដ	សកម្មភាព	សេចក្ដីពន្យល់
int score;	Declaration	ប្រកាសអញ្ញតិឈ្មោះ score ប្រភេទ int
int score = 80;	Declaration + Initialization	ប្រកាស និងផ្ដល់តម្លៃដំបូង 80
score = 95;	Assignment	ផ្លាស់ប្ដូរតម្លៃរបស់ score ទៅជា 95

គន្លឹះសម្រាប់ការរៀន៖ គូរប្រអប់មួយ សរសេរ score ជាស្លាកនៅខាងក្រៅ និងសរសេរ 80 នៅខាងក្នុង។ បន្ទាប់មក ជំនួស 80 ដោយ 95 ដើម្បីយល់ថា ឈ្មោះអញ្ញតិនៅដដែល ប៉ុន្តែតម្លៃអាចផ្លាស់ប្ដូរ។

---

៥. ប្រភេទទិន្នន័យមូលដ្ឋាន

ប្រភេទ	ប្រើសម្រាប់	ឧទាហរណ៍	Format Specifier ទូទៅ
char	តួអក្សរមួយ	'A'	%c
int	ចំនួនគត់	25, -7	%d
unsigned int	ចំនួនគត់មិនអវិជ្ជមាន	120U	%u
float	ចំនួនទសភាគ	3.5f	%f
double	ចំនួនទសភាគដែលមានភាពជាក់លាក់ខ្ពស់	3.1415926	%lf ក្នុង scanf() និង %f ក្នុង printf()
_Bool ឬ bool	តម្លៃពិត ឬមិនពិត	true, false	ជាទូទៅបង្ហាញដោយ %d

សម្រាប់ C ស្តង់ដារមុន C23 ការប្រើ bool, true និង false ត្រូវបញ្ចូល៖

#include <stdbool.h>

bool is_active = true;

ទំហំរបស់ប្រភេទទិន្នន័យអាចខុសគ្នាតាម Compiler និងប្រព័ន្ធ។ គួរប្រើ sizeof ដើម្បីពិនិត្យ ជំនួសការសន្មត់។

#include <stdio.h>

int main(void) {
    printf("Size of char   : %zu byte(s)\n", sizeof(char));
    printf("Size of int    : %zu byte(s)\n", sizeof(int));
    printf("Size of float  : %zu byte(s)\n", sizeof(float));
    printf("Size of double : %zu byte(s)\n", sizeof(double));

    return 0;
}

---

៦. ច្បាប់ដាក់ឈ្មោះអញ្ញតិ

ឈ្មោះអញ្ញតិក្នុងភាសា C ត្រូវគោរពច្បាប់ខាងក្រោម៖

• អាចមានអក្សរ A–Z, a–z, លេខ 0–9 និងសញ្ញាគូសក្រោម _។
• តួអក្សរដំបូងត្រូវជាអក្សរ ឬ _។
• មិនអាចចាប់ផ្ដើមដោយលេខ។
• មិនអាចមានចន្លោះ ឬសញ្ញាពិសេសដូចជា -, @ និង #។
• មិនអាចប្រើពាក្យគន្លឹះរបស់ C ដូចជា int, return, if ឬ while។
• ភាសា C បែងចែកអក្សរធំ និងអក្សរតូច។ ដូច្នេះ score, Score និង SCORE ជាឈ្មោះបីផ្សេងគ្នា។

ឈ្មោះ	ត្រឹមត្រូវ?	មូលហេតុ
student_age	ត្រឹមត្រូវ	មានន័យច្បាស់ និងប្រើរចនាប័ទ្ម snake_case
totalPrice	ត្រឹមត្រូវ	ប្រើរចនាប័ទ្ម camelCase
2nd_score	មិនត្រឹមត្រូវ	ចាប់ផ្ដើមដោយលេខ
total-price	មិនត្រឹមត្រូវ	មានសញ្ញា -
float	មិនត្រឹមត្រូវ	ជាពាក្យគន្លឹះរបស់ C
x	ត្រឹមត្រូវ ប៉ុន្តែមិនសូវល្អ	ខ្វះអត្ថន័យ លើកលែងតែប្រើក្នុងបរិបទខ្លី

គួរប្រើឈ្មោះដែលបង្ហាញអត្ថន័យ ដូចជា៖

student_score
unit_price
total_amount
is_logged_in

ត្រូវជ្រើសរើសរចនាប័ទ្មដាក់ឈ្មោះមួយ និងប្រើឱ្យស្របគ្នាក្នុងគម្រោងទាំងមូល។

---

៧. ការប្រើអញ្ញតិជាជំហានៗ
៧.១ ប្រកាសអញ្ញតិ

int score;

Compiler ដឹងថា score ជាអញ្ញតិសម្រាប់ផ្ទុកចំនួនគត់។ ប៉ុន្តែវាមិនទាន់មានតម្លៃដែលអាចយកទៅប្រើដោយសុវត្ថិភាពទេ។

៧.២ កំណត់តម្លៃដំបូង

score = 80;

ឬប្រកាស និងកំណត់តម្លៃដំបូងក្នុងពេលតែមួយ៖

int score = 80;

៧.៣ ប្រើតម្លៃ

printf("Score: %d\n", score);

%d ជានិមិត្តសញ្ញាកំណត់ទម្រង់សម្រាប់បង្ហាញតម្លៃប្រភេទ int។ នៅពេលកម្មវិធីដំណើរការ តម្លៃរបស់ score នឹងត្រូវដាក់ជំនួស %d។

៧.៤ ផ្លាស់ប្ដូរតម្លៃ

score = 95;

តម្លៃ 80 ត្រូវបានជំនួសដោយ 95។ អញ្ញតិមួយរក្សាទុកតម្លៃបច្ចុប្បន្នមួយនៅពេលណាមួយ។

---

៨. ការបញ្ចូល និងបង្ហាញតម្លៃអញ្ញតិ

កម្មវិធីខាងក្រោមទទួលអាយុពីអ្នកប្រើ និងបង្ហាញតម្លៃត្រឡប់មកវិញ៖

#include <stdio.h>

int main(void) {
    int age = 0;

    printf("Enter your age: ");

    if (scanf("%d", &age) != 1) {
        printf("Invalid input.\n");
        return 1;
    }

    printf("Your age is %d years.\n", age);

    return 0;
}

ចំណុចដែលត្រូវយល់៖

• scanf("%d", &age) អានចំនួនគត់ពីក្តារចុច។
• &age ផ្ដល់អាសយដ្ឋានអង្គចងចាំរបស់ age ដើម្បីឱ្យ scanf() អាចសរសេរតម្លៃចូលបាន។
• តម្លៃត្រឡប់ពី scanf() ត្រូវបានពិនិត្យ ដើម្បីបញ្ជាក់ថាការបញ្ចូលជោគជ័យ។
• return 1; បង្ហាញថាកម្មវិធីបញ្ចប់ដោយមានបញ្ហា។
• return 0; បង្ហាញថាកម្មវិធីបញ្ចប់ដោយជោគជ័យ។

---

៩. វិធីធ្វើបច្ចុប្បន្នភាពតម្លៃ

សន្មតថាមាន៖

int count = 10;

យើងអាចកែតម្លៃរបស់ count បានច្រើនរបៀប៖

count = 20;       // ផ្ដល់តម្លៃថ្មី
count = count + 5;
count += 5;       // មានន័យដូច count = count + 5
count -= 2;
count *= 3;
count /= 2;
count++;          // បន្ថែម 1
count--;          // ដក 1

កូដខាងក្រោម៖

count = count + 5;

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

1. អានតម្លៃបច្ចុប្បន្នរបស់ count។
2. បូកតម្លៃនោះជាមួយ 5។
3. ផ្ដល់លទ្ធផលថ្មីត្រឡប់ទៅឱ្យ count។

នេះជាមូលហេតុដែល = ក្នុងភាសា C ជាប្រមាណវិធីផ្ដល់តម្លៃ មិនមែនជាសមីការគណិតវិទ្យា។

---

១០. ការប្រកាសអញ្ញតិច្រើន

ភាសា C អនុញ្ញាតឱ្យប្រកាសអញ្ញតិច្រើនដែលមានប្រភេទដូចគ្នាក្នុងបន្ទាត់តែមួយ៖

int width, height, area;

ទោះជាយ៉ាងណា ការប្រកាសមួយអញ្ញតិក្នុងមួយបន្ទាត់ជាញឹកញាប់មានភាពច្បាស់ និងងាយថែទាំជាង៖

int width = 0;
int height = 0;
int area = 0;

សូមពិនិត្យករណី Pointer ខាងក្រោម៖

int *first, second;

មានតែ first ប៉ុណ្ណោះដែលជា Pointer ខណៈ second ជា int ធម្មតា។ ដើម្បីជៀសវាងការយល់ច្រឡំ គួរប្រកាសដាច់ដោយឡែក៖

int *first;
int second;

---

១១. ថេរ និងអញ្ញតិ

អញ្ញតិធម្មតាអាចផ្លាស់ប្ដូរតម្លៃបាន៖

double price = 10.0;
price = 12.5;

បើតម្លៃមិនគួរត្រូវបានផ្លាស់ប្ដូរ ត្រូវប្រើ const៖

const double TAX_RATE = 0.10;

ក្រោយប្រកាសរួច កូដខាងក្រោមមិនត្រឹមត្រូវទេ៖

TAX_RATE = 0.15;  // Error: មិនអាចកែតម្លៃ const

តាមរចនាប័ទ្មសរសេរកូដ គេនិយមដាក់ឈ្មោះថេរជាអក្សរធំ និងបំបែកដោយ _៖

MAX_STUDENTS
TAX_RATE
PASS_SCORE

---

១២. វិសាលភាព និងអាយុកាលរបស់អញ្ញតិ

១២.១ អញ្ញតិមូលដ្ឋាន (Local Variable)

អញ្ញតិដែលប្រកាសនៅក្នុងអនុគមន៍ ឬ Block { } អាចប្រើបានតែក្នុងតំបន់នោះ។

#include <stdio.h>

int main(void) {
    int score = 80;

    if (score >= 50) {
        char grade = 'P';
        printf("Grade: %c\n", grade);
    }

    // grade មិនអាចប្រើនៅទីនេះបានទេ

    return 0;
}

អញ្ញតិ grade មានវិសាលភាពតែនៅក្នុង Block របស់ if ប៉ុណ្ណោះ។

១២.២ អញ្ញតិសកល (Global Variable)

អញ្ញតិដែលប្រកាសនៅក្រៅអនុគមន៍អាចត្រូវបានយោងដោយអនុគមន៍ជាច្រើនក្នុងឯកសារ។

int total_students = 0;

អញ្ញតិសកលមានប្រយោជន៍ក្នុងករណីចាំបាច់ ប៉ុន្តែការប្រើច្រើនពេកអាចធ្វើឱ្យកម្មវិធី៖

• ពិបាកតាមដាន;
• ពិបាកសាកល្បង;
• មានការពឹងផ្អែកគ្នាច្រើន;
• ពិបាកថែទាំ និងកែប្រែ។

ដូច្នេះ គួរផ្ដល់អាទិភាពដល់អញ្ញតិមូលដ្ឋាន និងបញ្ជូនទិន្នន័យតាម Parameter។

១២.៣ អញ្ញតិ Static

អញ្ញតិមូលដ្ឋានដែលមាន static រក្សាតម្លៃរបស់វារវាងការហៅអនុគមន៍ម្ដងៗ។

#include <stdio.h>

void show_call_count(void) {
    static int count = 0;

    count++;
    printf("Called %d time(s)\n", count);
}

int main(void) {
    show_call_count();
    show_call_count();
    show_call_count();

    return 0;
}

លទ្ធផល៖

Called 1 time(s)
Called 2 time(s)
Called 3 time(s)

count មានវិសាលភាពនៅក្នុងអនុគមន៍ show_call_count() ប៉ុន្តែមានអាយុកាលរហូតដល់កម្មវិធីបញ្ចប់។

---

១៣. ការបម្លែងប្រភេទទិន្នន័យ

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

int total = 5;
int students = 2;

double average = total / students;

លទ្ធផលរបស់ average គឺ 2.0 មិនមែន 2.5 ទេ ព្រោះ total / students ជាការចែករវាង int និង int។ ផ្នែកទសភាគត្រូវបានបោះចោលមុនពេលលទ្ធផលត្រូវបានបម្លែងទៅជា double។

កែតម្រូវដោយបម្លែង Operand យ៉ាងហោចណាស់មួយទៅជា double៖

double average = (double) total / students;

ឥឡូវលទ្ធផលគឺ 2.5។ នេះបង្ហាញថា ការជ្រើសរើសប្រភេទអញ្ញតិមានឥទ្ធិពលដោយផ្ទាល់លើការគណនា។

---

១៤. កម្មវិធីអនុវត្តពេញលេញ៖ គណនាលទ្ធផលនិស្សិត

#include <stdio.h>

int main(void) {
    const double PASS_SCORE = 50.0;

    int student_id = 0;
    double quiz = 0.0;
    double midterm = 0.0;
    double final_exam = 0.0;
    double total = 0.0;

    printf("Enter student ID: ");
    if (scanf("%d", &student_id) != 1) {
        printf("Invalid student ID.\n");
        return 1;
    }

    printf("Enter quiz score (20): ");
    if (scanf("%lf", &quiz) != 1) {
        printf("Invalid quiz score.\n");
        return 1;
    }

    printf("Enter midterm score (30): ");
    if (scanf("%lf", &midterm) != 1) {
        printf("Invalid midterm score.\n");
        return 1;
    }

    printf("Enter final exam score (50): ");
    if (scanf("%lf", &final_exam) != 1) {
        printf("Invalid final exam score.\n");
        return 1;
    }

    if (quiz < 0.0 || quiz > 20.0 ||
        midterm < 0.0 || midterm > 30.0 ||
        final_exam < 0.0 || final_exam > 50.0) {
        printf("Score is outside the allowed range.\n");
        return 1;
    }

    total = quiz + midterm + final_exam;

    printf("\n--- Student Result ---\n");
    printf("Student ID : %d\n", student_id);
    printf("Total      : %.2f / 100.00\n", total);
    printf("Result     : %s\n",
           total >= PASS_SCORE ? "PASS" : "FAIL");

    return 0;
}

១៤.១ វិភាគកម្មវិធី

• PASS_SCORE ជាថេរ ព្រោះពិន្ទុជាប់មិនគួរផ្លាស់ប្ដូរក្នុងពេលដំណើរការ។
• student_id ប្រើ int ព្រោះគំរូនេះទទួលលេខសម្គាល់ជាចំនួនគត់។
• ក្នុងប្រព័ន្ធពិត បើ ID អាចមានលេខសូន្យនៅខាងមុខ ឬមានអក្សរ គួររក្សាទុកជា String។
• ពិន្ទុប្រើ double ដើម្បីអនុញ្ញាតតម្លៃទសភាគ។
• total ត្រូវបានកំណត់តម្លៃដំបូង និងផ្លាស់ប្ដូរក្រោយទទួលពិន្ទុ។
• កម្មវិធីពិនិត្យទាំងប្រភេទ Input និងដែនពិន្ទុមុនយកទៅគណនា។
• %.2f បង្ហាញចំនួនទសភាគពីរខ្ទង់។
• ប្រមាណវិធីលក្ខខណ្ឌ ?: ត្រូវបានប្រើសម្រាប់ជ្រើសរើស "PASS" ឬ "FAIL"។

---

១៥. កំហុសដែលជួបញឹកញាប់ និងវិធីកែ
១៥.១ ប្រើអញ្ញតិមុនកំណត់តម្លៃ

មិនត្រឹមត្រូវ៖

int score;
printf("%d\n", score);

កែតម្រូវ៖

int score = 0;
printf("%d\n", score);

១៥.២ ភ្លេច & ក្នុង scanf()

មិនត្រឹមត្រូវ៖

int age = 0;
scanf("%d", age);

កែតម្រូវ៖

int age = 0;
scanf("%d", &age);

១៥.៣ Format Specifier មិនត្រូវនឹងប្រភេទ

មិនត្រឹមត្រូវ៖

double price = 12.5;
printf("%d\n", price);

កែតម្រូវ៖

double price = 12.5;
printf("%.2f\n", price);

១៥.៤ ប្រើ = ជំនួស == ក្នុងលក្ខខណ្ឌ

មិនត្រឹមត្រូវ៖

if (score = 100) {
    /* ... */
}

កូដនេះផ្ដល់តម្លៃ 100 ទៅឱ្យ score មិនមែនប្រៀបធៀបទេ។

កែតម្រូវ៖

if (score == 100) {
    /* ... */
}

១៥.៥ Integer Division

double result = 5 / 2;

លទ្ធផលគឺ 2.0 ព្រោះ 5 និង 2 ជា int។

កែតម្រូវ៖

double result = 5.0 / 2.0;

ឬ៖

double result = (double) 5 / 2;

១៥.៦ Overflow ឬតម្លៃលើសដែន

ប្រភេទទិន្នន័យនីមួយៗមានដែនតម្លៃកំណត់។ អាចប្រើ <limits.h> និង <float.h> ដើម្បីពិនិត្យដែនតម្លៃតាមប្រព័ន្ធ។

#include <limits.h>
#include <stdio.h>

int main(void) {
    printf("INT_MIN = %d\n", INT_MIN);
    printf("INT_MAX = %d\n", INT_MAX);

    return 0;
}

---

១៦. វិធី Compile និង Run

បើប្រើ GCC និងរក្សាទុកកូដជា variables.c៖

gcc -std=c17 -Wall -Wextra -Wpedantic variables.c -o variables

ដំណើរការលើ Windows៖

variables.exe

ដំណើរការលើ macOS ឬ Linux៖

./variables

ជម្រើស Compile ខាងក្រោមមានសារៈសំខាន់៖

• -Wall បើក Warning សំខាន់ៗជាច្រើន។
• -Wextra បើក Warning បន្ថែម។
• -Wpedantic ពិនិត្យការអនុលោមតាមស្តង់ដារ C ឱ្យតឹងរ៉ឹងជាងមុន។

អ្នកសិក្សាគួរអាន Warning និងកែឱ្យអស់ មិនគួរមើលរំលងឡើយ។

---

១៧. សកម្មភាពក្នុងថ្នាក់
១៧.១ សកម្មភាពទី១៖ ប្រអប់អង្គចងចាំ

គ្រូសរសេរកូដខាងក្រោមលើក្ដារ៖

int quantity = 5;

អ្នកសិក្សាគូរប្រអប់មួយ មានស្លាក quantity និងដាក់តម្លៃ 5 នៅខាងក្នុង។

បន្ទាប់មក គ្រូបង្ហាញ៖

quantity += 3;

អ្នកសិក្សាគណនា និងផ្លាស់ប្ដូរតម្លៃក្នុងប្រអប់ពី 5 ទៅជា 8។

១៧.២ សកម្មភាពទី២៖ ព្យាករណ៍លទ្ធផល

មុន Compile និង Run សូមឱ្យអ្នកសិក្សាព្យាករណ៍លទ្ធផលរបស់កូដ៖

int value = 10;

value += 5;
value *= 2;
value--;

printf("%d\n", value);

លទ្ធផល៖

29

ដំណើរការ៖

1. value = 10
2. value += 5 → 15
3. value *= 2 → 30
4. value-- → 29

១៧.៣ សកម្មភាពទី៣៖ Think–Pair–Share

• Think: ហេតុអ្វី double average = 5 / 2; មិនទទួលបាន 2.5?
• Pair: ពិភាក្សាជាមួយដៃគូ និងសរសេរកូដកែតម្រូវពីររបៀប។
• Share: បង្ហាញចម្លើយ និងពន្យល់ពី Type Conversion ដល់ថ្នាក់។

---

១៨. លំហាត់អនុវត្ត
១៨.១ កម្រិតទី១៖ ចងចាំ និងយល់ដឹង

1. ប្រកាសអញ្ញតិ age, height, grade និង is_registered ដោយជ្រើសរើសប្រភេទសមស្រប។
2. កំណត់តម្លៃដំបូងឱ្យអញ្ញតិទាំងបួន។
3. បង្ហាញតម្លៃទាំងអស់ដោយ printf() និង Format Specifier ត្រឹមត្រូវ។
4. ពន្យល់ភាពខុសគ្នារវាង Declaration, Initialization និង Assignment ដោយប្រើកូដមួយបន្ទាត់សម្រាប់គំនិតនីមួយៗ។

១៨.២ កម្រិតទី២៖ អនុវត្ត

1. សរសេរកម្មវិធីទទួលបណ្ដោយ និងទទឹង រួចគណនាផ្ទៃក្រឡាចតុកោណ។
2. សរសេរកម្មវិធីបម្លែងសីតុណ្ហភាពពី Celsius ទៅ Fahrenheit តាមរូបមន្ត៖

$$F=C\times \frac{9}{5}+32$$

ត្រូវប្រុងប្រយ័ត្នបញ្ហា Integer Division។

3. សរសេរកម្មវិធីទទួលតម្លៃទំនិញ និងចំនួនទិញ រួចគណនាតម្លៃសរុប។
4. បន្ថែមអត្រាពន្ធជាថេរ៖

const double TAX_RATE = 0.10;

បង្ហាញសរុបមុនពន្ធ ចំនួនពន្ធ និងសរុបក្រោយពន្ធ។

១៨.៣ កម្រិតទី៣៖ វិភាគ និងដោះស្រាយបញ្ហា

កែតម្រូវកូដខាងក្រោម និងពន្យល់កំហុសនីមួយៗ៖

#include <stdio.h>

int main(void) {
    int 2scores;
    float average;

    printf("Enter average: ");
    scanf("%d", average);

    if (average = 50) {
        printf("Pass\n");
    }

    return 0;
}

ចំណុចដែលត្រូវសម្គាល់៖

• 2scores ចាប់ផ្ដើមដោយលេខ។
• average មិនបានកំណត់តម្លៃដំបូង។
• %d មិនត្រូវនឹង float។
• scanf() ខ្វះ &average។
• = ត្រូវបានប្រើជំនួស ==។

លំហាត់បន្ថែម៖

• សរសេរកម្មវិធីប្ដូរតម្លៃរវាង a និង b ដោយប្រើអញ្ញតិបណ្ដោះអាសន្ន temp។
• គូរប្រអប់អង្គចងចាំបង្ហាញស្ថានភាពមុន និងក្រោយប្ដូរ។
• បង្កើតកម្មវិធីគណនាប្រាក់ខែសុទ្ធ ដោយមានប្រាក់ខែគោល ប្រាក់បន្ថែម អត្រាពន្ធ និងប្រាក់ខែសុទ្ធ។
• ពិនិត្យ Input មិនឱ្យមានតម្លៃអវិជ្ជមាន។
• សាកល្បង sizeof និងតម្លៃពី <limits.h> លើកុំព្យូទ័ររបស់អ្នក រួចរៀបចំជាតារាងលទ្ធផល។

---

១៩. សំណួរវាយតម្លៃខ្លួនឯង

1. តើអញ្ញតិមានតួនាទីអ្វីក្នុងកម្មវិធី?
2. តើ int score; ខុសពី int score = 0; ដូចម្ដេច?
3. ហេតុអ្វីមិនគួរអានអញ្ញតិមូលដ្ឋានមុនកំណត់តម្លៃ?
4. តើ = និង == មានតួនាទីខុសគ្នាដូចម្ដេច?
5. ហេតុអ្វី scanf() ត្រូវការ & នៅមុខអញ្ញតិចំនួនគត់?
6. តើ float និង double ខុសគ្នាដូចម្ដេច?
7. តើ Scope និង Lifetime ជាគំនិតដូចគ្នាឬទេ?
8. តើពេលណាគួរប្រើ const?
9. តើលទ្ធផល 5 / 2 ក្នុង C ជាអ្វី? ហេតុអ្វី?
10. តើការប្រើអញ្ញតិសកលច្រើនពេកអាចបង្កបញ្ហាអ្វីខ្លះ?

---

២០. ចម្លើយខ្លីសម្រាប់ត្រួតពិនិត្យ

1. អញ្ញតិជាឈ្មោះតំណាងឱ្យទីតាំងផ្ទុក និងគ្រប់គ្រងតម្លៃនៅក្នុងអង្គចងចាំ។
2. បន្ទាត់ទីមួយប្រកាសដោយមិនផ្ដល់តម្លៃដំបូង ខណៈបន្ទាត់ទីពីរប្រកាស និងកំណត់តម្លៃ 0។
3. ព្រោះតម្លៃអាចមិនកំណត់ ហើយការអានវាអាចបណ្ដាលឱ្យកម្មវិធីមានអាកប្បកិរិយាមិនអាចព្យាករណ៍បាន។
4. = ប្រើសម្រាប់ផ្ដល់តម្លៃ ខណៈ == ប្រើសម្រាប់ប្រៀបធៀបភាពស្មើគ្នា។
5. ដើម្បីផ្ដល់អាសយដ្ឋានទីតាំងដែល scanf() ត្រូវសរសេរតម្លៃចូល។
6. ជាទូទៅ double មានភាពជាក់លាក់ និងដែនតម្លៃធំជាង float។
7. មិនដូចគ្នាទេ។ Scope ជាតំបន់ដែលឈ្មោះអាចប្រើបាន ខណៈ Lifetime ជារយៈពេលដែលវត្ថុមានវត្តមាននៅក្នុងអង្គចងចាំ។
8. ប្រើ const នៅពេលតម្លៃមិនគួរផ្លាស់ប្ដូរក្រោយការកំណត់ដំបូង។
9. លទ្ធផលគឺ 2 ព្រោះ Operand ទាំងពីរជា int ហើយផ្នែកទសភាគត្រូវបានបោះចោល។
10. វាបង្កើនការពឹងផ្អែករវាងផ្នែកកូដ និងធ្វើឱ្យកម្មវិធីពិបាកតាមដាន សាកល្បង និងថែទាំ។

---

២១. សេចក្ដីសង្ខេប

អញ្ញតិជាគ្រឹះសំខាន់នៃការសរសេរកម្មវិធីភាសា C ព្រោះវាអនុញ្ញាតឱ្យកម្មវិធីរក្សាទុក អាន គណនា និងផ្លាស់ប្ដូរទិន្នន័យ។ ការប្រើអញ្ញតិឱ្យបានត្រឹមត្រូវ ត្រូវយល់ពីប្រភេទទិន្នន័យ ការប្រកាស ការកំណត់តម្លៃដំបូង ការផ្ដល់តម្លៃថ្មី វិសាលភាព និងអាយុកាល។

អ្នកសរសេរកម្មវិធីគួរ៖

• កំណត់តម្លៃដំបូងឱ្យអញ្ញតិ;
• ជ្រើសរើសប្រភេទទិន្នន័យឱ្យសមស្រប;
• ដាក់ឈ្មោះអញ្ញតិឱ្យមានអត្ថន័យ;
• ពិនិត្យ Input មុនយកទៅប្រើ;
• ប្រើ Format Specifier ឱ្យត្រូវនឹងប្រភេទ;
• អាន និងកែ Compiler Warning ជានិច្ច។

---

២២. តភ្ជាប់ទៅមេរៀនបន្ទាប់

ក្នុងមេរៀនទី២ យើងនឹងសិក្សាលម្អិតអំពី ប្រភេទទិន្នន័យ (Data Types) ដែនតម្លៃ Type Modifiers និង Type Conversion ក្នុងភាសា C។ ចំណេះដឹងនេះនឹងជួយឱ្យអ្នកសិក្សាអាចជ្រើសរើសប្រភេទទិន្នន័យបានត្រឹមត្រូវ ប្រើអង្គចងចាំមានប្រសិទ្ធភាព និងជៀសវាង Overflow ឬការបាត់បង់ភាពជាក់លាក់។

២២.១ កំណត់សម្គាល់សម្រាប់គ្រូបង្រៀន

• ចាប់ផ្ដើមពីឧទាហរណ៍ជីវិតពិត មុនបង្ហាញ Syntax។
• ប្រើគំនូរប្រអប់អង្គចងចាំ រាល់ពេលតម្លៃអញ្ញតិផ្លាស់ប្ដូរ។
• ឱ្យអ្នកសិក្សាព្យាករណ៍លទ្ធផលមុន Compile និង Run។
• ប្រើ Compiler Warning ជាឧបករណ៍បង្រៀន មិនមែនគ្រាន់តែជាសារកំហុស។
• វាយតម្លៃទាំងការសរសេរកូដ ការពន្យល់ហេតុផល និងសមត្ថភាព Debugging។