Զրույց առաջին

Մի հայտնի ու իմաստուն գրքում (K&R) ասվում է, որ ծրագրավորման լեզուն սովորելու ամենալավ եղանակը դրանով ծրագրեր գրելն է։ Ես հետևում եմ այդ խորհրդին ու այս զրույցում ներկայացնում եմ C ծրագրավորման լեզվով գրված առաջին ծրագիրը։ Այն պետք է ստանդարտ արտածման հոսքին դուրս բերի երկու տող՝ «Ողջո՛ւյն։» և «Այդ ես եմ՝ քո առաջին C ծրագիրը։»։

Ծրագրավորողի տեսակետից մեկ առանձին ծրագրի հետ աշխատանքը բաղկացած է հետևյալ հիմնական քայլերից․

Ծրագրի տեքստի խմբագրում (editing) ― մի որևէ տեքստային խմբագրիչով, կամ ծրագրերի մշակման ինտեգրացված միջավայրում ստեղծվում է ծրագրի տեքստը և պահպանվում է ֆայլի մեջ։ C լեզվով գրված ծրագրերը հիմնականում ունենում են .c վերջավորություն։

Կոմպիլյացիա (compilation) ― թարգմանող ծրագրի՝ կոմպիլյատորի միջոցով ծրագրի տեքստային ներկայացումից կառուցվում է կոնկտրետ ապարատային պլատֆորմի վրա և կոնկրետ օպերացիոն համակարգում աշխատող մեքենայակ կոդը պարունակող կատարվող մոդուլը (բինար ֆայլ)։

Կատարում (execution) ― օպերացիոն համակարգը կատորվող մոդուլը բեռնում է մեքենայի հիշողության մեջ և սկսում է կատարել այն։

Շտկում (debugging) ― եթե կոմպիլյացիայի կամ կատարման քայլերում ծրագրում հայտնաբերվել են լեքսիկական, շարակյուսական կամ տրամաբանական սխալներ, ապա շտկումներ են կատարվում ծրագրի տեքստում և այս քայլերը նորից կրկնվում են անհրաժեշտ հաջորդականությամբ։

Տեքստային խմբագրիչում ներմուծում եմ հետևյալ տեքստը և այն պահպանում եմ prog01.c անունով ֆայլում։

/* Առաջին ծրագիրը */
#include <stdio.h>
int main()
{
    puts( "Ողջո՜ւյն։" );
    puts( "Այդ ե՛ս եմ՝ քո առաջին C ծրագիրը։" );
    return 0;
}

Առաջին տողում գրված /* նիշերով սկսվող և */ նիշերով ավարտվող տեքստը մեկնաբանություն է։ Մեկնաբանությունները նախատեսված են մարդկանց համար․ դրանք ամբողջությամբ անտեսվում են կոմպիլյատորի կողմից։

Երկրորդ տողի #include <stdio.h> արտահայտությունը պահանջում է կոմպիլյացիայից առաջ prog01.c ֆայլին կցել գրադարանային stdio.h ֆայլը։ Այն պարունակում է տվյալների ներմուծման ու արտածման համար նախատեսված ստանդարտ ֆունկցիաների, կառուցվածքների և այլ ծրագրային բաղադրիչների հայտարարությունները։

Երրորդ տողում գրված է C ծրագրերի մուտքի կետ հանդիսացող main ֆունկցիայի վերնագիրը։ Տվյալ դեպքում main ֆունկցիան արգումենտներ չի սպասում՝ նրա արգումենտների ցուցակը դատարկ է, բայց վերադարձնում է int (ամբողջ թիվ) տիպի արժեք։ C լեզվով գրված բոլոր ծրագրիերն իրենց աշխատանքը սկսում են հենց main ֆունկցիայից։ Ավելի պատկերավոր ասած՝ main ֆունկցիան կանչվում է օպերացիոն համակարգի կողմից, իսկ նրա վերադարձրած արժեքը օպերացիոն համակարգը մեկնաբանում է որպես կատարվող ծրագրի հաջող կամ անհաջող ավարտի հայտանիշ։ Պայմանավորվածություն կա, որ 0 արժեք են վերադարձնում հաջող ավարտված ծրագրերը, իսկ զրոյից տարբեր արժեք՝ անհաջող ավարտվածները։

C ֆունկցիայի մարմինը՝ այն հրամանների հաջորդականությունը, որոնցով որոշվում է ֆունկցիայի վարքը, պարփակված է { և } փակագծերի մեջ։ Իմ այս օրինակի չորրորդ տողում սկսվում է և ութերորդ տողում ավարտվում է main ֆունկցիայի մարմինը։

Հինգերորդ և վեցերորդ տողերում օգտագործված է stdio (standard input-output) գրադարանի puts (put string - արտածել տողը) ֆունկցիան։ Այս ֆունկցիան արգումենտում ստանում է նիշերի տող և այդ տողն արտածում է stdout ստանդարտ արտածման հոսքին։

Վեցերորդ տողում օգտագործված return հրամանը նախատեսված է ֆունկցիայից արժեք վերադարձնելու համար (սրա մասին դեռ շատ կխոսեմ)։ Այստեղ return հրամանով main ֆունկցիան վերադարձնում է 0 արժեքը, որը ցուց է տալիս ծրագրի՝ այդ կետում հաջող ավարտված լինելը։

Հիմա, երբ մեկնաբանված է ծրագրի տեքստի ամեն մի տողը, պետք է կոմպիլյատորի օգնությամբ թարգմանել այն և ստանալ կատարվող ֆայլ։ Արդեն նշել եմ, որ օգտագործելու եմ C լեզվի երկու կոմպիլյատորներ՝ clang-ը և gcc-ն։ Այդ ծրագրերը, իրենց օժանդակ գործիքների հետ միասին, իմ GNU/Linux համակարգում տեղադրել եմ հետևյալ հրամաններով.

$ sudo apt-get install clang
$ sudo apt-get install gcc

Ծրագիրը պարունակող prog01.c ֆայլը (source file) թարգմանում եմ այսպես.

$ clang prog01.c -o prog01

Որտեղ կոմպիլյատորին տրվող -o պարամետրի արգումենտով որոշվում է ստեղծվելիք կատարվող (executable) մոդուլի անունը։ Եթե -o պարամետրը տրված չէ, ապա կոմպիլյատորը կստեղծի a.out անունով կատարվող ֆայլ։

Եթե ծրագրի տեքստը սխալներ չի պարունակում, և կոմպիլյացիան հաջող է անցնում, ապա ստեղծվում է prog01 կատարվող մոդուլը։ Այն աշխատեցնելու համար պարզապես պետք է Bash-ի հրամանային տողից գործարկել ինչպես որևէ այլ ծրագիր.

$ ./prog01
Ողջո՛ւյն։
Այդ ես եմ՝ քո առաջին C ծրագիրը։

Հիմա եթե prog01 կատարվող ֆայլն աշխատեցնելուց հետո Bash-ի echo հրամանով արտածենք $? փոևդոփոփոխականը, որը պարունակում է վերջին աշխատած ծրագիր ավարտի կոդը, ապա կստանանք 0 արժեքը։ Այս 0-ն հենց իմ ծրագրի main ֆունկցիայից return հրամանով վերադարձրած արժեքն է։

$ echo $?
0

Առաջին զրույցի համար, թերևս, այսքանը։ Մեկ անգամ ևս անցեք ծրագրի տեքստով և համոզվեք, որ հասկացել եք յուրաքանչյուր տողի նշանակությունը։ Հետաքրքրության համար կարող եք նաև ինչ-որ փոփոխություններ անել ծրագրում և տեսնել, թե ինչպես է կոմպիլյատորն արձագանքում դրանց։

Հաջորդ զրույցում կպատմեմ փոփոխականների հայտարարման և ստեղնաշարից տվյալների ներածման մասին։

Վարժություն

1. prog01.c ծրագրում գրված return հրամանի արգումենտում 0-ի փոխարեն դնել մի այլ արժեք, ապա կոմպիլյացնել և կատարել։ Կատարելուց հետո ստուգել, թե ինչ արժեք է պարունակում Bash-ի $? փսևդոփոփոխականը։