អរុណសួស្តីមិត្តជាទីស្រឡាញ់។ ជាមួយនឹងអត្ថបទនេះ ខ្ញុំចាប់ផ្តើមមេរៀនជាបន្តបន្ទាប់ដែលឧទ្ទិសដល់ភាសាសរសេរកម្មវិធីដ៏ពេញនិយមបំផុតមួយ - C++ ។ មេរៀនគឺផ្តោតជាចម្បងទៅលើអ្នកប្រើប្រាស់ដែលមិនស៊ាំនឹងការសរសេរកម្មវិធី ដូច្នេះអ្នកជំនាញសូមកុំតឹងរ៉ឹង ទោះបីខ្ញុំគាំទ្រការរិះគន់ជាពិសេសប្រឆាំងនឹងខ្លួនឯងក៏ដោយ។ នៅក្នុងមេរៀនរបស់ខ្ញុំ ខ្ញុំនឹងប្រើ Code::Blocks development environment ដែលអាចទាញយក និងប្រើប្រាស់ដោយឥតគិតថ្លៃ។ តោះចាប់ផ្តើមជាមួយ Hello, world =)

ខ្ញុំសង្ឃឹមថាអ្នកបានទាញយក និងដំឡើងរួចហើយ Code::Blocks បើអញ្ចឹង តោះចាប់ផ្តើម។ បើកដំណើរការបរិស្ថានអភិវឌ្ឍន៍

ជាដំបូង បង្កើតគម្រោងទទេថ្មី File->New->Project ហើយជ្រើសរើស Empty project

ចុច Go បន្ទាប់មក Next

ហើយនៅក្នុងបង្អួចដែលលេចឡើង ក្នុងវាលចំណងជើងគម្រោង វាយចំណងជើងនៃគម្រោង ក្នុងឈ្មោះឯកសារគម្រោង ឈ្មោះគម្រោង ហើយម្តងទៀតបន្ទាប់ទៀត។

នៅក្នុងបង្អួចបន្ទាប់ យក Objects dir ចេញពី បង្កើត "Debug" configuration ហើយបង្កើត "Release" configuration sections ដូចដែលបានបង្ហាញក្នុង screenshot ខាងលើ ហើយចុចប៊ូតុង Finish ។ គម្រោងមួយដែលមានឈ្មោះថា "ជំរាបសួរពិភពលោក" គួរតែលេចឡើងនៅខាងស្តាំ។

ជំហានបន្ទាប់គឺត្រូវបន្ថែមឯកសារ File->New->FIle... ទៅក្នុងគម្រោង ហើយជ្រើសរើសប្រភព c/c++ នៅក្នុងបង្អួចដែលលេចឡើង។

ទៅ, បន្ទាប់ម្តងទៀត, ជ្រើសរើស C ++, បន្ទាប់ ហើយឃើញបង្អួចខាងក្រោម

,

នៅទីនេះយើងត្រូវចង្អុលបង្ហាញឈ្មោះឯកសារ (ខ្ញុំបានហៅថាមេ) និងផ្លូវរបស់វា និយមថតជាមួយគម្រោង។ ធីកប្រអប់ បំបាត់កំហុស និងចេញផ្សាយ ហើយចុច បញ្ចប់។

ហើយយើងបានទទួលឯកសារ C ++ ទទេដែលយើងនឹងសរសេរកូដកម្មវិធីដោយខ្លួនឯង។

ឥឡូវនេះយើងចាប់ផ្តើមសរសេរកូដកម្មវិធីដោយខ្លួនឯង។ ដើម្បីបង្ហាញព័ត៌មាននៅលើអេក្រង់ យើងត្រូវការបណ្ណាល័យ iostream I/O ។

# រួមបញ្ចូល

ដោយប្រើ namespace std;

បន្ទាប់មកយើងនឹងសរសេរមុខងារចម្បងដែលនឹងត្រូវបានប្រតិបត្តិនៅពេលដែលកម្មវិធីចាប់ផ្តើម

int main()

វាត្រូវតែត្រូវបានគេហៅថា "មេ" ហើយយើងចង្អុលបង្ហាញប្រភេទរបស់វា int (យើងនឹងនិយាយអំពីវានៅក្នុងមេរៀនបន្ទាប់) ។ រវាងដង្កៀបអង្កាញ់ហើយនឹងជាកូដកម្មវិធី។ យើងនឹងសរសេរកម្មវិធីសាមញ្ញមួយ ដែលនឹងបង្ហាញការស្វាគមន៍ “ជំរាបសួរ ពិភពលោក!” នៅក្នុងកុងសូល។

cout<<"សួស្តី​ពិភពលោក!" ;

បន្ទាប់ពីពាក្យបញ្ជានីមួយៗ អ្នកត្រូវតែដាក់ ";" វាប្រាប់អ្នកចងក្រងថាពាក្យបញ្ជាត្រូវបានបញ្ចប់ ហើយពាក្យបញ្ជាបន្ទាប់អាចដំណើរការបាន។ cout - បោះពុម្ពតម្លៃអថេរ ឬខ្សែអក្សរទៅបន្ទាត់ពាក្យបញ្ជា។

បញ្ជីកម្មវិធីពេញលេញ។

# រួមបញ្ចូល

ដោយប្រើ namespace std;

សំខាន់ ()

cout<< "Hello, world!" ;

ត្រឡប់មកវិញ 0 ;

យើងចាប់ផ្តើមគម្រោងហើយឃើញលទ្ធផល។

ខាងក្រោមនេះខ្ញុំភ្ជាប់មេរៀនវីដេអូមួយទៅអត្ថបទនេះ។

ប្រសិនបើអ្នកមានចម្ងល់ផ្សេងៗ សូមសរសេរមតិយោបល់ទៅកាន់អាសយដ្ឋានអ៊ីមែលនេះ ដែលត្រូវបានការពារពីសំបុត្រឥតបានការ។ អ្នកត្រូវតែបើក JavaScript ដើម្បីមើលវា។ ,">អាសយដ្ឋាន​អ៊ីមែល​នេះ​ត្រូវ​បាន​ការពារ​ពី​សំបុត្រ​ឥត​ប្រយោជន៍។ អ្នកត្រូវតែបើក JavaScript ដើម្បីមើលវា។ខ្ញុំនឹងកែលម្អមេរៀន ឬគ្រាន់តែជួយក្នុងការសិក្សាសម្ភារៈ។

• < Назад

កូដ::Blocks គឺជាបរិស្ថានអភិវឌ្ឍន៍ឆ្លងវេទិកាឥតគិតថ្លៃ។ Code::Blocks ត្រូវបានសរសេរក្នុង C++ ហើយប្រើបណ្ណាល័យ wxWidgets។ មានស្ថាបត្យកម្មបើកចំហ វាអាចត្រូវបានធ្វើមាត្រដ្ឋានតាមរយៈកម្មវិធីជំនួយ។ គាំទ្រភាសាសរសេរកម្មវិធី C, C ++, D (ជាមួយដែនកំណត់) ។
កូដ::Blocks ត្រូវបានបង្កើតឡើងសម្រាប់ Windows, Linux និង Mac OS X។ បរិស្ថានអាចត្រូវបានចងក្រងពីកូដប្រភពសម្រាប់ប្រព័ន្ធស្ទើរតែទាំងអស់ដែលស្រដៀងនឹងយូនីក។ [ http://ru.wikipedia.org/wiki/Code::Blocks ]

ដើម្បីបើកភាសារុស្សី អ្នកត្រូវធ្វើដូចខាងក្រោម៖

1. បណ្ណសារត្រូវតែខ្ចប់ទៅក្នុងថតរងកម្មវិធី (កន្លែងដែលវាត្រូវបានដំឡើង) ឧទាហរណ៍ C:\Program Files (x86)\CodeBlocks\share\CodeBlocks
2. បន្ទាប់ពីចាប់ផ្តើមកម្មវិធី សូមជ្រើសរើស Settings -> Environment -> View ធីកប្រអប់ “Internationalization” ហើយជ្រើសរើស “Russian” ពីបញ្ជី។

3. ចាប់ផ្តើមកម្មវិធី CodeBlocks ឡើងវិញ ហើយទទួលបាន Russification ។

ភាសារុស្សីត្រូវបានភ្ជាប់ដោយជោគជ័យទៅកាន់ Code::Blocks version 13.12។

បណ្ណសារមានរចនាសម្ព័ន្ធថតឯកសារ locale\ru_RU រួចហើយ (ត្រូវដាក់ក្នុង \CodeBlocks\share\CodeBlocks)

ស្ថានភាពបកប្រែ៖
សារ៖ ២១៧៣
បកប្រែ៖ 2173 (100.0%)
មិនបានបកប្រែ៖ 0 (0.0%)
ចែករំលែករវាងអ៊ូប៊ុនទូ និងខាងលើ៖ 2173 (100.0%)
បកប្រែ​ខុស​គ្នា​រវាង​អ៊ូប៊ុនទូ និង​ខាង​លើ៖ 0 (0.0%)
បកប្រែតែខាងនេះប៉ុណ្ណោះ៖ 0 (0.0%)

បរិស្ថានអភិវឌ្ឍន៍រួមបញ្ចូលគ្នា (IDE) កូដ៖:ប្លុក (ហៅកាត់ថា CB) គឺជាផលិតផលពេញលេញសម្រាប់បង្កើតកម្មវិធីនៅក្នុងភាសា C/C++។ CB គឺជាក្របខ័ណ្ឌឆ្លងវេទិកាដែលត្រូវបានបង្កើតឡើងដោយប្រើបណ្ណាល័យឧបករណ៍ wxWidgets ។ មានកំណែបរិស្ថានសម្រាប់ទាំង Windows និងប្រព័ន្ធប្រតិបត្តិការផ្សេងទៀត (OS) - Linux និង Mac OS ។ IDE នេះគឺឥតគិតថ្លៃទាំងស្រុង ប្រភពបើកចំហ និងបង្កើតឡើងទាំងស្រុងដោយប្រើបច្ចេកវិទ្យាប្រភពបើកចំហ។ ចំណុចខ្លាំងបំផុតមួយរបស់ CB គឺការគាំទ្ររបស់វាសម្រាប់ការបង្កើតកម្មវិធី wxWidgets ពោលគឺកម្មវិធីដែលប្រើ OS API ដើម្បីបង្ហាញចំណុចប្រទាក់អ្នកប្រើក្រាហ្វិក (GUI) ។ ម្យ៉ាងវិញទៀត CB អនុញ្ញាតឱ្យអ្នកបង្កើតកម្មវិធីឆ្លងវេទិកាសម្រាប់គ្រប់រសជាតិ។

CB អាចធ្វើការជាមួយអ្នកចងក្រងមួយចំនួនធំ។ ប្រសិនបើមានពួកវាជាច្រើនដែលបានដំឡើងនៅក្នុងប្រព័ន្ធ អ្នកអាចប្តូររវាងពួកវាបានយ៉ាងងាយស្រួល អាស្រ័យលើតម្រូវការរបស់អ្នក។ លើសពីនេះ នៅដំណាក់កាលដំឡើង IDE ខ្លួនវានឹងស្កេនប្រព័ន្ធសម្រាប់កម្មវិធីចងក្រងដែលមាន ហើយផ្តល់ជូនដើម្បីប្រើមួយជាប្រព័ន្ធសំខាន់។ វាអាចទៅរួចក្នុងការផ្លាស់ប្តូរការកំណត់ទាំងនេះនៅពេលក្រោយ ទាំងជាសកល និងបុគ្គលសម្រាប់គម្រោង។ សម្រាប់ការកំណត់បរិស្ថានសកល មានផ្នែក "ការកំណត់" ទាំងមូលនៅក្នុងម៉ឺនុយមេ CB ។ ដើម្បីធ្វើការកំណត់ជាក់លាក់ណាមួយចំពោះគម្រោងជាក់លាក់មួយ អ្នកត្រូវបើកបង្អួចលក្ខណសម្បត្តិគម្រោង។ ដើម្បីធ្វើដូចនេះអ្នកត្រូវហៅម៉ឺនុយបរិបទរបស់គម្រោងដោយចុចខាងស្តាំលើវាហើយជ្រើសរើស "លក្ខណសម្បត្តិ" ។ គម្រោងដោយខ្លួនឯង (បច្ចុប្បន្នបើកនៅក្នុង IDE) ត្រូវបានបង្ហាញជាមែកធាងនៅក្នុងបន្ទះចត "ការគ្រប់គ្រង" នៅក្នុងផ្ទាំង "គម្រោង" របស់វា។ ឥឡូវនេះ នៅក្នុងបង្អួចលក្ខណសម្បត្តិដែលបើក អ្នកអាចកំណត់រចនាសម្ព័ន្ធប៉ារ៉ាម៉ែត្រជាច្រើន ចាប់ពីការកែសម្រួលគោលដៅសាងសង់ រហូតដល់ការភ្ជាប់បណ្ណាល័យភាគីទីបី។ ប៊ូតុង "ជម្រើសសាងសង់របស់គម្រោង" នៅលើផ្ទាំង "ការកំណត់គម្រោង" នៃបង្អួចលក្ខណសម្បត្តិដូចគ្នា អនុញ្ញាតឱ្យអ្នកកំណត់រចនាសម្ព័ន្ធការស្ថាបនាបានយ៉ាងបត់បែនសម្រាប់គម្រោងជាក់លាក់មួយ៖ គ្រាប់ចុចចងក្រង ជ្រើសរើសអ្នកចងក្រងដោយខ្លួនឯង ភ្ជាប់បណ្ណាល័យសម្រាប់ឧបករណ៍ភ្ជាប់។ល។ នេះអាចត្រូវបានធ្វើសម្រាប់របៀបបុគ្គល៖ "ចេញផ្សាយ" "បំបាត់កំហុស" ។

CB GUI ត្រូវបានបង្កើតឡើងជុំវិញបន្ទះចតដែលអណ្តែត និងអាចលាតសន្ធឹងបាន ដែលអាចចតទៅផ្នែកណាមួយនៃបង្អួច IDE ចម្បងដោយគ្រាន់តែអូសពួកវាដោយប្រើកណ្ដុរ។ សូមអរគុណចំពោះបញ្ហានេះ អ្នកអាចកំណត់រចនាសម្ព័ន្ធប្លង់ចំណុចប្រទាក់ផ្សេងៗគ្នាយ៉ាងបត់បែនសម្រាប់ទំហំអេក្រង់ផ្សេងៗគ្នា បង្កើនប្រសិទ្ធភាព ergonomics នៃ GUI ។ ប្រសិនបើមានម៉ូនីទ័រជាច្រើន វាងាយស្រួលក្នុងការបំបែកបន្ទះមួយចំនួនចេញពីបង្អួចមេ ហើយដាក់វានៅលើម៉ូនីទ័រដែលនៅជាប់គ្នា។

ការបន្លិច ការបំពេញកូដ និងឧបករណ៍កែសម្រួលនៅក្នុង CB ធ្វើឱ្យដំណើរការនៃការធ្វើការជាមួយកូដមានភាពងាយស្រួល និងផាសុកភាព។ ឃ្លាំងអាវុធដ៏ធំនៃការកំណត់អនុញ្ញាតឱ្យអ្នកកែសម្រួលបរិយាកាស "សម្រាប់ខ្លួនអ្នក" យ៉ាងល្អិតល្អន់។ វាមានប្រយោជន៍ណាស់ក្នុងការមានការគាំទ្រសម្រាប់ធ្វើការជាមួយអថេរបរិស្ថាន។ សូមអរគុណចំពោះលក្ខណៈពិសេសនេះ CB អាចត្រូវបានដាក់បញ្ចូលយ៉ាងជិតស្និទ្ធទៅក្នុងប្រព័ន្ធ ហើយសមត្ថភាពរបស់វាអាចត្រូវបានពង្រីក ឧទាហរណ៍ វិធីនេះអ្នកអាចភ្ជាប់បណ្ណាល័យ wxWidgets ។

ដោយវិធីនេះ ដើម្បីបង្កើតកម្មវិធី GUI ដោយផ្អែកលើ wxWidgets CB មានឧបករណ៍ RAD ដែលភ្ជាប់មកជាមួយសម្រាប់ការរចនា GUI - wxSmith ។ នេះ​ជា​ឧបករណ៍​ប្រើប្រាស់​ដ៏​មាន​ឥទ្ធិពល​មួយ ទោះបី​មិន​ងាយស្រួល​រៀន​ទាំងស្រុង​ក៏ដោយ។

កូដ::Blocks គឺជាបរិស្ថានអភិវឌ្ឍន៍រួមបញ្ចូលគ្នា (IDE) ឥតគិតថ្លៃ និងប្រភពបើកចំហដែលគាំទ្រការប្រើប្រាស់កម្មវិធីចងក្រងផ្សេងៗ។ តាមលំនាំដើម កូដ::Blocks ប្រើកម្មវិធីចងក្រង MinGW ដែលត្រូវបានរួមបញ្ចូលក្នុងកញ្ចប់ (អ្នកអាចទាញយកការចែកចាយដោយគ្មានឧបករណ៍ចងក្រងដែលភ្ជាប់មកជាមួយ)។ MinGW គឺជាវ៉ារ្យ៉ង់នៃកម្មវិធីចងក្រង GNU C/C ++ សម្រាប់ Windows ។ MinGW គឺខ្លីសម្រាប់ "Minimalist GNU for Windows" ។ ឈុត MinGW រួមបញ្ចូលឧបករណ៍សរសេរកម្មវិធីប្រភពបើកចំហដែលមិនពឹងផ្អែកលើបណ្ណាល័យភាគីទីបីដែលបង់ប្រាក់ណាមួយឡើយ។ វា​ត្រូវ​បាន​ប្រើ​ដោយ​បរិស្ថាន​អភិវឌ្ឍន៍​ជា​ច្រើន (Visual Studio ប្រើ​កម្មវិធី​ចងក្រង​ផ្ទាល់​ខ្លួន)។ MinGW រួមមាន GNU Compiler Collection (GCC) រួមទាំង C, C++, ADA និង Fortran compilers ។ Code::Blocks មានស្ថាបត្យកម្មបើកចំហ ដែលអនុញ្ញាតឱ្យវាធ្វើមាត្រដ្ឋានដោយប្រើកម្មវិធីជំនួយ (អ្នកអាចសរសេរកម្មវិធីសម្រាប់ Windows, Linux និង microprocessors ផ្សេងៗដូចជា avr និង stm32)។ កម្មវិធីបំបាត់កំហុសកូដនៅក្នុង Code::Blocks គាំទ្រចំណុចឈប់នៅក្នុងកូដប្រភព ឬនៅក្នុងទិន្នន័យដែលកម្មវិធីដំណើរការ។

កូដ៖:Blocks មានសម្រាប់ Windows, Linux និង Mac OS X។ គេហទំព័រគម្រោងគឺ codeblocks.org។

ការដំឡើងកម្មវិធីចងក្រង MinGW

ការដំឡើងកូដ:: ប្លុកដោយខ្លួនឯងមិនពិបាកទេ។ វាត្រូវបានណែនាំឱ្យដំឡើងវានៅក្នុងថតដែលមិនមានចន្លោះ ឬតួអក្សរ Cyrillic នៅក្នុងផ្លូវ។ សូមក្រឡេកមើលការដំឡើងកម្មវិធីចងក្រង MinGW ។ តាមក្បួនកូដ::ការចែកចាយប្លុកមានកំណែចាស់នៃកម្មវិធីចងក្រង MinGW ដូច្នេះវាត្រូវបានណែនាំឱ្យទាញយក Code::Blocks ដោយគ្មានកម្មវិធីចងក្រង MinGW ហើយដំឡើងកម្មវិធីចងក្រងដោយឡែកពីគ្នា។ ដំបូង ទាញយកកម្មវិធីដំឡើងពីគេហទំព័រគម្រោង mingw.org ។ បន្ទាប់ពីបើកដំណើរការ បង្អួចខាងក្រោមនឹងលេចឡើង។

ចុច ដំឡើងហើយយើងទទួលបានបង្អួចខាងក្រោម។

នៅទីនេះនៅក្នុងវាល បញ្ជីដំឡើងចង្អុលបង្ហាញទីតាំងនៃឯកសារចងក្រង។ លំនាំដើមគឺ C:\MinGWយើងទុកវាចោល។ ចុច បន្តហើយការទាញយក និងដំឡើងកម្មវិធីគ្រប់គ្រងសម្រាប់ការដំឡើង MinGW ចាប់ផ្តើម។

ចុច បន្តហើយយើងទទួលបានបង្អួចខាងក្រោម។

សម្រាប់ការសរសេរកម្មវិធីនៅក្នុង C++ សូមជ្រើសរើសកញ្ចប់ដែលត្រូវដំឡើង mingw32-base-bin (ការដំឡើងមូលដ្ឋាន MinGW)និង mingw32-gcc-g++-bin (កម្មវិធីចងក្រង GNU C++)ហើយបន្ទាប់មកចុចលើម៉ឺនុយ ការដំឡើង -> អនុវត្តការផ្លាស់ប្តូរ. បង្អួចមួយនឹងលេចឡើងដែលបង្ហាញពីការទាញយកកញ្ចប់ដែលបានជ្រើសរើស។

នៅពេលដែលកញ្ចប់ត្រូវបានទាញយកសូមចុចលើប៊ូតុង បិទ

ជាលើកដំបូងដែលអ្នកដំណើរការ Code::Blocks វានឹងរកឃើញកម្មវិធីចងក្រងដែលបានដំឡើងដោយស្វ័យប្រវត្តិ។ ប្រសិនបើបញ្ហាកើតឡើងអ្នកត្រូវចូលទៅកាន់ម៉ឺនុយ ការកំណត់ -> កម្មវិធីចងក្រង...និងនៅលើផ្ទាំង ឧបករណ៍ដែលអាចប្រតិបត្តិបាន។ពិនិត្យភាពត្រឹមត្រូវនៃផ្លូវទៅកាន់ MinGW ក៏ដូចជាឈ្មោះឯកសារចងក្រង និងឯកសារភ្ជាប់។ ឥឡូវនេះអ្នកអាចបង្កើតគម្រោងមួយ។

ការបង្កើតគម្រោង

ដើម្បីបង្កើតគម្រោងអ្នកត្រូវចូលទៅកាន់ម៉ឺនុយ ឯកសារ -> ថ្មី -> គម្រោង...

នៅក្នុងបង្អួចដែលលេចឡើងសូមជ្រើសរើសប្រភេទគម្រោងដែលត្រូវការ។ នៅទីនេះយើងឃើញថា Code::Blocks មានគំរូគម្រោងមួយចំនួនធំ។ ក្នុងករណីរបស់យើងវាគឺ កម្មវិធីកុងសូល។(កម្មវិធីកុងសូល) ។

នៅក្នុងបង្អួចបន្ទាប់ សូមជ្រើសរើសភាសាសរសេរកម្មវិធីដែលត្រូវប្រើ។ ជ្រើសរើស C ++ ហើយចុចលើប៊ូតុង បន្ទាប់.

បន្ទាប់នៅក្នុងវាល ចំណងជើងគម្រោងបញ្ចូលឈ្មោះគម្រោង។ ក្នុងករណីរបស់យើងវាគឺ សាកល្បង. យើងចង្អុលបង្ហាញភ្លាមៗនូវទីតាំងនៃគម្រោងនៅលើថាស (វាល ថតឯកសារដើម្បីបង្កើតគម្រោង) នៅក្នុងថតដែលយើងបានបញ្ជាក់ Codeblcoks នឹងបង្កើតថតដោយស្វ័យប្រវត្តិជាមួយនឹងឈ្មោះគម្រោងដែលបានបញ្ជាក់ពីមុន។ បន្ទាប់ពីបញ្ជាក់ឈ្មោះថត និងឈ្មោះឯកសារ សូមចុចលើប៊ូតុង បន្ទាប់.

នៅក្នុងបង្អួចបន្ទាប់ជ្រើសកម្មវិធីចងក្រង។ តាមលំនាំដើម GNU GCC Compiler ត្រូវបានជ្រើសរើស ដែលជាអ្វីដែលយើងនឹងប្រើ។

ចុច បញ្ចប់ហើយយើងទទួលបានកម្មវិធីតិចតួចបំផុត ដែលហៅថា Hello World!

ចុច F9 ដើម្បីចងក្រង និងដំណើរការកម្មវិធី ហើយទទួលបានបង្អួចខាងក្រោម។

ការគាំទ្រ Cyrillic នៅក្នុងកុងសូល។

កូដគម្រោងស្តង់ដារដែលបង្កើតដោយ Code::Blocks environment មិនគាំទ្រការបញ្ចូល និងលទ្ធផលនៃតួអក្សរ Cyrillic នៅក្នុងកុងសូល។ ដើម្បីដោះស្រាយបញ្ហានេះ ដំបូងអ្នកត្រូវតែធ្វើការផ្លាស់ប្តូរបន្តិចបន្តួចចំពោះកូដគម្រោង។ ឧទាហរណ៍កូដប្រភពត្រូវបានបង្ហាញខាងក្រោម។

ប្រភព

# រួមបញ្ចូល # រួមបញ្ចូល ដោយប្រើ namespace std; int main() ( SetConsoleCP(1251); // កំណត់កូដ win-cp ទំព័រ 1251 ទៅស្ទ្រីមបញ្ចូល SetConsoleOutputCP(1251); // ការកំណត់ win-cp code ទំព័រ 1251 ទៅកាន់ output stream cout

បន្ទាប់មកអ្នកត្រូវដំណើរការកម្មវិធី ចុចកណ្ដុរឆ្វេងលើចំណងជើងបង្អួច (ដែលផ្លូវទៅកាន់ឯកសារ .exe ដែលកំពុងដំណើរការត្រូវបានបង្ហាញ) ហើយជ្រើសរើសធាតុនៅក្នុងម៉ឺនុយបរិបទ ទ្រព្យសម្បត្តិ. បន្ទាប់មកនៅលើផ្ទាំង ពុម្ពអក្សរដំឡើងពុម្ពអក្សរ កុងសូល Lucidaហើយជ្រើសរើសទំហំពុម្ពអក្សរដែលងាយស្រួល។ បន្ទាប់ពីនេះ សារនៅក្នុងកម្មវិធីកុងសូលនឹងគាំទ្រតួអក្សរ Cyrillic ។

កំណែបឋម (មិនទាន់ចប់)

1 ការដំឡើង និងការកំណត់រចនាសម្ព័ន្ធបរិស្ថានអភិវឌ្ឍន៍

1.1 ព័ត៌មានទូទៅ

ដំបូង​អ្នក​ត្រូវ​ដំឡើង​បរិស្ថាន​អភិវឌ្ឍន៍ ដែល​នឹង​ក្លាយ​ជា​បរិស្ថាន​កម្មវិធី​ដែល​រួម​បញ្ចូល​គ្នា Code::Blocks។ អត្ថប្រយោជន៍ចម្បងនៃកូដ::ប្លុករួមមាន:

• អាជ្ញាប័ណ្ណឥតគិតថ្លៃ GPL v3.0 ជាពិសេសការចែកចាយ និងការប្រើប្រាស់ដោយឥតគិតថ្លៃត្រូវបានអនុញ្ញាត។
• បរិស្ថានអាចដំណើរការលើប្រព័ន្ធប្រតិបត្តិការរបស់គ្រួសារ Windows, Linux, OS X (នោះគឺវាឆ្លងវេទិកា);
• សមត្ថភាពក្នុងការធ្វើការជាមួយអ្នកចងក្រងផ្សេងៗ។

ឯកសារនេះដំឡើងទាំង Code::Blocks environment និង MinGW ដែលផ្តល់នូវគ្រួសារ GCC នៃអ្នកចងក្រង។ បរិស្ថាន MinGW ក៏ជាកម្មវិធីឥតគិតថ្លៃផងដែរ។

1.2.1.2 ដំណើរការដំឡើង

អ្នកត្រូវដំណើរការឯកសារ codeblocks-10.05mingw-setup.exe ។ បង្អួចកម្មវិធីដំឡើងនឹងលេចឡើង។

អ្នកត្រូវចុច "បន្ទាប់" ។ បង្អួចនឹងបង្ហាញជាមួយអត្ថបទនៃអាជ្ញាប័ណ្ណឥតគិតថ្លៃ GPL v3.0 ។

ការចុចប៊ូតុង "ខ្ញុំយល់ព្រម" មានន័យថាអ្នកយល់ព្រមនឹងលក្ខខណ្ឌអាជ្ញាប័ណ្ណ និងអនុញ្ញាតឱ្យអ្នកបន្តដំឡើងកម្មវិធី ក្នុងអំឡុងពេលនោះបង្អួចជ្រើសរើសសមាសភាគនឹងលេចឡើង។ នៅក្នុងបង្អួចនេះអ្នកត្រូវជ្រើសរើសប្រភេទដំឡើង "ពេញ: កម្មវិធីជំនួយទាំងអស់ ឧបករណ៍ទាំងអស់ អ្វីគ្រប់យ៉ាង" ។

បន្ទាប់ពីនេះអ្នកត្រូវចុចប៊ូតុង "បន្ទាប់" ។ បង្អួចនឹងបង្ហាញជាមួយឈ្មោះនៃថតដំឡើង។ វាប្រសើរជាងដែលឈ្មោះពេញថតមិនមានចន្លោះ ឬអក្សរផ្សេងក្រៅពីឡាតាំង។ដូច្នេះ ជាឧទាហរណ៍ វាជាការប្រសើរក្នុងការជំនួសឈ្មោះ C:\Program Files\CodeBlocks ជាមួយអ្វីផ្សេងទៀត ឧទាហរណ៍ C:\CodeBlocks ឬ C:\Programs\CodeBlocks ។

បន្ទាប់ពីនេះអ្នកអាចចុចប៊ូតុង "ដំឡើង" ដែលចាប់ផ្តើមដំណើរការដំឡើងដោយខ្លួនឯង។

នៅចុងបញ្ចប់នៃដំណើរការ បង្អួចនឹងលេចឡើងដែលស្នើឱ្យអ្នកបើកដំណើរការ Code::Blocks ។ វាជាការប្រសើរក្នុងការចុច "ទេ" នៅទីនេះ ហើយបន្ទាប់មកពិនិត្យមើលកូដនោះ:: ប្លុកចាប់ផ្តើមតាមរបៀបធម្មតា។

បន្ទាប់ពីនេះគ្រាន់តែចុចប៊ូតុង "បន្ទាប់" ហើយបន្ទាប់មក "បញ្ចប់" ដើម្បីបញ្ចប់ដំណើរការដំឡើង។

1.2.1.3 ការចាប់ផ្តើមដំបូង

ផ្លូវកាត់ដើម្បីបើកដំណើរការ Code::Blocks គួរតែបង្ហាញនៅក្នុងរបារឧបករណ៍ Quick Launch។ ផងដែរ ផ្លូវកាត់ស្រដៀងគ្នាគួរតែលេចឡើងនៅលើផ្ទៃតុ។

កូដ::ប្លុកអាចត្រូវបានបើកដំណើរការដោយប្រើផ្លូវកាត់ទាំងនេះ ក៏ដូចជាការប្រើម៉ឺនុយកម្មវិធីប្រព័ន្ធស្តង់ដារ។

នៅ ដំបូងនៅពេលអ្នកចាប់ផ្តើម Code::Blocks បង្អួចគួរតែលេចឡើងដើម្បីស្វែងរកកម្មវិធីចងក្រងដោយស្វ័យប្រវត្តិ។

ចំណាំថាបន្ទាត់ទីមួយគួរតែមានពាក្យ "បានរកឃើញ" ។ នេះមានន័យថាអ្នកចងក្រងត្រូវបានរកឃើញ។ អ្នកត្រូវតែចុច "យល់ព្រម" ។ ដំណើរការដំណើរការដំបូងនឹងបន្ត ហើយបរិយាកាសអភិវឌ្ឍន៍នឹងត្រូវចាប់ផ្តើម។ បង្អួចដែលមានព័ត៌មានជំនួយនៃថ្ងៃនឹងលេចឡើង។

ប្រសិនបើអ្នកមិនចង់ឱ្យបង្អួចនេះលេចឡើងរាល់ពេលដែលអ្នកចាប់ផ្តើម Code::Blocks បន្ទាប់មកដោះធីកប្រអប់ធីក "Show tips at startup in this window"។ ចុច "បិទ" ដើម្បីបិទបង្អួចនេះ។

បន្ទាប់ពីនេះ បង្អួចខាងក្រោមអាចលេចឡើង។

នៅទីនេះវាជាការប្រសើរក្នុងការចុច "យល់ព្រម" ដូច្នេះឯកសារដែលទាក់ទង C/C++ ត្រូវបានភ្ជាប់ជាមួយ Code::Blocks ។

អ្នកក៏អាចបិទបង្អួច "កុងសូលស្គ្រីប" ផងដែរ។

1.2.2 ការដំឡើងសម្រាប់ប្រព័ន្ធប្រតិបត្តិការលីនុច

ក្នុងករណី Linux អ្នកអាចដំឡើង Code::Blocks ដោយប្រើកញ្ចប់សម្រាប់ការចែកចាយដែលអ្នកចង់បានពីអ្នកដែលបានរាយក្នុងទំព័រនេះ។

អ្នកក៏អាចសាកល្បងស្វែងរក Code::Blocks នៅក្នុងឃ្លាំងនៃការចែកចាយ Linux របស់អ្នក។ ឧទាហរណ៍ Code::Blocks package (10.05-1) មាននៅក្នុងឃ្លាំង Ubuntu 11.04។

1.3 ការដំឡើង

ដើម្បីចាប់ផ្តើម អ្នកអាចចែកចាយរបារឧបករណ៍កាន់តែបង្រួមនៅផ្នែកខាងលើនៃបង្អួច។

បន្ទាប់ពីនេះអ្នកត្រូវធ្វើការផ្លាស់ប្តូរមួយចំនួនចំពោះការកំណត់មូលដ្ឋាន។

ជ្រើសរើសម៉ឺនុយ "Settings=>Compiler and Debugger..." ។ បង្អួចការកំណត់នឹងលេចឡើង។

នៅក្នុងបង្អួចនេះអ្នកត្រូវការ ដាក់ធីកប្រអប់សម្រាប់ "ផលិតនិមិត្តសញ្ញាបំបាត់កំហុស" ។ ការផ្លាស់ប្តូរនេះនឹងអនុញ្ញាតឱ្យអ្នកអនុវត្តរបៀបបំបាត់កំហុស ដែលនឹងត្រូវបានពិភាក្សានៅក្នុងការបង្រៀននៅពេលក្រោយ។

ដោយមិនចាំបាច់បិទបង្អួចនេះទេ អ្នកត្រូវចុចលើផ្ទាំង "ជម្រើសផ្សេងទៀត"។

ហើយនៅក្នុងវាលកែសម្រួលអ្នកត្រូវបន្ថែមបន្ទាត់ខាងក្រោម។

Finput-charset=CP1251 -fexec-charset=CP866

នេះនឹងអនុញ្ញាតឱ្យអក្ខរក្រម Cyrillic ត្រូវបានបង្ហាញយ៉ាងត្រឹមត្រូវនៅក្នុងកុងសូលក្នុងករណីប្រព័ន្ធប្រតិបត្តិការវីនដូ។ នៅពេលប្រើ Code::Blocks នៅលើប្រព័ន្ធប្រតិបត្តិការផ្សេងទៀត (ឧទាហរណ៍ Linux) អ្នកមិនចាំបាច់បន្ថែមបន្ទាត់នេះទេ។.

ដោយមិនចាំបាច់បិទបង្អួចនេះទេ អ្នកត្រូវចុចលើរូបភាពនៅខាងឆ្វេងជាមួយនឹងសិលាចារឹក "ការកំណត់បំបាត់កំហុស" ហើយបន្ទាប់មក ដាក់ធីកប្រអប់សម្រាប់ "វាយតម្លៃកន្សោមក្រោមទស្សន៍ទ្រនិច" ។

បន្ទាប់ពីនោះចុច "យល់ព្រម" ។ រាល់ការផ្លាស់ប្តូរដែលបានធ្វើឡើងត្រូវតែមានប្រសិទ្ធភាព។

2 គម្រោងដំបូង

2.1 ការបង្កើតគម្រោង

ឥឡូវ​យើង​ព្យាយាម​បង្កើត​កម្មវិធី​មួយ​នៅ​ក្នុង C ។

ដើម្បីធ្វើដូច្នេះអ្នកត្រូវបង្កើតគម្រោង។ ជាទូទៅ គម្រោងមួយគឺត្រូវការជាចាំបាច់ដើម្បីបញ្ចូលគ្នានូវឯកសារជាច្រើនចូលទៅក្នុងតែមួយទាំងមូល។ ប៉ុន្តែក្នុងករណីនេះវាកាន់តែងាយស្រួលក្នុងការបង្កើតគម្រោងសម្រាប់ឯកសារមួយ។ លើសពីនេះទៀតនៅពេលអនាគតវានឹងកាន់តែសាមញ្ញក្នុងការធ្វើការជាមួយគម្រោង។

ដូច្នេះដើម្បីបង្កើតគម្រោង សូមជ្រើសរើសម៉ឺនុយ "ឯកសារ" បន្ទាប់មកជ្រើសរើស "ថ្មី" ពីបញ្ជីដែលលេចឡើង បន្ទាប់មកជ្រើសរើស "គម្រោង" ពីបញ្ជីដែលលេចឡើង (សម្រាប់ភាពសង្ខេប សកម្មភាពនេះអាចត្រូវបានកំណត់ថាជា "ឯកសារ=>ថ្មី => គម្រោង" ហើយនៅពេលអនាគត នឹងមានការប្រើប្រាស់កំណត់ចំណាំខ្លីៗបែបនេះ)។ ជាលទ្ធផល ប្រអប់មួយគួរតែលេចឡើង។

នៅក្នុងវាជ្រើសរើស "កម្មវិធីកុងសូល" ហើយចុច "ទៅ" ។ អ្នកជំនួយគម្រោងថ្មីលេចឡើង។

ចុច "បន្ទាប់" ។ បង្អួចខាងក្រោមនឹងលេចឡើង។

នៅទីនេះអ្នកត្រូវជ្រើសរើស C (មិនមែន C ++) ហើយចុច "បន្ទាប់" ។ បង្អួចខាងក្រោមនឹងលេចឡើង។

នៅក្នុងបន្ទាត់ "ចំណងជើងគម្រោង" សូមបញ្ចូលឈ្មោះគម្រោង ឧទាហរណ៍ Project01។ ចំណាំថានៅក្នុងបន្ទាត់ "ឈ្មោះឯកសារគម្រោង" ឈ្មោះនេះនឹងត្រូវបានចម្លង។ ឈ្មោះឯកសារនេះអាចត្រូវបានផ្លាស់ប្តូរ (ដើម្បីឱ្យខុសពីឈ្មោះគម្រោង) ប៉ុន្តែដើម្បីភាពងាយស្រួល វាជាការប្រសើរក្នុងការទុកពួកវាឱ្យនៅដដែល។ បន្ទាប់មកនៅក្នុងបន្ទាត់ "ថតឯកសារដើម្បីបង្កើតគម្រោងក្នុង" (ថតសម្រាប់បង្កើតគម្រោងនៅក្នុងវា) អ្នកត្រូវបញ្ជាក់ថតដែលថតជាមួយគម្រោងនឹងមានទីតាំងនៅ។ អ្នកអាចជ្រើសរើសថតឯកសារពីឯកសារដែលមានដោយប្រើប៊ូតុង "..." ឬវាយឈ្មោះថតដោយដៃ ឧទាហរណ៍ C:\Projects ។

បន្ទាប់មកថតដែលមានឈ្មោះគម្រោងនឹងត្រូវបានបង្កើតនៅក្នុងថតដែលបានជ្រើសរើស ដែលគម្រោងខ្លួនវានឹងស្ថិតនៅ។ អ្នកអាចពិនិត្យមើលវាដោយយកចិត្តទុកដាក់លើបន្ទាត់ "ឈ្មោះឯកសារលទ្ធផល" ។

នៅពេលបញ្ជាក់ឈ្មោះគម្រោង និងឈ្មោះថតសម្រាប់គម្រោង កុំអនុញ្ញាតឲ្យឈ្មោះថតដែលមានដកឃ្លា ឬអក្សរដែលមិនមែនជាឡាតាំង(បន្ទាត់ "ឈ្មោះឯកសារលទ្ធផល" មិនត្រូវមានចន្លោះនៅក្នុងឈ្មោះថត ហើយក៏មិនត្រូវមានអក្សរក្រៅពីឡាតាំងដែរ)។

ចុចបន្ទាប់។ បង្អួចខាងក្រោមនឹងលេចឡើង។

ទុកឱ្យការកំណត់ទាំងនេះមិនផ្លាស់ប្តូរ។ ចុច "បញ្ចប់" ។ គម្រោងនេះនឹងត្រូវបានបង្កើតឡើង។

នៅផ្នែកខាងលើខាងឆ្វេង (នៅក្នុងបង្អួច "ការគ្រប់គ្រង") គម្រោងដែលមានថត "ប្រភព" នឹងត្រូវបានបង្ហាញ។

អ្នកត្រូវចុចលើ "+" (ឬចុចពីរដងលើថតឯកសារ) ហើយថតនេះនឹងបើក។

វានឹងមានឯកសារ main.c តែមួយ។ អ្នកត្រូវចុចពីរដងលើវា បន្ទាប់មកវាលកែសម្រួលនឹងបើកនៅខាងស្តាំ ដែលមាតិកានៃឯកសារនេះនឹងត្រូវបានបង្ហាញ (នៅផ្នែកខាងលើនឹងមានផ្ទាំងមួយដែលមានឈ្មោះឯកសារ)។

បង្អួចកែសម្រួលនឹងបង្ហាញអត្ថបទនៃកម្មវិធីដំបូងជាមួយនឹងការបន្លិច។ សូមចំណាំថាផ្នែកផ្សេងៗនៃអត្ថបទប្រើពណ៌ផ្សេងគ្នាដើម្បីធ្វើឱ្យអត្ថបទកាន់តែងាយស្រួលអាន។

នេះគឺជាកម្មវិធីសាមញ្ញដំបូងគេដែលបង្ហាញអត្ថបទ "ជំរាបសួរពិភពលោក!" ("សួស្តី​ពិភពលោក!")។ តាមទម្លាប់ នេះគឺជាកម្មវិធីដែលប្រើជាកម្មវិធីដំបូងគេពេលស្គាល់ភាសាសរសេរកម្មវិធី។ ក្នុងករណី Code::Blocks កម្មវិធីនេះត្រូវបានបង្កើតដោយស្វ័យប្រវត្តិនៅពេលអ្នកបង្កើតគម្រោងថ្មី។

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

អ្នកក៏អាចប្រើម៉ឺនុយ “Settings=>Editor” ហើយដោយចុចលើប៊ូតុង “Choose” នៅផ្នែកខាងលើខាងស្តាំ ផ្លាស់ប្តូរមិនត្រឹមតែទំហំពុម្ពអក្សរប៉ុណ្ណោះទេ ប៉ុន្តែក៏ពុម្ពអក្សរខ្លួនឯងផងដែរ។ សូមចងចាំថានៅពេលសរសេរកម្មវិធី វាជាការប្រសើរក្នុងការប្រើពុម្ពអក្សរដែលអក្សរទាំងអស់មានទទឹងដូចគ្នា។ ជាឧទាហរណ៍ ពុម្ពអក្សរបែបនេះ រួមមានពុម្ពអក្សរដូចខាងក្រោម៖ Courier New, Courier, Liberation Mono, Lucida Console, Monospace ជាដើម។

ប្រសិនបើវាប្រែថាបង្អួច "ការគ្រប់គ្រង" ឬបង្អួចចាំបាច់មួយចំនួនផ្សេងទៀតបាត់នៅលើអេក្រង់នោះអ្នកត្រូវជ្រើសរើសម៉ឺនុយមើលហើយនៅក្នុងម៉ឺនុយដែលលេចឡើងសូមជ្រើសរើសធាតុដែលត្រូវគ្នានឹងបង្អួចដែលចង់បាន។

ប្រសិនបើភ្លាមៗនោះគម្រោងត្រូវបានបិទឧទាហរណ៍ នៅពេលចេញ និងបញ្ចូល Code::Blocks ឡើងវិញ វាអាចត្រូវបានបើកឡើងវិញ។ ដើម្បីធ្វើដូចនេះជ្រើសម៉ឺនុយ "ឯកសារ=> គម្រោងថ្មីៗ" ដែលបន្ទាប់មកនៅក្នុងបញ្ជីដែលលេចឡើងសូមជ្រើសរើសគម្រោងដែលចង់បាន។ ឬអ្នកអាចប្រើម៉ឺនុយ "ឯកសារ=>បើក" ហើយបន្ទាប់មកជ្រើសរើសឯកសារ Project01.cbp ។

2.2 ការកសាង និងដំណើរការកម្មវិធី

កម្មវិធី​នេះ​នឹង​ត្រូវ​ពិភាក្សា​លម្អិត​នៅ​ពេល​ក្រោយ​បន្តិច ប៉ុន្តែ​ឥឡូវ​នេះ​សូម​ព្យាយាម​ដំណើរការ​វា​។

ដើម្បីធ្វើដូចនេះត្រូវតែធ្វើ ការចងក្រងអត្ថបទកម្មវិធី (ចងក្រង) និងការប្រើប្រាស់ ប្លង់(ការភ្ជាប់) ឯកសារដែលអាចប្រតិបត្តិបានជាមួយផ្នែកបន្ថែម .exe ត្រូវតែត្រូវបានបង្កើត ដែលនឹងត្រូវបានដាក់ឱ្យដំណើរការ។ ដំណើរការទាំងមូលនៃការចងក្រង និងភ្ជាប់នេះត្រូវបានគេហៅថា ការជួបប្រជុំគ្នា។(អគារ)។

គួរកត់សំគាល់ថា ដំណើរការដែលតំណាងនៅទីនេះដោយពាក្យ Compiling ក៏ត្រូវបានគេហៅថាដំណើរការផងដែរ។ ការផ្សាយ. វាមានបំរែបំរួលផ្សេងៗគ្នានៃវាក្យស័ព្ទនៅក្នុងតំបន់នេះ។ ឧទាហរណ៍ ដំណើរការដំឡើងខាងលើអាចត្រូវបានគេហៅថាការចងក្រង ដែលនៅក្នុងវេនមានការបកប្រែ និងភ្ជាប់ជំហាន។ ប៉ុន្តែឥឡូវនេះ យើងនឹងមិនស្វែងយល់អំពីបញ្ហានៃវាក្យសព្ទទេ ហើយនឹងគ្រាន់តែប្រើកំណែជាភាសាអង់គ្លេសនៃពាក្យនេះជាមូលដ្ឋាន ដោយធម្មជាតិជាមួយនឹងការបកប្រែទៅជាភាសារុស្សី។ ដូច្នេះយើងនឹងនិយាយអំពី ការជួបប្រជុំគ្នា។(សំណង់) ដែលមានដំណាក់កាល ការចងក្រង(ចងក្រង) និង ប្លង់(តំណភ្ជាប់) ។ ជម្រើសនេះក្នុងករណីនេះហាក់ដូចជាងាយស្រួលជាង ដោយសារឈ្មោះដែលត្រូវគ្នាជាភាសាអង់គ្លេសអាចត្រូវបានគេសង្កេតឃើញក្នុងអំឡុងពេលដំណើរការដំឡើង។

កូដបរិស្ថានអភិវឌ្ឍន៍រួមបញ្ចូលគ្នា៖:ប្លុកអនុញ្ញាតឱ្យអ្នកធ្វើស្វ័យប្រវត្តិកម្មការជួបប្រជុំគ្នា និងចាប់ផ្តើម (ដំណើរការ) នៃកម្មវិធី។ ដើម្បីសាងសង់ និងដំណើរការកម្មវិធី គ្រាន់តែប្រតិបត្តិពាក្យបញ្ជា "Build and run" ដោយចុចប៊ូតុង ឬគ្រាប់ចុច F9 ។ ជម្រើសមួយទៀតគឺជ្រើសរើសម៉ឺនុយ "Build => Build and Run" ។

នៅក្នុងបង្អួចខាងក្រោម (សារអំពីដំណើរការបង្កើត) ពាក្យ "ចងក្រង" "ការភ្ជាប់" ជាដើមនឹងលេចឡើង ដែលឆ្លុះបញ្ចាំងពីវឌ្ឍនភាពនៃការចងក្រង និងភ្ជាប់កម្មវិធី។

ជាលទ្ធផល បង្អួចកុងសូលគួរតែលេចឡើង ដែលនៅផ្នែកខាងលើប្រយោគដែលបានបញ្ជាក់នៅក្នុងកម្មវិធីនៅក្នុងសម្រង់នឹងត្រូវបានបង្ហាញ ពោលគឺប្រយោគ "ជំរាបសួរពិភពលោក!"

ដូច្នេះកម្មវិធីបង្ហាញខ្សែអក្សរដែលបានផ្តល់ឱ្យនៅលើអេក្រង់។

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

ពុម្ពអក្សរដែលប្រើក្នុងបង្អួចកុងសូលអាចត្រូវបានផ្លាស់ប្តូរប្រសិនបើចាំបាច់។ឧទាហរណ៍ ក្នុងករណីប្រព័ន្ធប្រតិបត្តិការ Windows អ្នកអាចសាកល្បងជំហានខាងក្រោម។

ចុច ត្រឹមត្រូវ។ចុចលើរូបតំណាងនៅជ្រុងខាងឆ្វេងខាងលើនៃបង្អួចកុងសូល។ ម៉ឺនុយលេចឡើងគួរតែលេចឡើងដែលអ្នកត្រូវជ្រើសរើសធាតុ "លំនាំដើម" ។

បង្អួចការកំណត់នឹងលេចឡើង។

នៅក្នុងបង្អួចនេះអ្នកត្រូវជ្រើសរើសពុម្ពអក្សរដែលចង់បាន (ឧទាហរណ៍ Lucida Console) ។ បន្ទាប់មក សម្រាប់ពុម្ពអក្សរនេះ អ្នកត្រូវជ្រើសរើសទំហំដែលចង់បាន (ឧទាហរណ៍ ១៤)។ បន្ទាប់ពីនេះអ្នកត្រូវចុច "យល់ព្រម" ដើម្បីរក្សាទុកការកំណត់។

បន្ទាប់មក អ្នកត្រូវបិទបង្អួចកុងសូលដោយចុចគ្រាប់ចុចណាមួយ។

បន្ទាប់ពីនេះ អ្នកត្រូវចាប់ផ្តើមកម្មវិធីឡើងវិញដោយចុចប៊ូតុង ឬគ្រាប់ចុច F9 (ឬជ្រើសរើសម៉ឺនុយ "Build=>Build and run")។

ឥឡូវនេះ បង្អួចកុងសូលគួរតែមានពុម្ពអក្សរថ្មី។

2.3 ការពន្យល់អំពីកម្មវិធី

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

# រួមបញ្ចូល # រួមបញ្ចូល int main() { printf("សួស្តីពិភពលោក!\n"); ត្រឡប់ 0; }

ពាក្យចម្បងត្រូវបានផ្តល់ឱ្យដែលការប្រតិបត្តិនៃកម្មវិធីណាមួយចាប់ផ្តើម។ នេះមានន័យថាមុខងារចម្បងដែលអ្វីៗចាប់ផ្តើម។ វាអាចមានការហៅទៅកាន់មុខងារផ្សេងទៀតនៅក្នុងមុខងារនេះ ប៉ុន្តែវាទាំងអស់ចាប់ផ្តើមជាមួយនឹងការប្រតិបត្តិមាតិកានៃមេ។ បន្ទាប់​ពី​ឈ្មោះ​នៃ​អនុគមន៍​នេះ មាន​វង់ក្រចក​ដែល​គ្មាន​អ្វី​នៅ​ចន្លោះ​ពួកវា។ នេះមានន័យថាមុខងារនេះមិនមានអំណះអំណាងណាមួយឡើយ។ មុខងារនីមួយៗត្រូវតែមានវង់ក្រចក ទោះបីជាវាគ្មានអាគុយម៉ង់ក៏ដោយ។

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

មុន​ឈ្មោះ main គឺ​ជា​ពាក្យ int ដែល​បញ្ជាក់​ប្រភេទ​តម្លៃ​ដែល​បាន​ត្រឡប់​ដោយ​អនុគមន៍។ ក្នុងករណីនេះវាគឺជាប្រភេទចំនួនគត់ (នៅពេលអនាគត ប្រភេទទិន្នន័យផ្សេងគ្នានឹងត្រូវបានពិភាក្សាដោយឡែកពីគ្នា)។ មុខងារចម្បង (នោះគឺជាកម្មវិធីសំខាន់) ត្រឡប់លេខកូដចេញរបស់កម្មវិធី។ ជាទូទៅគេជឿថាកម្មវិធីមួយគួរតែត្រឡប់តម្លៃ 0 កំឡុងពេលប្រតិបត្តិធម្មតា ការត្រឡប់តម្លៃនេះត្រូវបានធ្វើដោយប្រើខ្សែកោងបិទត្រឡប់មកវិញ 0 ។

ផងដែររវាងដង្កៀបអង្កាញ់គឺជាការហៅមុខងារហៅថា printf ។ មុខងារនេះត្រូវបានប្រើក្នុងករណីនេះដើម្បីបង្ហាញអត្ថបទនៅលើអេក្រង់។ វង់ក្រចកសម្រាប់មុខងារនេះបង្ហាញពីអាគុយម៉ង់របស់វា។ នៅទីនេះ អាគុយម៉ង់តែមួយគត់គឺខ្សែអក្សរដែលរុំព័ទ្ធក្នុងសម្រង់ទ្វេ។ វាគឺជាបន្ទាត់នេះដែលត្រូវបានបោះពុម្ពទៅអេក្រង់ដោយមុខងារ printf ។ ប៉ុន្តែការរួមបញ្ចូលគ្នានៃតួអក្សរ \n មិនត្រូវបានបង្ហាញនៅលើអេក្រង់ទេ។ ការរួមបញ្ចូលគ្នានេះបង្ហាញពីតួអក្សរបន្ទាត់ថ្មី ដែលមិនត្រូវបានបោះពុម្ពនៅលើអេក្រង់ ប៉ុន្តែមានន័យថាបន្ទាត់ថ្មីគួរតែត្រូវបានអនុវត្តនៅទីតាំងនោះ។

ដើម្បីយល់ពីអត្ថន័យនៃតួអក្សរបន្ទាត់ថ្មី សូមព្យាយាមដកបន្សំ \n ចេញពីបន្ទាត់ ដំណើរការកម្មវិធី និងមើលលទ្ធផល។ សាកល្បងប្រើបន្សំ \n ជាច្រើនដងក្នុងមួយជួរ ដំណើរការកម្មវិធី និងមើលលទ្ធផល។ បន្ទាប់មកត្រឡប់កំណែដើមនៃកម្មវិធី។

មានសញ្ញាក្បៀសបន្ទាប់ពីការហៅមុខងារ printf ។ នេះអនុញ្ញាតឱ្យប្រតិបត្តិករនីមួយៗដាច់ដោយឡែកពីគ្នាទៅវិញទៅមក។ ជាពិសេស វាបំបែកការហៅមុខងារ printf ចេញពីសេចក្តីថ្លែងការត្រឡប់មកវិញ។

វានៅតែត្រូវយល់ថាហេតុអ្វីបានជាបន្ទាត់នៅក្នុងកម្មវិធីនេះត្រូវការ។ ដោយមិនចូលទៅក្នុងសេចក្តីលម្អិត យើងអាចនិយាយបានថា បន្ទាត់គឺត្រូវការដើម្បីធ្វើឱ្យវាអាចប្រើមុខងារ printf ចាប់តាំងពីបន្ទាត់នេះធ្វើឱ្យវាអាចទទួលបានព័ត៌មានអំពីមុខងារនេះ។ បន្ទាត់នេះរួមបញ្ចូលឯកសារ stdio.h ដែលឈ្មោះរបស់វាត្រូវបានចង្អុលបង្ហាញនៅក្នុងវង់ក្រចកជាតួអក្សរ< и >. ពាក្យបញ្ជា #include បង្ហាញពីការដាក់បញ្ចូលឯកសារនេះ។ ការតភ្ជាប់នេះអនុញ្ញាតឱ្យអ្នកប្រើមុខងារដែលបានប្រកាសនៅក្នុងឯកសារនេះ ជាពិសេសមុខងារ printf ។ បន្ទាត់នៅក្នុងកម្មវិធីនេះជាទូទៅមិនត្រូវការទេប៉ុន្តែគោលការណ៍នៃប្រតិបត្តិការរបស់វាគឺស្រដៀងគ្នាមានតែឯកសារផ្សេងទៀត (stdlib.h) ត្រូវបានរួមបញ្ចូលនៅទីនេះ។

2.4 ការផ្លាស់ប្តូរកម្មវិធី

ឥឡូវអ្នកអាចងាកទៅកែសម្រួលឯកសារ main.c ។

អ្នក​អាច​វាយ​អត្ថបទ​ណា​មួយ​ក្នុង​កន្លែង​កែ​សម្រួល ដូច​ក្នុង​កម្មវិធី​កែ​ធម្មតា​ដែរ។ នៅពេលអនាគត ឧទាហរណ៍កម្មវិធី និងបំណែកកម្មវិធីអាចត្រូវបានបិទភ្ជាប់ទៅក្នុងវាលកែសម្រួលដោយប្រើការចម្លងធម្មតានៃប្លុកអត្ថបទ។ ចូរយើងពិចារណាសកម្មភាពស្រដៀងគ្នាមួយនៅក្នុងឧទាហរណ៍ខាងក្រោម។

មាតិកានៃឯកសារ main.c ត្រូវបានបង្កើតដោយស្វ័យប្រវត្តិ។ ប៉ុន្តែ​កម្មវិធី​បែបនេះ​អាច​សរសេរ​បាន​ខ្លី​ជាង​នេះ​បន្តិច ហើយ​ក៏​បាន​ផ្លាស់ប្តូរ​បន្តិចបន្តួច​ដោយ​បន្ថែម​សញ្ញាឧទាន។

# រួមបញ្ចូល int main()( printf("សួស្តីពិភពលោក!!!\n");ត្រឡប់ 0; )

ឥឡូវនេះកម្មវិធីនេះត្រូវតែត្រូវបានផ្ទេរទៅបង្អួចកែសម្រួលដោយប្រើការចម្លងធម្មតា។ ដើម្បីធ្វើដូចនេះអ្នកត្រូវជ្រើសរើសអត្ថបទកម្មវិធីហើយចម្លងអត្ថបទដែលបានជ្រើសរើសទៅក្ដារតម្បៀតខ្ទាស់ឧទាហរណ៍ដោយចុចប៊ូតុងកណ្ដុរខាងស្ដាំហើយជ្រើសរើស "ចម្លង" ពីម៉ឺនុយ) ។ បន្ទាប់មក អ្នកត្រូវប្តូរទៅ Code::Blocks Edit Window, បន្លិចអត្ថបទនៅទីនោះហើយបិទភ្ជាប់អត្ថបទពីក្តារតម្បៀតខ្ទាស់ ជាឧទាហរណ៍ ដោយជ្រើសរើសម៉ឺនុយ "កែសម្រួល=>បិទភ្ជាប់" ឬដោយជ្រើសរើស បន្ទាប់ពីចុចខាងស្តាំ ម៉ឺនុយ "កែសម្រួល=>បិទភ្ជាប់"។ កំណែរបស់កម្មវិធីនេះគួរតែបង្ហាញនៅក្នុងបង្អួចកែសម្រួល។

រក្សាទុកកំណែថ្មីនៃកម្មវិធី។ ដើម្បីធ្វើដូចនេះគ្រាន់តែចុច Ctrl-S (ឬជ្រើសរើសម៉ឺនុយ "ឯកសារ=> រក្សាទុកឯកសារ") ។ ហ្វឹកហាត់ខ្លួនអ្នកឱ្យរក្សាទុកឯកសារបន្ទាប់ពីរាល់ការផ្លាស់ប្តូរនៅក្នុងអត្ថបទកម្មវិធី។បើមិនដូច្នោះទេ នៅពេលដែលវាបង្កក បរិមាណការងារមួយចំនួនអាចនឹងបាត់បង់។

សាកល្បងដំណើរការកម្មវិធីកំណែថ្មីនេះ។

ភារកិច្ចគ្រប់គ្រងខ្លួនឯង

1. ប្តូរអត្ថបទ "សួស្តីពិភពលោក!!!" ទៅភាសាផ្សេងទៀត ខណៈពេលដែលប្រើភាសារុស្សី។ ដំណើរការកម្មវិធីដើម្បីពិនិត្យមើលការផ្លាស់ប្តូរ។
2. ផ្លាស់ប្តូរតម្លៃ 0 បន្ទាប់ពីត្រឡប់ទៅតម្លៃលេខមួយចំនួនផ្សេងទៀត ឧទាហរណ៍ 5. ដំណើរការកម្មវិធី ហើយពិនិត្យមើលថាបន្ទាប់ពី "ដំណើរការត្រឡប់មកវិញ" តម្លៃលេខថ្មីត្រូវបានបង្ហាញនៅក្នុងបង្អួចកុងសូល។
3. ត្រូវប្រាកដថានៅពេលអ្នកចាប់ផ្តើមកម្មវិធី មុនពេលបោះពុម្ពបន្ទាត់ "សួស្តីពិភពលោក!!!" មានការផ្លាស់ប្តូរចុះក្រោមមួយបន្ទាត់នៅលើអេក្រង់។ ដើម្បីធ្វើដូចនេះដាក់ \n នៅដើមបន្ទាត់ដែលប្រើជាអាគុយម៉ង់ទៅអនុគមន៍ printf ។ ដំណើរការកម្មវិធីដើម្បីប្រាកដថាភារកិច្ចត្រូវបានបញ្ចប់យ៉ាងត្រឹមត្រូវ។
4. ត្រូវប្រាកដថានៅពេលអ្នកចាប់ផ្តើមកម្មវិធី មុនពេលបោះពុម្ពបន្ទាត់ "ជំរាបសួរពិភពលោក!" មានការផ្លាស់ប្តូរបន្ទាត់ជាច្រើននៅលើអេក្រង់។ ដើម្បីធ្វើដូចនេះដាក់បន្សំ \n ច្រើនដងក្នុងមួយជួរនៅដើមបន្ទាត់ដែលប្រើជាអាគុយម៉ង់សម្រាប់មុខងារ printf (មានន័យថាខ្សែអក្សរដែលមានទីតាំងនៅក្នុងវង់ក្រចកក្នុងសញ្ញាសម្រង់)។ ដំណើរការកម្មវិធីដើម្បីប្រាកដថាភារកិច្ចត្រូវបានបញ្ចប់យ៉ាងត្រឹមត្រូវ។
5. បោះពុម្ពបន្ទាត់ "សួស្តីពិភពលោក !!!" បីដងក្នុងបន្ទាត់បីជាប់គ្នានៅលើអេក្រង់ (មួយច្បាប់ចម្លងក្នុងមួយជួរ) ដាក់បន្សំ \n នៅកន្លែងដែលត្រឹមត្រូវ។
6. ត្រូវប្រាកដថានៅពេលអ្នកចាប់ផ្តើមកម្មវិធី បន្ទាត់ "សួស្តីពិភពលោក!!!" បង្ហាញយ៉ាងច្បាស់នៅកណ្តាលអេក្រង់។ ដើម្បីធ្វើដូច្នេះ អ្នកត្រូវផ្លាស់ទីបន្ទាត់ចុះក្រោម និងទៅខាងស្តាំដោយប្រើ \n និងដកឃ្លា។
7. បង្ហាញពាក្យបីផ្សេងគ្នាក្នុងពេលដំណាលគ្នាក្នុងបីកន្លែងនៅលើអេក្រង់៖ នៅជ្រុងខាងលើ និងនៅកណ្តាលអេក្រង់។ ប្រើការហៅ printf ពីរក្នុងមួយជួរដែលមានខ្សែផ្សេងគ្នាជាអាគុយម៉ង់ ដោយប្រើ \n និងដកឃ្លាក្នុងវិធីពិសេសនៅក្នុងករណីនីមួយៗ។

2.5 ដំណើរការកម្មវិធីនៅខាងក្រៅបរិយាកាសអភិវឌ្ឍន៍ក្នុងករណី Windows

ថតគម្រោង ផ្លូវដែលបានបញ្ជាក់នៅពេលបង្កើតគម្រោង (សូមមើល) គួរតែមាន bin/Debug folder។ ហើយនៅក្នុងថតនេះគួរតែមានឯកសារដែលអាចប្រតិបត្តិបាន Project01.exe ដែលទទួលបានជាលទ្ធផលនៃការបង្កើតកម្មវិធី។

ឯកសារដែលអាចប្រតិបត្តិបាននេះ (កម្មវិធី) អាចត្រូវបានចាប់ផ្តើមដោយប្រើមធ្យោបាយស្តង់ដារ (ឧទាហរណ៍ដោយប្រើ Explorer) នោះគឺ នៅខាងក្រៅកូដ៖:រារាំងបរិស្ថានអភិវឌ្ឍន៍។ ឧទាហរណ៍ផងដែរ អ្នកអាចបង្កើតផ្លូវកាត់ទៅកាន់ឯកសារនេះ ហើយដាក់វានៅលើផ្ទៃតុរបស់អ្នក ដូច្នេះអ្នកអាចបើកដំណើរការវាពីទីនោះបាន។

ប៉ុន្តែនៅពេលបើកដំណើរការតាមរបៀបនេះ បង្អួចកុងសូលដែលមានបន្ទាត់លទ្ធផលលេចឡើង ហើយបាត់ភ្លាមៗ ចាប់តាំងពីកម្មវិធីបញ្ចប់ភ្លាមៗដោយមិនរង់ចាំពាក្យបញ្ជារបស់អ្នកប្រើ។ ហេតុអ្វីបានជារឿងនេះកើតឡើង? រឿងនេះគឺថានៅពេលបើកដំណើរការពី Code::Blocks ការរង់ចាំសម្រាប់ការចុចគ្រាប់ចុចណាមួយត្រូវបានបន្ថែមដោយស្វ័យប្រវត្តិ ប៉ុន្តែកម្មវិធីខ្លួនឯងមិនផ្តល់វាទេ។

ដើម្បីអនុវត្តការរង់ចាំចុចគ្រាប់ចុច (ក្នុងករណីវីនដូ) អ្នកត្រូវផ្លាស់ប្តូរកម្មវិធីដោយបន្ថែមបន្ទាត់ជាច្រើន។ បន្ទាប់មកវានឹងយកទម្រង់ដូចខាងក្រោម។

# រួមបញ្ចូល # រួមបញ្ចូល int main () ( printf("សួស្តីពិភពលោក!!!\n"); getch(); return 0; )

សាកល្បងដំណើរការកម្មវិធីនេះពី Code::Blocks។ ដើម្បីធ្វើដូចនេះដាក់កម្មវិធីដែលបានបញ្ជាក់នៅក្នុងវាលកែសម្រួល ជំនួស​អោយអាចប្រើបាន ហើយដំណើរការកម្មវិធីដោយចុចប៊ូតុង ឬគ្រាប់ចុច F9 (ឬជ្រើសរើសម៉ឺនុយ "Build=>Build and run")។

សូម​កត់​សម្គាល់​ថា បន្ទាប់​ពី​បាន​បោះពុម្ព "Hello world!!!" ឥឡូវនេះគ្មានអ្វីផ្សេងទៀតត្រូវបានបោះពុម្ពទេព្រោះវាកំពុងរង់ចាំការចុចគ្រាប់ចុច។ ប៉ុន្តែបន្ទាប់ពីចុចគ្រាប់ចុចមួយ បន្ទាត់ពីរដែលធ្លាប់ស្គាល់រួចជាលទ្ធផល ("ដំណើរការត្រឡប់ ... " និង "ចុចគ្រាប់ចុចណាមួយដើម្បីបន្ត")។ បន្ទាប់ពីបន្ទាត់ទាំងនេះ យើងរង់ចាំម្តងទៀតសម្រាប់ការចុចគ្រាប់ចុច (ដែលត្រូវបានផ្តល់ដោយ Code::Blocks environment)។

ឥឡូវនេះប្រសិនបើអ្នកដំណើរការកម្មវិធីនេះ នៅខាងក្រៅ Code::Blocks ដោយដំណើរការឯកសារ Project01.exe អត្ថបទដែលបានបញ្ជាក់នឹងត្រូវបានបង្ហាញនៅក្នុងបង្អួច ហើយកម្មវិធីនឹងរង់ចាំការចុចគ្រាប់ចុចដើម្បីបញ្ចប់។

ដើម្បីកែប្រែកម្មវិធីតាមវិធីនេះ បន្ទាត់ពីរត្រូវបានទាមទារ៖ មួយមាន conio.h និងមួយមាន getch ។ conio.h ត្រូវការដើម្បីធ្វើឱ្យវាអាចធ្វើទៅបានដើម្បីហៅមុខងារ getch ។ វាស្រដៀងនឹងការភ្ជាប់ stdio.h ដើម្បីអាចហៅមុខងារ printf បាន។ មុខងារ getch រង់ចាំការចុចគ្រាប់ចុច។

ការផ្លាស់ប្តូរបែបនេះនឹងមិនត្រូវបានបញ្ជាក់នៅពេលអនាគតទេ ប៉ុន្តែប្រសិនបើចាំបាច់ អ្នកតែងតែអាចធ្វើឱ្យពួកវាដូចគ្នា ដើម្បីធានាថាអ្នករង់ចាំសម្រាប់ចុចគ្រាប់ចុច មុនពេលបញ្ចប់កម្មវិធី។

2.6 សារអំពីការព្រមាន និងកំហុសនៅក្នុងកម្មវិធី

នៅពេលបង្កើតកម្មវិធី (នៅពេលព្យាយាមដំណើរការវាបន្ទាប់ពីការផ្លាស់ប្តូរ) ការព្រមាន និងកំហុសអាចលេចឡើង។ សូមក្រឡេកមើលរបៀបដែលវាកើតឡើងដោយប្រើឧទាហរណ៍។ សាកល្បងដំណើរការកម្មវិធីខាងក្រោម។

# រួមបញ្ចូល int main () ( printf("សួស្តីពិភពលោក!!!\n" ); )

កម្មវិធីនេះមិនមានការត្រឡប់មកវិញទេ ប៉ុន្តែវានឹងដំណើរការ។ សាកល្បងដំណើរការវា។

ទោះជាយ៉ាងណាក៏ដោយក្នុងអំឡុងពេលចងក្រង ការព្រមាននឹងត្រូវបានចេញដោយសារតែការពិតដែលថាមិនមានសេចក្តីថ្លែងការណ៍ត្រឡប់មកវិញ។ នៅពេលអ្នកចាប់ផ្តើមកម្មវិធី ការព្រមាននេះនឹងរលាយបាត់ ព្រោះវាមិនប៉ះពាល់ដល់ការចាប់ផ្តើមរបស់កម្មវិធីនោះទេ។ ប៉ុន្តែវាអាចត្រូវបានអានប្រសិនបើអ្នកគ្រាន់តែបង្កើតឯកសារ (ដោយមិនដំណើរការកម្មវិធី) ។ ដើម្បីធ្វើដូច្នេះ អ្នកត្រូវបង្កើតពាក្យបញ្ជា "Build" ដោយចុច Ctrl-F9 ឬដោយចុចប៊ូតុង ឬដោយជ្រើសរើសម៉ឺនុយ "Build=>Build"។

ប៉ុន្តែ​ប្រសិនបើ​កម្មវិធី​មិន​បាន​ផ្លាស់ប្តូរ​ចាប់តាំងពី​ការ​បង្កើត​មុន​ឬ​ការ​បើក​ដំណើរការ​នោះ​ការ​បង្កើត​ថ្មី​នឹង​មិន​ត្រូវ​បាន​ប្រតិបត្តិ​ឡើយ។ ហើយនៅក្នុងបង្អួចខាងក្រោមសារមួយនឹងត្រូវបានបង្ហាញដោយបញ្ជាក់ថាការជួបប្រជុំគ្នាគឺថ្មីបំផុតរួចទៅហើយ ហើយគ្មានអ្វីផ្សេងទៀតត្រូវធ្វើសម្រាប់ពាក្យបញ្ជានេះទេ ("គោលដៅគឺទាន់សម័យ។ គ្មានអ្វីត្រូវធ្វើទេ។")។

ក្នុងករណីនេះអ្នកត្រូវរៀបចំវាឡើងវិញ។ ដើម្បីធ្វើដូចនេះអ្នកត្រូវបង្កើតពាក្យបញ្ជា "បង្កើតឡើងវិញ" ដោយចុច Ctrl-F11 ឬដោយចុចប៊ូតុងឬដោយជ្រើសរើសម៉ឺនុយ "Build=> Rebuild" ។ បន្ទាប់ពីពាក្យបញ្ជានេះត្រូវបានបង្កើត បង្អួចលេចឡើងដើម្បីបញ្ជាក់វា។ ដើម្បីបញ្ជាក់ពាក្យបញ្ជានេះ សូមចុច "បាទ" នៅក្នុងបង្អួចដែលបានបញ្ជាក់។

បន្ទាប់មកនៅក្នុងបង្អួចខាងក្រោម អ្នកអាចមើលឃើញបន្ទាត់ដែលមានការព្រមាន (ពណ៌ខៀវ) ក៏ដូចជាសារអំពីវត្តមាននៃការព្រមានមួយ (1 ការព្រមាន)។

ជាទូទៅ ការព្រមានអនុញ្ញាតឱ្យកម្មវិធីត្រូវបានប្រតិបត្តិ ប៉ុន្តែជូនដំណឹងដល់អ្នកសរសេរកម្មវិធីអំពីកំហុសដែលអាចកើតមាន ឬភាពមិនត្រឹមត្រូវ។

នៅពេលអនាគត សេចក្តីថ្លែងការត្រឡប់សម្រាប់មុខងារចម្បងអាចនឹងមិនត្រូវបានប្រើសម្រាប់ភាពខ្លី ដូចដែលបានធ្វើនៅក្នុង . ប៉ុន្តែ​យើង​ត្រូវ​គិត​ថា នេះ​ជា​ហេតុ​ធ្វើ​ឱ្យ​មាន​ការ​ព្រមាន​លេច​ឡើង។

ឥឡូវសាកល្បងដំណើរការកម្មវិធីខាងក្រោម។

# រួមបញ្ចូល int main() ( printf( សួស្តីពិភពលោក!!!\n); }

ចំណាំថាកម្មវិធីនឹងមិនចាប់ផ្តើមទេ។ ផ្ទុយទៅវិញ បន្ទាត់ក្នុងពុម្ពអក្សរពណ៌ក្រហមនឹងបង្ហាញនៅក្នុងបង្អួចខាងក្រោមដែលបង្ហាញពីកំហុស។

បន្ទាត់នៅក្នុងកម្មវិធីដែលមានកំហុសត្រូវបានបន្លិចដោយការ៉េក្រហម។

វាគួរតែត្រូវបានគេយកទៅពិចារណាថា កំហុសត្រឹមត្រូវមួយអាចនាំឱ្យមានសារកំហុសជាច្រើនក្នុងពេលតែមួយ។ ក្នុងឧទាហរណ៍នេះ 5 កំហុសត្រូវបានបង្កើត ដូច្នេះ 5 បន្ទាត់ត្រូវបានបង្ហាញជាពុម្ពអក្សរក្រហម។

ការប្រៀបធៀបកម្មវិធីវាមិនពិបាកក្នុងការយល់ថាកំហុសកើតឡើងដោយសារតែការពិតដែលសញ្ញាសម្រង់មិនត្រូវបានបញ្ជាក់។ ដូច្នោះហើយ កំហុស "ជំរាបសួរ" ដែលមិនបានប្រកាសត្រូវបានបង្ហាញ។ ពាក្យ "មិនបានប្រកាស" មានន័យថា "មិនបានប្រកាស" មានន័យថា អ្នកចងក្រងកំពុងព្យាយាមយល់ពីអត្ថន័យ ហេឡូ និងអ្វីដែលគួរធ្វើ។ វាមិនអាចរកឃើញពាក្យនេះក្នុងចំនោមពាក្យដែលគេស្គាល់ទេ ដូច្នេះវាធ្វើឱ្យមានកំហុស។ ប្រសិនបើពាក្យនេះនៅក្នុងសម្រង់ទ្វេ នោះវាត្រូវបានគេយល់ថាជាខ្សែអក្សរ ដែលនៅខាងក្នុងអ្វីដែលអាចជា។ ខ្សែអក្សរអាចត្រូវបានបង្ហាញនៅលើអេក្រង់។ ដូច្នេះបន្ទាប់ពីកែកម្មវិធី (បន្ថែមសម្រង់តាមការចាំបាច់) អ្វីគ្រប់យ៉ាងគួរតែល្អ។

កែកម្មវិធី ហើយពិនិត្យមើលថាវាដំណើរការត្រឹមត្រូវ។

ភារកិច្ចគ្រប់គ្រងខ្លួនឯង

1. សាកល្បងដកដង្កៀបអង្កាញ់ចុងក្រោយចេញ ហើយដំណើរការកម្មវិធី។ សូមកត់សម្គាល់ថាកំហុសត្រូវបានកត់សម្គាល់នៅលើបន្ទាត់ដែលមាន printf ដែលជាបន្ទាត់មុន។ ស្តារកម្មវិធីត្រឹមត្រូវ។
2. ព្យាយាមដកវង់ក្រចកពីរចេញបន្ទាប់ពីមេ។ សូមកត់សម្គាល់ថាកំហុសត្រូវបានកត់សម្គាល់នៅលើបន្ទាត់ដែលមានដង្កៀបអង្កាញ់ដែលជាបន្ទាត់បន្ទាប់។ ស្តារកម្មវិធីត្រឹមត្រូវ។
3. ព្យាយាមដកវង់ក្រចកដំបូងចេញបន្ទាប់ពីមេ។ ចំណាំថាកំហុសត្រូវបានកត់សម្គាល់នៅលើបន្ទាត់ដែលមានមេ ដែលជាបន្ទាត់ដូចគ្នា។ ស្តារកម្មវិធីត្រឹមត្រូវ។

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

3 ព័ត៌មានមូលដ្ឋាន

3.1 ចំនួនគត់

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

ការប្រកាសអថេរត្រូវបានធ្វើដូចខាងក្រោម។

variable_type variable_name;

ឧទាហរណ៍ អថេរចំនួនគត់ a ត្រូវបានប្រកាសដូចខាងក្រោម។

int a;

ក្នុងករណីនេះ អថេរ a គឺជាប្រភេទ int ដែលតំណាងឱ្យប្រភេទចំនួនគត់។

សេចក្តីប្រកាសអថេរបញ្ជាក់ប្លុកនៃអង្គចងចាំដើម្បីរក្សាទុកទិន្នន័យនៃប្រភេទដែលបានបញ្ជាក់។ តាមធម្មជាតិ អ្នកអាចជ្រើសរើសប្លុកស្រដៀងគ្នាជាច្រើន។ ដើម្បីសម្គាល់ពួកវាពីគ្នាទៅវិញទៅមកប្លុកទាំងនេះត្រូវបានដាក់ឈ្មោះ។ ឧទាហរណ៍ ការប្រកាស int បែងចែកប្លុកដែលមានឈ្មោះ a ការប្រកាស int b បែងចែកប្លុកដែលមានឈ្មោះ b ។ល។ ក្នុងករណីនេះអ្នកអាចប្រកាសអថេរជាច្រើនក្នុងពេលដំណាលគ្នា ពោលគឺជ្រើសរើសប្លុកជាច្រើននៃ ប្រភេទដូចគ្នាដែលមានឈ្មោះផ្សេងគ្នា។ ដើម្បីធ្វើដូច្នេះបាន ឈ្មោះនៃប្លុកទាំងនេះត្រូវបានរាយបញ្ជីដោយបំបែកដោយសញ្ញាក្បៀស បន្ទាប់ពីការកំណត់ប្រភេទ។

int x, y, z;

សេចក្តីប្រកាសនេះកំណត់ប្លុកបីផ្សេងគ្នានៃប្រភេទដូចគ្នាដែលមានឈ្មោះផ្សេងគ្នា។

ដើម្បីសរសេរតម្លៃទៅប្លុកទិន្នន័យដែលបានជ្រើសរើស អ្នកត្រូវកំណត់តម្លៃនេះទៅអថេរដែលត្រូវគ្នា ឧទាហរណ៍ កន្សោម

កំណត់អថេរ a តម្លៃ 10។ អ្នកក៏អាចកំណត់អថេរមួយតម្លៃនៃអថេរផ្សេងទៀត ឧទាហរណ៍ កន្សោម

កំណត់អថេរ a តម្លៃនៃអថេរ ខ។ អ្នកអាចកំណត់តម្លៃដូចគ្នាទៅអថេរជាច្រើនក្នុងពេលតែមួយ។ ដើម្បីធ្វើដូច្នេះ ជាឧទាហរណ៍ អ្នកអាចប្រើកន្សោមខាងក្រោម។

X = y = z = 100;

សូមចងចាំថាអថេរអាចត្រូវបានកំណត់តម្លៃបានលុះត្រាតែអថេរត្រូវបានប្រកាស (ជាពិសេស ប្រភេទរបស់វាត្រូវបានបញ្ជាក់)។

តម្លៃនៃអថេរអាចត្រូវបានបោះពុម្ពទៅអេក្រង់ដោយប្រើមុខងារ printf ។ ជាឧទាហរណ៍ សូមពិនិត្យមើលការប្រតិបត្តិនៃកម្មវិធីខាងក្រោម។

# រួមបញ្ចូល int main()( int a; /* សេចក្តីប្រកាសអថេរ ក*/ a = 10; printf( "តម្លៃអថេរ a = %d\n", ក); }

សូមចំណាំថានៅក្នុងកម្មវិធីមានមតិ "ប្រកាសអថេរ a" ។ មតិយោបល់គឺជាបំណែកដែលត្រូវការដើម្បីពិពណ៌នាផ្នែកជាក់លាក់នៃកម្មវិធី។ សេចក្តីអធិប្បាយមិនប៉ះពាល់ដល់កម្មវិធីចុងក្រោយទេ វាគ្រាន់តែជាការបន្ថែមទៅលើអត្ថបទ ដែលមិនត្រូវបានប្រើជាបន្តបន្ទាប់នៅពេលដំណើរការកម្មវិធី។ មតិយោបល់ត្រូវតែចាប់ផ្តើមដោយបន្សំតួអក្សរ /* និងបញ្ចប់ដោយបន្សំតួអក្សរ */ ។ ក្នុងករណីនេះ សេចក្តីអធិប្បាយអាចស្ថិតនៅលើបន្ទាត់ជាច្រើនសម្រាប់នេះ ការរួមបញ្ចូលគ្នា /* នឹងមានទីតាំងនៅដើមបន្ទាត់ដំបូងនៃមតិយោបល់ ហើយការរួមបញ្ចូលគ្នា */ នឹងមានទីតាំងនៅចុងបន្ទាត់ចុងក្រោយនៃ មតិយោបល់។

នៅដើមដំបូងនៃមុខងារចម្បង អថេរ a. បន្ទាប់មកអថេរនេះមានតម្លៃ 10. នៅជួរបន្ទាប់ សូមប្រើមុខងារ printf ដើម្បីបង្ហាញតម្លៃនៃអថេរនៅលើអេក្រង់។ ដើម្បីធ្វើដូចនេះបន្ថែមអាគុយម៉ង់បន្ថែមទៅអនុគមន៍ printf បំបែកដោយសញ្ញាក្បៀសបន្ទាប់ពីខ្សែអក្សរដែលបានដកស្រង់។ អាគុយម៉ង់បន្ថែមនេះគឺជាអថេរ a ខ្លួនវា តម្លៃដែលគួរត្រូវបានបោះពុម្ពលើអេក្រង់។ ដើម្បីប្រាប់មុខងារ printf កន្លែងដែលត្រូវបោះពុម្ពតម្លៃនៃអថេរ ការរួមបញ្ចូលគ្នានៃតួអក្សរពីរគឺ %d ត្រូវបានបន្ថែមទៅខ្សែអក្សរលទ្ធផល។ តួអក្សរទាំងនេះខ្លួនឯងនឹងមិនត្រូវបានបង្ហាញនៅលើអេក្រង់ទេ ប៉ុន្តែជំនួសឱ្យពួកវាតម្លៃនៃអថេរដែលបំបែកដោយសញ្ញាក្បៀសបន្ទាប់ពីបន្ទាត់នឹងត្រូវបានបង្ហាញ។ ដំណើរការកម្មវិធីហើយពិនិត្យមើលប្រតិបត្តិការរបស់វា។

នៅពេលវាយកម្មវិធី សូមចំណាំថាអក្សរតូច និងអក្សរធំគឺជាអក្សរផ្សេងគ្នាពីទស្សនៈរបស់អ្នកចងក្រង។ ដូច្នេះ ជាឧទាហរណ៍ ការវាយបញ្ចូល Main ជំនួសឲ្យ main នឹងបណ្តាលឱ្យមានកំហុស។

ភារកិច្ចគ្រប់គ្រងខ្លួនឯង

1. ផ្លាស់ប្តូរតម្លៃនៃអថេរ a ទៅតម្លៃផ្សេងទៀត និង
2. ព្យាយាមបន្ថែមមតិទៅផ្នែកផ្សេងៗនៃកម្មវិធី។ ត្រូវប្រាកដថាពួកវាមិនប៉ះពាល់ដល់ការប្រតិបត្តិកម្មវិធីទេ។ ពិនិត្យមើលការប្រើប្រាស់មតិយោបល់ដែលលាតសន្ធឹងលើបន្ទាត់ជាច្រើន។
3. ពិនិត្យមើលថាតើមានអ្វីកើតឡើងនៅពេលអ្នកផ្លាស់ប្តូរករណីនៃអក្សរជាក់លាក់មួយ នោះគឺជាឧទាហរណ៍ នៅពេលផ្លាស់ប្តូរអក្សរតូចទៅជាអក្សរធំ និងច្រាសមកវិញ។

ដើម្បីប្រកាសអថេរ a និងចាប់ផ្តើមវា បន្ទាត់ពីរជាប់គ្នា ( និង ) ត្រូវបានទទួល។ ប៉ុន្តែអ្នកអាចផ្សំការប្រកាសអថេរ និងការចាប់ផ្តើម។ ជំនួសឱ្យបន្ទាត់ពីរដែលបានចង្អុលបង្ហាញ អ្នកអាចសរសេរបានតែមួយបន្ទាត់នៃប្រភេទខាងក្រោម។

int a = 10;

ពិនិត្យមើលថាកម្មវិធីដំណើរការបានត្រឹមត្រូវបន្ទាប់ពីការផ្លាស់ប្តូរបែបនេះ។

មុខងារ printf ក៏អាចបោះពុម្ពតម្លៃនៃអថេរច្រើនក្នុងពេលតែមួយ។ ដើម្បីសាកល្បងលទ្ធភាពនេះ សូមប្រកាសអថេរ b និងកំណត់តម្លៃមួយចំនួនទៅអថេរនោះ មុនពេលហៅមុខងារ printf ។ វាជារឿងសំខាន់ក្នុងការកត់សម្គាល់ថាការប្រកាសអថេរអាចកើតឡើងនៅកន្លែងណាមួយនៅខាងក្នុងដង្កៀបអង្កាញ់នៃអនុគមន៍ ជាពិសេសមុខងារចម្បង។ បន្ទាប់ពីនោះ បំប្លែងខ្សែអក្សរមុខងារ printf ដូចខាងក្រោម។

Printf("a = %d, b = %d \n" , a, b);

ពិនិត្យមើលថាកម្មវិធីដំណើរការត្រឹមត្រូវ។

ដូច្នេះ ដើម្បីបង្ហាញតម្លៃនៃអថេរជាច្រើនក្នុងពេលតែមួយ អ្នកត្រូវរៀបចំតួអក្សរលទ្ធផលដែលបានធ្វើទ្រង់ទ្រាយ %d ក្នុងបន្ទាត់លទ្ធផលតាម ហើយក៏រាយបញ្ជីអថេរដែលបំបែកដោយសញ្ញាក្បៀសភ្លាមៗបន្ទាប់ពីបន្ទាត់លទ្ធផលនៅក្នុងលំដាប់លទ្ធផល។ បន្ទាប់មកជំនួសឱ្យបន្សំនីមួយៗ %d តម្លៃនៃអថេរបន្ទាប់ពីបញ្ជីអថេរដែលបំបែកដោយសញ្ញាក្បៀសនឹងត្រូវបានជំនួស។

ក្នុង​ករណី​នេះ អ្នក​ក៏​អាច​បញ្ជាក់​កន្សោម​ជា​អាគុយម៉ង់​ចំពោះ​អនុគមន៍ printf ។ ឧទាហរណ៍ ដើម្បីការ៉េ និងគូបអថេរ អ្នកអាចប្រើសញ្ញា * ដើម្បីបង្ហាញពីគុណ។ បន្ថែមផ្នែកខាងក្រោមបន្ទាប់ពីការហៅមុខងារ printf ដែលមានស្រាប់។

Printf( "a = %d\n(a squared) = %d\n(a cubed) = %d\n", a, a * a, a * a * a);

ពិនិត្យមើលថាកម្មវិធីដំណើរការត្រឹមត្រូវ។

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

3.2 កន្សោមនព្វន្ធ

ឥឡូវនេះ ដើម្បីការ៉េ ឬគូបចំនួនគត់ វាគ្រប់គ្រាន់ហើយក្នុងការកែតម្រូវកិច្ចការដំបូងទៅអថេរ a ហើយដំណើរការកម្មវិធីឡើងវិញ។ ពិសោធន៍ជាមួយនេះ។ បន្ថែមពីលើការបំបែក និងគូប អ្នកអាចប្រើកន្សោមផ្សេងៗដោយផ្អែកលើប្រតិបត្តិការនព្វន្ធ៖ +, -, *, / ។

ភារកិច្ចគ្រប់គ្រងខ្លួនឯង

1. អនុវត្តការគណនារូបមន្តមួយចំនួនដែលប្រើប្រតិបត្តិការនព្វន្ធទាំង 4 ។ កំណត់តម្លៃនៃអថេរនៅក្នុងកម្មវិធី។ ពិនិត្យមើលថារូបមន្តនេះត្រូវបានគណនាត្រឹមត្រូវ។
2. គណនារូបមន្តពីអថេរពីរ។ កំណត់តម្លៃនៃអថេរនៅក្នុងកម្មវិធី។

ភាសា C ក៏​មាន​សមត្ថភាព​ក្នុង​ការ​សរសេរ​សំណង់​ដែល​គេ​ប្រើ​ញឹកញាប់​មួយ​ចំនួន​ឱ្យ​បាន​ច្បាស់​ជាង​មុន។ ដូច្នេះ ដើម្បីបង្កើនអថេរដោយតម្លៃដែលបានផ្តល់ឱ្យ ប្រតិបត្តិការ += ត្រូវបានប្រើ។ វាប្រែថាការបញ្ចេញមតិ

A += 10;

គឺស្មើនឹងការបញ្ចេញមតិ

A = a + 10;

ក្នុងករណីនេះតាមរបៀបស្រដៀងគ្នាជំនួសឱ្យសញ្ញា + ក៏អាចមានសញ្ញា -, *, / ក៏ដូចជាសញ្ញាប្រតិបត្តិការមួយចំនួនផ្សេងទៀត។

បំណែកនៃកម្មវិធីខាងក្រោមបង្ហាញពីឧទាហរណ៍នៃការប្រើប្រាស់លក្ខណៈពិសេសទាំងនេះ ជាមួយនឹងមតិយោបល់ដែលបង្ហាញពីតម្លៃដែលអថេរយកជាលទ្ធផលនៃការគណនាកន្សោមនព្វន្ធ។

int i = 10; i = (i * 2 + 1) / 3 - 5; /* i = 2 */ i += 5; /* i = 7 */ int j = 3; ខ្ញុំ *= j; /* i = 21 */ i /= 7; /* ខ្ញុំ = 3 */

ភារកិច្ចគ្រប់គ្រងខ្លួនឯង

1. អនុវត្តការគណនារូបមន្តមួយចំនួនដែលប្រើសមត្ថភាពដែលបានបញ្ជាក់ (ទម្រង់សង្ខេបនៃការសរសេរកន្សោមនព្វន្ធមួយចំនួន)។

លើសពីនេះទៅទៀតការបញ្ចេញមតិ

បង្ហាញពីការកើនឡើងនៃអថេរ a ដោយ 1 ដែលស្មើនឹងកន្សោម

A = a + 1;

ដូចគ្នានេះដែរការបញ្ចេញមតិ

នៅទីនេះមានន័យថាថយចុះ 1 ។

វាជាការសំខាន់ក្នុងការកត់សម្គាល់ថាក៏មានកន្សោមនៃទម្រង់ផងដែរ។

A++; ក--;

ពួកគេក៏បង្ហាញពីការកើនឡើងនៃ 1 និងការថយចុះនៃ 1 ។

ទោះយ៉ាងណាក៏ដោយ វាមានភាពខុសប្លែកគ្នារវាងបុព្វបទ (++a) និងទម្រង់ postfix (a++) នៅក្នុងកន្សោមស្មុគស្មាញជាង។

ពេលណា​ បុព្វបទទម្រង់ (++a) ដំបូងបង្កើន (បន្ថយ) ដោយ 1 ហើយបន្ទាប់មកវាយតម្លៃកន្សោមដែលនៅសល់។

ពេលណា​ ការកែក្រោយទម្រង់ (a++) កន្សោមត្រូវបានវាយតម្លៃដំបូងហើយបន្ទាប់មកបង្កើន (បន្ថយ) ដោយ 1 ។

ឧទាហរណ៍ខាងក្រោមបង្ហាញពីភាពខុសគ្នានេះ។

សូមក្រឡេកមើលបំណែកដូចគ្នាដែល ++y (ទម្រង់បុព្វបទ) ត្រូវបានប្រើ។

int x = 10; int y = 2; x = x * (++ y); printf("x = %d y = %d\n", x, y);

X = 30 y = 3

នៅទីនេះ y ដំបូងដោយសារ ++y នឹងទទួលបានតម្លៃ 3 ហើយបន្ទាប់ពីនោះគុណនឹង 10 គុណនឹង 3 នឹងកើតឡើង។

សូមក្រឡេកមើលបំណែកដូចគ្នាដែល y ++ (ទម្រង់ postfix) ត្រូវបានប្រើ។

int x = 10; int y = 2; x = x * (y++); printf("x = %d y = %d\n", x, y);

ក្នុងអំឡុងពេលនៃការប្រតិបត្តិនៃបំណែកនេះ បន្ទាត់ខាងក្រោមនឹងត្រូវបានបង្ហាញនៅលើអេក្រង់។

X = 20 y = 3

នៅទីនេះ 10 ដំបូងនឹងត្រូវបានគុណដោយតម្លៃ y ស្មើនឹង 2 ហើយបន្ទាប់ពីនោះ y ++ នឹងត្រូវបានប្រតិបត្តិ។

វាគួរតែត្រូវបានកត់សម្គាល់ថានៅក្នុងបំណែកទាំងនេះវាមិនចាំបាច់ទាល់តែសោះក្នុងការដាក់វង់ក្រចកជុំវិញ ++y និង y++ ។

ភារកិច្ចគ្រប់គ្រងខ្លួនឯង

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

3.3 ប្រភេទនៃចំនួនគត់

រហូតមកដល់ពេលនេះយើងបានពិចារណាតែប្រភេទ int សម្រាប់ចំនួនគត់។ តើតម្លៃអតិបរមាដែលអាចកំណត់សម្រាប់អថេរ int គឺជាអ្វី?

ធានាអ្នកអាចកំណត់តម្លៃក្នុងចន្លោះពី -32768 ដល់ 32767 ចាប់តាំងពីអថេរ int ត្រូវបានបែងចែក មិន​តិច​ជាង១៦ ប៊ីត។

ប៉ុន្តែឥឡូវនេះ អ្នកនឹងឃើញជាញឹកញាប់ការអនុវត្តកម្មវិធីចងក្រងដែលបែងចែក 32 ប៊ីតទៅជាអថេរ int មានន័យថាអថេរអាចយកតម្លៃក្នុងចន្លោះ -2147483648 ដល់ 2147483647 ។

ទោះយ៉ាងណាក៏ដោយ អ្នកអាចប្រាកដបានថា ជួរនៃតម្លៃត្រឹមត្រូវសម្រាប់អថេរ x នឹងមិនតិចជាងចន្លោះពី -32768 ដល់ 32767 ទេ។

នៅពេលប្រើកំណែដែលបានស្នើឡើងនៃ Code::Blocks និង gcc compiler ដែលភ្ជាប់មកជាមួយវា (ឬកម្មវិធីចងក្រងស្រដៀងគ្នាដែលបានដំឡើងពីមុន) អ្នកទំនងជានឹងឃើញខ្លួនអ្នកនៅក្នុងស្ថានភាពដែលអថេរ int អាចយកតម្លៃពីជួរ -2147483648 ទៅ 2147483647 ។

ចូរយើងពិនិត្យមើលវាជាមួយនឹងឧទាហរណ៍ខាងក្រោម។

# រួមបញ្ចូល int main () ( int x1 = -2147483648; int x2 = 2147483647; printf("x1 = %d x2 = %d\n" , x1, x2); )

X1 = -2147483648 x2 = 2147483647

បើដូច្នេះមែន នេះបង្ហាញថាអថេរនៃប្រភេទ int អាចយកតម្លៃបែបនេះ។

ឥឡូវនេះមុនពេលបន្ទាត់ printf អ្នកអាចកំណត់អថេរ x2 ទៅ 1

# រួមបញ្ចូល int main () ( int x1 = -2147483648; int x2 = 2147483647; ++x2; printf("x1 = %d x2 = %d\n" , x1, x2); )

នៅពេលអ្នកដំណើរការកម្មវិធីនេះ បន្ទាត់ខាងក្រោមទំនងជានឹងត្រូវបានបោះពុម្ព។

X1 = -2147483648 x2 = -2147483648

សូមកត់សម្គាល់ថាតម្លៃនៃ x2 បានក្លាយជាតម្លៃដែនកំណត់អវិជ្ជមាន។ យើងអាចនិយាយបានថានៅពេលព្យាយាមបន្ថែម 1 ទៅតម្លៃវិជ្ជមានអតិបរមា (តម្លៃ 2147483647) តម្លៃបានចេញពីជួរ ហើយតម្លៃ "រាងជារង្វង់" បានទៅតម្លៃអវិជ្ជមានអតិបរមា (តម្លៃ -2147483648) ។ អ្វីដែលគេហៅថាបានកើតឡើង ហៀរ.

ប្រសិនបើអ្នកបង្កើន x2 មិនមែនដោយ 1 ប៉ុន្តែដោយ 2 នោះអថេរ x2 នឹងយកតម្លៃ -2147483647 (ដែលខុសពីតម្លៃអវិជ្ជមានអតិបរមា)។ ពិនិត្យ​វា។

ប្រសិនបើអ្នកបង្កើន x2 មិនមែនដោយ 1 ប៉ុន្តែដោយ 3 នោះអថេរ x2 នឹងយកតម្លៃ -2147483646 (ដែលខុសពីតម្លៃអវិជ្ជមានអតិបរមា)។ ពិនិត្យ​វា។

ដូច្នេះអ្នកអាចយល់ពីគោលការណ៍នៃឥរិយាបទនៃអថេរចំនួនគត់នៅក្នុងករណីនៃការហៀរ។

ភារកិច្ចគ្រប់គ្រងខ្លួនឯង

1. ស្រដៀងគ្នានេះដែរ ពិនិត្យមើលការលើសនៃអថេរ x1 ឆ្ពោះទៅរកតម្លៃអវិជ្ជមានខ្លាំង ពោលគឺនៅពេលដកលេខជាក់លាក់មួយចេញពីអថេរនេះ។
2. Overflow ក៏កើតឡើងនៅពេលដែលអ្នកគ្រាន់តែព្យាយាមកំណត់តម្លៃទៅអថេរដែលនៅក្រៅជួរដែលអនុញ្ញាត។ ពិនិត្យ​វា។

បន្ថែមពីលើប្រភេទ int មានប្រភេទចំនួនគត់ផ្សេងទៀតសម្រាប់ប្រកាសអថេរ។

ឧទាហរណ៍ ប្រភេទវែងអនុញ្ញាតឱ្យអ្នកធានា -2147483648 ទៅ 2147483647 (ប្រភេទ int មិនផ្តល់ការធានានេះសម្រាប់អ្នកចងក្រងទាំងអស់ទេ)។

ផងដែរនៅក្នុងកម្មវិធីចងក្រងភាសា C ទំនើប ប្រភេទវែងវែង (សរសេរជាពីរពាក្យ) បានបង្ហាញខ្លួន ដែលបែងចែក 64 ប៊ីតសម្រាប់អថេរមួយ។ ហើយនេះត្រូវគ្នាទៅនឹងជួរនៃលេខពី -9223372036854775808 ដល់ 9223372036854775807 ។

សូមពិនិត្យមើលប្រភេទនេះដោយប្រើកម្មវិធីខាងក្រោមជាឧទាហរណ៍។

# រួមបញ្ចូល int main() ( long long x1 = -9223372036854775808; long long x2 = 9223372036854775807; printf("x1 = %lld x2 = %lld\n" , x1, x2); }

X1 = -9223372036854775808 x2 = 9223372036854775807

ចំណាំថាក្នុងករណីនេះ នៅពេលហៅមុខងារ printf បន្សំតួអក្សរគឺ %lld មិនមែន %d ទេ។ នេះគឺចាំបាច់សម្រាប់មុខងារ printf ដើម្បីបង្ហាញលេខធំនៃប្រភេទ long long យ៉ាងត្រឹមត្រូវ។

ភារកិច្ចគ្រប់គ្រងខ្លួនឯង

1. ស្រដៀងគ្នានេះដែរ សូមពិនិត្យមើលការហៀរនៃអថេរនៃប្រភេទ long long ក្នុងឧទាហរណ៍នេះ (ដូចករណីជាមួយអថេរនៃប្រភេទ int)។
2. សាកល្បងប្រើ %d ជំនួសឱ្យ %lld ក្នុងមុខងារ printf ក្នុងឧទាហរណ៍នេះ។

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

# រួមបញ្ចូល int main() (unsigned int x1 = 0; unsigned int x2 = 4294967295; printf("x1 = %u x2 = %u\n" , x1, x2); }

នៅពេលកម្មវិធីនេះត្រូវបានប្រតិបត្តិ ខ្សែអក្សរគួរតែត្រូវបានបោះពុម្ព។

X1 = 0 x2 = 4294967295

ចំណាំថាក្នុងករណីនេះ នៅពេលហៅមុខងារ printf បន្សំតួអក្សរគឺ %u មិនមែន %d ទេ។ នេះគឺចាំបាច់សម្រាប់មុខងារ printf ដើម្បីបង្ហាញលេខត្រឹមត្រូវដែលត្រូវនឹងប្រភេទដែលមិនបានចុះហត្ថលេខា។

ភារកិច្ចគ្រប់គ្រងខ្លួនឯង

1. ស្រដៀងគ្នានេះដែរ សូមពិនិត្យមើលការហូរលើសនៃអថេរនៃប្រភេទ unsigned int ក្នុងឧទាហរណ៍នេះ (ដូចករណីជាមួយអថេរនៃប្រភេទ int)។
2. សាកល្បងប្រើ %d ជំនួសឱ្យ %u ក្នុងមុខងារ printf ក្នុងឧទាហរណ៍នេះ។
3. ដោយផ្អែកលើឧទាហរណ៍នេះ សូមព្យាយាមបង្ហាញតម្លៃអតិបរមាដែលអាចត្រូវបានសរសេរទៅអថេរនៃប្រភេទ unsigned long long (គឺលេខ 18446744073709551615)។ សម្រាប់ការបង្ហាញត្រឹមត្រូវ មុខងារ printf ប្រើបន្សំតួអក្សរ %llu (ជំនួសឱ្យ %u)។

3.4 ចំនួនពិត

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

វាក៏មានប្រភេទទ្វេវែងផងដែរ ហើយអថេរនៃប្រភេទនេះអាចកាន់កាប់ពី 8 ទៅ 16 បៃ អាស្រ័យលើការអនុវត្តកម្មវិធីចងក្រង។ ដូច្នេះ ប្រភេទ​ទ្វេ​ដង​វែង​ច្រើន​តែ​ផ្តល់​ភាព​ជាក់លាក់​កាន់​តែ​ខ្លាំង​ជា​ថ្នូរ​នឹង​ការ​ប្រើ​ប្រាស់​អង្គ​ចងចាំ​កាន់​តែ​ច្រើន។

ចូរយើងពិនិត្យមើលការប្រតិបត្តិនៃកម្មវិធីខាងក្រោម។

# រួមបញ្ចូល int main () ( ទ្វេ x = 10.5; printf("x = %f\n" , x); )

អេក្រង់នឹងបង្ហាញ៖

X = 10.500000

ចំណាំថា %f ត្រូវបានប្រើជំនួសឱ្យ %d ដោយសារតែការប្រើប្រាស់ប្រភេទពិតជំនួសឱ្យចំនួនគត់។ ពិនិត្យមើលថាតើមានអ្វីកើតឡើងប្រសិនបើអ្នកដាក់ %d ជំនួសឱ្យ %f ។

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

Printf("x = %1f \n" ,x);

ក្នុង​ករណី​នេះ លេខ​បន្ទាប់​ពី​ចំនុច​បង្ហាញ​ពី​ចំនួន​ខ្ទង់​បន្ទាប់​ពី​ខ្ទង់​ទសភាគ។ ពិសោធន៍ជាមួយនេះ។

លើសពីនេះទៀត អ្នកអាចកំណត់ចំនួនតួអក្សរដែលប្រើដើម្បីបង្ហាញលេខ ឧទាហរណ៍ អ្នកអាចកំណត់លេខនេះដល់ 10 ដូចខាងក្រោម។

Printf("x = %10.1f \n" ,x);

ពិនិត្យមើលថាតើមានការផ្លាស់ប្តូរអ្វីខ្លះ។

លើសពីនេះទៀតជំនួសឱ្យអក្សរ f ដែលផ្សំជាមួយ % អ្នកអាចប្រើអក្សរ e ដើម្បីបង្ហាញលេខក្នុងទម្រង់អិចស្ប៉ូណង់ស្យែល ក៏ដូចជាអក្សរ g ដើម្បីជ្រើសរើសទម្រង់លទ្ធផលដោយស្វ័យប្រវត្តិអាស្រ័យលើតម្លៃនៃលេខ។ លើសពីនេះ អក្សរ E និង G ក៏អាចប្រើប្រាស់បានដែរ។

ភារកិច្ចគ្រប់គ្រងខ្លួនឯង

1. សាកល្បងបំរែបំរួលផ្សេងៗនៃការសរសេរលេខពិត ហើយមើលថាតើមានអ្វីកើតឡើង (រួមទាំងការប្រើអក្សរ e និង g ជំនួសឱ្យ f រួមផ្សំជាមួយ %) ។
2. កំណត់ដោយខ្លួនឯងថាតើផលវិបាកនៃការប្រើប្រាស់អក្សរ E និង G ត្រូវបានប្រៀបធៀបទៅនឹងអក្សរ e និង g ។
3. អនុវត្តការេ និងគូបនៃចំនួនពិត ធានាថាតម្លៃលទ្ធផលត្រូវបានបង្ហាញនៅលើអេក្រង់។ ជ្រើសរើសទម្រង់លទ្ធផលចំនួនពិតដែលសមស្រប។