C++: Առաջին ծրագիրը մեկնաբանություններով

C++ ծրագրավորման լեզվի ուսումնասիրությունը սկսենք մի կարճ ծրագրից, որը պետք է ստանդարտ արտածման հոսքին դուրս բերի «Ողջո՜ւյն, այդ ես եմ, քո առաջին ծրագիրը։» տողը։

Գործարկենք տեքստային խմբագրիչը և նրա օգնությամբ ստեղծենք ex01.cpp ֆայլը՝ հետևյալ պարունակությամբ․

// Առաջին C++ ծրագիրը
#include <iostream>

int main()
{
    std::cout << "Ողջո՜ւյն, այդ ես եմ, քո առաջին ծրագիրը:\n";
}

Շրագրի տեքստը ֆայլու գրառելուց հետո այն պետք է կոմպիլյատորի օգնությամբ թարգմանել մեքենայական հրամանների և կատարել։ Բայց մի փոքր առաջ անցնենք ու ծրագրի ամեն մի տողի համար տանք համառոտ մեկնաբանություն։

Առաջին տողը «//» նիշերով սկսվող և մինչև տողի վերջը շարունակվող մեկնաբանություն է։ Մեկնաբանությունները, որոնք կարող են պարունակել կամայական տեքստ, ծրագրի իմաստի վրա չեն ազդում և ամբողջովին անտեսվում են կոմպիլյատորի կողմից։ Դրանց նպատակն է ծրագում բացատրություններ թողնել մարդու համար։

Երկրորդ տողում գրված #include հրահանգը նախապրոցեսորից պահանջում է ծրագրին կցենլ iostream գրադարանային ֆայլը։ Այս ֆայլում են սահմանված ստանդարտ ներմուծման ու արտածման հոսքերի հետ աշխատող գործողություններն ու օբյեկտները։ Ի թիվս զանազան ֆունկցիաների ու օբյեկտների, iostream ֆայլը պարունակում է ստանդարտ արտածման հոսքի հետ կապված cout օբյեկտը և իր աջ արգումենտը ձախ արգումենտի մեջ գրող << գործողությունը։

C++ լեզվով գրված ամեն մի ծրագիր պետք է պարունակի main անունով միակ ֆունկցիա։ Այս ֆունկցիան հանդիսանում է ծրագրի մուտքի կետը, այսինքն՝ ծրագրիրը սկսում է կատարվել main ֆունկցիայից։ Ավելի պատկերավոր ասած՝ ծրագիրը կատարելու համար օպերացիոն համակարգը կանչում է main ֆունկցիան։ Տվյալ դեպքում main ֆունկցիան արգումենտներ չի սպասում և վերադարձնում է int (integer, ամբողջ թիվ) տիպի արժեք։ Օպերացիոն համակարգն այս ֆունկցիայի արժեքը մեկնաբանում է որպես ծրագրի հաջող կամ անհաջող ավարտի ազդանշան։ Ըստ պայմանավորվածության, 0 արժեքը համարվում է հաջող ավարտ, իսկ 0-ից տարբեր դրական ամբողջ թվերը՝ անհաջող ավարտ։ C++ ֆունկցիայից որևէ արժեք է վերադարձվում է return հրամանով։ Սակայն միայն main ֆունկցիայի համար կա բացառություն, որ, եթե բացահայտորեն նշված չէ return հրամանը, ապա վերադարձվող արժեքը համարվում է 0։

main ֆունկցիայի մարմինը, որ պարփակված է «{» և «}» փակագծերի մեջ, պարունակում է միակ արտահայտություն, որտեղ << գործողության օգնությամբ «Ողջո՜ւյն, աշխարհ։» տողն ուղարկվում է ստանդարտ արտածման հոսքի հետ կապված cout (cconsole output) օբյեկտին։ cout անունից առաջ գրված std:: նախդիրը ցույց է տալիս, որ այդ երկու անունները պատկանում են լեզվի Կաղապարների ստանդարտ գրադարանին (Standard template library, STL)։

Պետք է հիշել, որ cout-ը C++ լեզվի ծառայողական բառ չէ։ Այն ընդամենը iostream գրադարանում հայտարարված ավտոմատ օբյեկտ է։

Հիմա այս ծրագիրը թարգմանենք (կոմպիլյացնենք) մեքենայական կոդի և աշխատեցնենք։ C++ լեզվով գրված ծրագրերը թարգմանության ժամանակ անցնում է երեք հիմնական փուլ. i) նախնական մշակում - preprocessing -- այս փուլում մշակվում են # նիշով սկսվող հրահանգները, որոնք ծրագրի տեքստի հետ կատարվում են զուտ տեքստային գործողություններ։ Օրինակմ ֆայլերի կցում, անունների փոփոխում արժեքներով և այլն, ii) թարգմանություն - compilation -- այս փուլում ծրագրավորողի գրած տեքստը թարգմանվում է մեքենայական կոդի և ստեղծվում են այսպես կոչված օբյեկտային ֆայլեր, iii) կապակցում - linking -- այս փուլում նոր ստեղծված օբյեկտային ֆայլերը կապակցվում են գրադարանային (կամ այլ) օբյեկտային ֆայլերի հետ և ստեղծվում է կատարվող մոդուլ։

Սովորաբար ծրագրի տեքստից կատարվող մոդուլի ստացման այս երեք փուլերը թաքնված են օգտագործողից և, պարզ ծրագերի դեպքում, կատարվում են մեկ հրամանով։ Օրինակ, Bash ինտերպրետատորի հրամանային տողում ներմուծենք հետևյալը, որտեղ -std=c++11 պարամետրով կոմպիլյատորից պահանջում ենք միացնել C++11 ստանդարտի հատկությունները.

$ g++ -std=c++11 ex01.cpp

կամ, եթե ուզում ենք օգտագործել clang++ կոմպիլյատորը, ապա.

$ clang++ -std=c++11 ex01.cpp

Եթե կոմպիլյատորը որևէ սխալ չի հայտնաբերել, ապա ընթացիկ պանակում ստեղծվում է a.out անունով կատարվող մոդուլը։ Երբ հարկավոր է կատարվող մոդուլին այլ անուն տալ, ապա կարող ենք օգտագործել կոմպիլյատորի -o պարամետրը։ Օրինակ.

$ clang++ -std=c++11 -o ex01 ex01.cpp

այս հրամանի կատարման արդյունքում կատարվող մոդուլը a.out-ի փոխարեն կունենա ex01 անունը։

ex01 մոդուլն աշխատեցնելու համար պետք է Bash—ի հրամանային տողում ներմուծել.

$ ./ex01
Ողջո՜ւյն, աշխարհ։

Ծրագրի կատարման արդյունքում տեսնում ենք արտածված տողը. սա հենց այն է, ինչ ակնկալում էինք առաջին ծրագրից։

Որպեսզի համոզվենք, որ իսկապես main ֆունկցիայի վերադարձրած արժեքը փոխանցվում է օպերացիոն համակարգին, կարող ենք ծրագրի կատարումից հետո Bash ինտերպրետատորի echo հրամանով դուրս բերել $? փսևդոփոփոխականի արժեքը։

$ echo $?
0

Հիմա վերը բերված օրինակի ex01.cpp ֆայլը պատճենենք ex02.cpp անունով, և main ֆունկցիայի մարմինն ավարտող «}» փակագծից առաջ ավելացնենք «return 0;» հրամանը։

#include 

int main()
{
    std::cout << "Ողջո՜ւյն, աշխարհ։" << std::endl;
    return 7;
}

Ապա նորից կոմպիլյացնենք ծրագիրը, աշխատեցնենք ու արտածենք $? փսևդոփոփոխականի արժեքը։ Հրամանների հաջորդականությունը և արտածված արդյունքները հետևյալ տեսքն ունեն.

$ g++ -std=c++11 -o ex02 ex02.cpp
$ ./ex02
Ողջո՜ւյն, աշխարհ։
$ echo $?
7