C- ն հին ծրագրավորման լեզուներից է: Այն մշակվել է 70-ականներին, բայց այն դեռ շատ հզոր է, քանի որ այն ցածր մակարդակի է: C սովորելը հիանալի միջոց է նաև ձեզ ավելի բարդ լեզուներին ներկայացնելու համար, և ձեր ձեռք բերած գիտելիքները օգտակար կլինեն գրեթե բոլոր ծրագրավորման լեզուներում և կարող են օգնել ձեզ մտնել հավելվածների մշակման մեջ: Սովորելու համար, թե ինչպես սկսել ծրագրավորում C- ով, տե՛ս ստորև բերված Քայլ 1 -ը:
Քայլեր
Մաս 1 -ը 6 -ից. Պատրաստվելը
Քայլ 1. Ներբեռնեք և տեղադրեք կազմող:
C ծածկագիրը պետք է կազմվի ծրագրի կողմից, որը կոդը մեկնաբանում է ազդանշանների համար, որոնք մեքենան կարող է հասկանալ: Կազմողները սովորաբար անվճար են, և տարբեր կոմպիլյատորներ հասանելի են տարբեր օպերացիոն համակարգերի համար:
- Windows- ի համար փորձեք Microsoft Visual Studio Express կամ MinGW:
- Mac- ի համար XCode- ը լավագույն C կազմողներից մեկն է:
- Linux- ի համար gcc- ն ամենահայտնի տարբերակներից մեկն է:
Քայլ 2. Հասկացեք հիմունքները:
C- ն հին ծրագրավորման լեզուներից է և կարող է շատ հզոր լինել: Այն նախատեսված էր Unix օպերացիոն համակարգերի համար, սակայն տեղափոխվել և ընդլայնվել է գրեթե բոլոր օպերացիոն համակարգերի համար: C- ի ժամանակակից տարբերակը C ++ է:
C- ն ըստ էության բաղկացած է գործառույթներից, և այդ գործառույթներում կարող եք օգտագործել փոփոխականներ, պայմանական հայտարարություններ, օղակներ ՝ տվյալները պահելու և շահարկելու համար:
Քայլ 3. Ուսումնասիրեք մի քանի հիմնական ծածկագիր:
Նայեք ստորև ներկայացված (շատ) հիմնական ծրագրին ՝ լավ պատկերացում կազմելու համար, թե ինչպես են լեզվի տարբեր ասպեկտները գործում միասին, և պատկերացում կազմելու, թե ինչպես են գործում ծրագրերը:
#include int main () {printf («Բարև, աշխարհ! / n»); getchar (); վերադարձ 0; }
- #Include հրամանը հայտնվում է ծրագրի մեկնարկից առաջ և բեռնում է ձեզ անհրաժեշտ գործառույթները պարունակող գրադարաններ: Այս օրինակում stdio.h- ն թույլ է տալիս մեզ օգտագործել printf () և getchar () գործառույթները:
- Int main () հրամանը կազմողին ասում է, որ ծրագիրը գործարկում է «հիմնական» կոչվող գործառույթը, և որ այն ավարտելուց հետո ամբողջ թիվը կվերադարձնի: Բոլոր C ծրագրերը կատարում են «հիմնական» գործառույթ:
- {} - ը ցույց է տալիս, որ իրենց ներսում ամեն ինչ գործառույթի մի մասն է: Այս դեպքում նրանք նշում են, որ ներսում ամեն ինչ «հիմնական» գործառույթի մի մասն է:
- Printf () գործառույթը օգտվողի էկրանին ցուցադրում է փակագծերի բովանդակությունը: Մեջբերումները ապահովում են, որ ներսի տողը տպված լինի բառացիորեն: / N հաջորդականությունը հաղորդիչին ասում է, որ կուրսորը տեղափոխի հաջորդ տող:
- The; նշանակում է տողի վերջ: C կոդի տողերի մեծ մասը պետք է ավարտվի ստորակետով:
- Getchar () հրամանը կոմպիլյատորին ասում է, որ նախքան առաջ շարժվելը սպասի ստեղնաշարի մուտքագրմանը: Սա օգտակար է, քանի որ շատ կոմպիլյատորներ կգործարկեն ծրագիրը և անմիջապես կփակեն պատուհանը: Սա պահում է ծրագրի ավարտը մինչև բանալին սեղմելը:
- Վերադարձ 0 հրամանը ցույց է տալիս գործառույթի ավարտը: Ուշադրություն դարձրեք, թե ինչպես է «հիմնական» գործառույթը int գործառույթ: Սա նշանակում է, որ ծրագրի ավարտից հետո վերադարձնելու համար անհրաժեշտ կլինի ամբողջ թիվ: «0» նշանը ցույց է տալիս, որ ծրագիրը ճիշտ է կատարել. ցանկացած այլ թիվ կնշանակի, որ ծրագիրը բախվել է սխալի:
Քայլ 4. Փորձեք կազմել ծրագիրը:
Մուտքագրեք կոդը ձեր կոդի խմբագրիչում և պահեք այն որպես «*.c» ֆայլ: Կազմեք այն ձեր կազմողի մեջ, սովորաբար կտտացնելով Կառուցել կամ գործարկել կոճակին:
Քայլ 5. Միշտ մեկնաբանեք ձեր կոդը:
Մեկնաբանությունները կոդի մի մասն են, որը չի կազմվում, բայց թույլ է տալիս բացատրել, թե ինչ է կատարվում: Սա օգտակար է ինքներդ ձեզ հիշեցնելու համար, թե ինչի համար է ձեր կոդը և այլ ծրագրավորողների օգնելու համար, ովքեր գուցե ձեր կոդին են նայում:
- Մեկնաբանության սկզբում C տեղում / * և * / վերջում մեկնաբանություններ տալու համար:
- Մեկնաբանեք ձեր ծածկագրի բոլոր, բացի ամենահիմնական մասերը:
- Մեկնաբանությունները կարող են օգտագործվել ձեր կոդի մասերը արագ հեռացնելու համար ՝ առանց դրանք ջնջելու: Պարզապես կցեք այն կոդը, որը ցանկանում եք բացառել մեկնաբանության պիտակներով, այնուհետև կազմել: Եթե ցանկանում եք հետ ավելացնել կոդը, հեռացրեք պիտակները:
Մաս 2 -ից 6 -ից. Փոփոխականների օգտագործումը
Քայլ 1. Հասկացեք փոփոխականների գործառույթը:
Փոփոխականները թույլ են տալիս պահպանել տվյալները ՝ ծրագրում կատարվող հաշվարկներից կամ օգտագործողի մուտքագրումից: Փոփոխականները պետք է սահմանվեն, նախքան դրանք օգտագործելը, և ընտրության մի քանի տեսակներ կան:
Առավել տարածված փոփոխականներից մի քանիսը ներառում են int, char և float: Յուրաքանչյուրը պահում է տարբեր տեսակի տվյալներ:
Քայլ 2. Իմացեք, թե ինչպես են հայտարարվում փոփոխականները:
Փոփոխականները պետք է հաստատվեն կամ «հայտարարվեն», նախքան դրանք ծրագրում օգտագործելը: Դուք փոփոխական եք հայտարարում `մուտքագրելով տվյալների տեսակը, որին հաջորդում է փոփոխականի անունը: Օրինակ, ստորև ներկայացված են բոլոր փոփոխական վավեր հայտարարագրերը.
բոց x; char անունը; int a, b, c, d;
- Նկատի ունեցեք, որ միևնույն տողում կարող եք հայտարարել բազմաթիվ փոփոխականներ, եթե դրանք նույն տիպն են: Պարզապես բաժանել փոփոխականների անունները ստորակետներով:
- Ինչպես C- ի շատ տողեր, հայտարարագրման յուրաքանչյուր փոփոխական տող պետք է ավարտվի ստորակետով:
Քայլ 3. Իմացեք, թե որտեղ հայտարարեք փոփոխականներ:
Փոփոխականները պետք է հայտարարվեն յուրաքանչյուր ծածկագրի սկզբում (Ձեր ծածկագրի այն հատվածները, որոնք փակված են {} փակագծերում): Եթե փորձեք փոփոխական հայտարարել բլոկում ավելի ուշ, ծրագիրը ճիշտ չի գործի:
Քայլ 4. Օգտվողի ներածումը պահելու համար օգտագործեք փոփոխականներ:
Այժմ, երբ դուք գիտեք փոփոխականների աշխատանքի հիմունքները, կարող եք գրել մի պարզ ծրագիր, որը կպահպանի օգտվողի մուտքը: Usingրագրում օգտագործելու եք մեկ այլ գործառույթ, որը կոչվում է scanf: Այս գործառույթը որոնում է մուտքագրումը, որը տրամադրվում է որոշակի արժեքների համար:
#ներառել int main () {int x; printf ("Մուտքագրեք համարը."); scanf ("%d", & x); printf ("Դուք մուտքագրեցիք %d", x); getchar (); վերադարձ 0; }
- «%D» տողը scanf- ին ասում է, որ օգտագործողի մուտքագրման մեջ փնտրի ամբողջ թվեր:
- & Փոփոխականից առաջ x- ն ասում է scanf- ին, թե որտեղ պետք է գտնել փոփոխականը `այն փոխելու համար, և ամբողջը պահում է փոփոխականի մեջ:
- Վերջնական printf հրամանը օգտվողին հետ է կարդում մուտքային ամբողջ թիվը:
Քայլ 5. Կառավարեք ձեր փոփոխականները:
Դուք կարող եք օգտագործել մաթեմատիկական արտահայտություններ `ձեր փոփոխականներում պահված տվյալները շահարկելու համար: Մաթեմատիկական արտահայտությունների համար հիշելու ամենակարևոր տարբերությունն այն է, որ մեկ = սահմանում է փոփոխականի արժեքը, մինչդեռ == - ն համեմատում է երկու կողմերի արժեքները `տեսնելու համար, թե արդյոք դրանք հավասար են:
x = 3 * 4; / * սահմանում է «x» - ը 3 * 4 կամ 12 */ x = x + 3; / * ավելացնում է 3 -ը «x» - ի սկզբնական արժեքին, և նոր արժեքը սահմանում է որպես փոփոխական */ x == 15; / * ստուգում է, թե արդյոք «x» - ը հավասար է 15 */ x <10; / * ստուգում է, եթե «x» արժեքը 10 -ից փոքր է//
Մաս 3 -ից 6 -ից. Պայմանական հայտարարությունների օգտագործումը
Քայլ 1. Հասկացեք պայմանական հայտարարությունների հիմունքները:
Պայմանական հայտարարություններն այն են, ինչը մղում է ծրագրերի մեծամասնությանը: Դրանք հայտարարություններ են, որոնք որոշվում են կամ UEԻՇՏ, կամ ՍՈSEՏ, իսկ հետո գործում են արդյունքի հիման վրա: Հայտարարություններից ամենահիմնականը if հայտարարությունն է:
TRՇՄԱՐՏՈ andԹՅՈՆԸ և ՍԱAL -ն տարբեր կերպ են աշխատում C- ում, քան այն, ինչին կարող էիք սովոր լինել: TRUE հայտարարությունները միշտ հավասարվում են ոչ զրոյի թվի: Համեմատություններ կատարելիս, եթե արդյունքը TRՇՄԱՐՏ է, ապա «1» -ը վերադարձվում է: Եթե արդյունքը ԿԵSE Է, ապա «0» -ը վերադարձվում է: Սա հասկանալը կօգնի ձեզ տեսնել, թե ինչպես են մշակվում ԵԹԵ հայտարարությունները:
Քայլ 2. Իմացեք հիմնական պայմանական օպերատորները:
Պայմանական հայտարարությունները պտտվում են արժեքները համեմատող մաթեմատիկական օպերատորների օգտագործման շուրջ: Հետևյալ ցուցակը պարունակում է առավել հաճախ օգտագործվող պայմանական օպերատորներ:
/* ավելի մեծ* /< /* պակաս* /> = /* մեծ կամ հավասար* /<= /* փոքր կամ հավասար* /== /* հավասար* /! = /* ոչ հավասար դեպի */
10> 5 UEՇՄԱՐ 6 <15 UEՇՄԱՐ 8> = 8 UEՇՄԱՐ 4 <= 8 UEՇՄԱՐՏ 3 == 3 UEՇՄԱՐՏ 4! = 5 UEՇՄԱՐՏ
Քայլ 3. Գրեք IF- ի հիմնական հայտարարություն:
Դուք կարող եք օգտագործել IF- ի հայտարարությունները `որոշելու համար, թե ինչ պետք է անի ծրագիրը հայտարարության գնահատումից հետո: Դուք կարող եք այն հետագայում համատեղել այլ պայմանական հայտարարությունների հետ ՝ ստեղծելու հզոր բազմակի տարբերակներ, բայց առայժմ գրեք պարզ ՝ դրանց ընտելանալու համար:
#ներառել int main () {if (3 <5) printf ("3 -ը 5 -ից փոքր է"); getchar (); }
Քայլ 4. Օգտագործեք ELSE/ELSE IF հայտարարությունները `ձեր պայմաններն ընդլայնելու համար:
Դուք կարող եք հիմնվել IF հայտարարությունների վրա ՝ օգտագործելով այլ արդյունքներ և այլ արդյունքներ: ՈSEրիշ հայտարարություններ գործարկվում են, եթե IF հայտարարությունը ԿԵSE Է: ՈSEրիշ ԵԹԵ հայտարարությունները թույլ են տալիս ներառել IF- ի բազմաթիվ հայտարարություններ մեկ կոդի բլոկի մեջ `տարբեր գործեր լուծելու համար: Տեսեք ստորև բերված ծրագրի օրինակը ՝ տեսնելու, թե ինչպես են դրանք փոխազդում:
#include int main () {int age; printf ("Մուտքագրեք ձեր ներկայիս տարիքը."); scanf ("%d", & տարիքը); if (տարիքը <= 12) {printf ("Դուք պարզապես երեխա եք! / n"); } else if (տարիքը <20) {printf ("դեռահաս լինելը բավականին հիանալի է! / n"); } else if (տարիքը <40) {printf ("Դուք դեռ երիտասարդ եք սրտով: / n"); } else {printf ("Տարիքի հետ գալիս է իմաստություն. / n"); } վերադարձ 0; }
Takesրագիրը օգտվողից վերցնում է մուտքագրումը և այն տանում է IF հայտարարությունների միջոցով: Եթե թիվը բավարարում է առաջին հայտարարությանը, ապա առաջին printf հայտարարությունը վերադարձվում է: Եթե այն չի բավարարում առաջին պնդումը, ապա այն վերցվում է ՈSEրիշ ԵԹԵ հայտարարության միջոցով, մինչև չգտնի այն, որն աշխատում է: Եթե դա չի համապատասխանում դրանցից որևէ մեկին, ապա վերջում անցնում է ELSE հայտարարությունը:
Մաս 4 -ից 6 -ից. Ուսուցման օղակներ
Քայլ 1. Հասկացեք, թե ինչպես են աշխատում օղակները:
Օղակները ծրագրավորման ամենակարևոր ասպեկտներից են, քանի որ դրանք թույլ են տալիս կրկնել կոդերի բլոկները մինչև որոշակի պայմանների կատարումը: Սա կարող է շատ հեշտությամբ կրկնել գործողությունները, և ձեզ հետ է պահում ամեն անգամ, երբ ցանկանում եք, որ ինչ -որ բան պատահի, նոր պայմանական հայտարարություններ չգրեք:
Օղակների երեք հիմնական տեսակ կա ՝ FOR, WHILE և DO… WHILE:
Քայլ 2. Օգտագործեք FOR հանգույց:
Սա ամենատարածված և օգտակար հանգույցի տեսակն է: Այն կշարունակի գործարկել գործառույթը մինչև FOR հանգույցում սահմանված պայմանների կատարումը: FOR loops- ի համար պահանջվում է երեք պայման ՝ փոփոխականի նախաստորագրում, պայմանի բավարարում և փոփոխականի թարմացման եղանակ: Եթե ձեզ անհրաժեշտ չեն այս բոլոր պայմանները, ապա ձեզ դեռ պետք է դատարկ տարածք թողնել ստորակետով, հակառակ դեպքում հանգույցը հավերժ կգործի:
#ներառել int main () {int y; համար (y = 0; y <15; y ++;) {printf ("%d / n", y); } getchar (); }
Վերոնշյալ ծրագրում y- ը սահմանվում է 0, և օղակը շարունակվում է այնքան ժամանակ, քանի դեռ y արժեքը 15 -ից փոքր է: Ամեն անգամ, երբ y արժեքը տպվում է, y- ին ավելանում է 1 -ը, և օղակը կրկնվում է: Երբ y = 15, օղակը կկոտրվի:
Քայլ 3. Օգտագործեք WHILE հանգույց:
WHOLE loops- ն ավելի պարզ է, քան FOR loops- ը: Նրանք ունեն միայն մեկ պայման, և օղակը գործում է այնքան ժամանակ, քանի դեռ այդ պայմանը ճշմարիտ է: Անհրաժեշտ չէ փոփոխականը նախաստորագրել կամ թարմացնել, չնայած դա կարող եք անել հանգույցի հիմնական մարմնում:
#ներառել int main () {int y; while (y <= 15) {printf ("%d / n", y); y ++; } getchar (); }
Y ++ հրամանը y- ի փոփոխականին ավելացնում է ամեն անգամ, երբ օղակը կատարվում է: Երբ y- ը հարվածում է 16 -ին (հիշեք, որ այս օղակը շարունակվում է այնքան ժամանակ, քանի դեռ y- ը 15 -ից փոքր կամ հավասար է), օղակը ճեղքվում է:
Քայլ 4. Օգտագործեք DO:
.. WHILE հանգույց:
Այս հանգույցը շատ օգտակար է այն օղակների համար, որոնք ցանկանում եք ապահովել առնվազն մեկ անգամ գործարկումը: FOR և WHILE օղակներում վիճակը ստուգվում է օղակի սկզբում, ինչը նշանակում է, որ այն չի կարող անցնել և անմիջապես ձախողվել: ԱՆԵԼ… WHILE loops- ը ստուգում է օղակի վերջի պայմանները ՝ ապահովելով, որ loop- ը կատարվի առնվազն մեկ անգամ:
#ներառել int main () {int y; y = 5; անել {printf ("Այս օղակն աշխատում է! / n"); } while (y! = 5); getchar (); }
- Այս հանգույցը կցուցադրի հաղորդագրությունը, չնայած որ պայմանը ԿԱԼՍ է: Y փոփոխականը սահմանվում է 5 և WHILE հանգույցը գործարկվում է, երբ y- ը հավասար չէ 5 -ի, ուստի օղակը դադարում է: Հաղորդագրությունն արդեն տպագրված էր, քանի որ վիճակը մինչև վերջ չի ստուգվում:
- WHILE հանգույցը DO… WHILE հավաքածուն պետք է ավարտվի ստորակետով: Սա միակ դեպքն է, երբ օղակն ավարտվում է ստորակետով:
Մաս 5 -ից 6 -ից. Գործառույթների օգտագործումը
Քայլ 1. Հասկացեք գործառույթների հիմունքները:
Գործառույթները ինքնուրույն կոդերի բլոկներ են, որոնք կարող են կոչվել ծրագրի այլ մասերի կողմից: Նրանք շատ դյուրին են դարձնում ծածկագիրը կրկնելը, և օգնում են ծրագիրը դարձնել ավելի պարզ ՝ կարդալու և փոխելու համար: Գործառույթները կարող են ներառել այս հոդվածում սովորած նախկինում ընդգրկված բոլոր տեխնիկան և նույնիսկ այլ գործառույթներ:
- Վերոնշյալ բոլոր օրինակների սկզբում հիմնական () տողը գործառույթ է, ինչպես և getchar ()
- Գործառույթներն էական են արդյունավետ և հեշտ ընթերցվող կոդի համար: Լավ օգտագործեք գործառույթները `ձեր ծրագիրը պարզեցնելու համար:
Քայլ 2. Սկսեք ուրվագծից:
Գործառույթները լավագույնս ստեղծվում են, երբ նախանշում եք այն, ինչ ցանկանում եք, որ այն իրականացնի նախքան իրական կոդավորումը սկսելը: Ֆունկցիաների հիմնական շարահյուսությունն է «return_type name (argument1, argument2 և այլն);»: Օրինակ ՝ երկու թիվ գումարող գործառույթ ստեղծելու համար.
int ավելացնել (int x, int y);
Սա կստեղծի գործառույթ, որն ավելացնում է երկու ամբողջ թիվ (x և y), իսկ հետո գումարը վերադարձնում է որպես ամբողջ թիվ:
Քայլ 3. Ֆունկցիան ավելացրեք ծրագրին:
Կարող եք օգտագործել ուրվագիծը ՝ ստեղծելու ծրագիր, որը տևում է երկու ամբողջ թիվ, որը մուտքագրում է օգտագործողը, այնուհետև դրանք ավելացնում միասին: Րագիրը սահմանելու է, թե ինչպես է աշխատում «ավելացնել» գործառույթը և այն օգտագործելու է մուտքագրված թվերը շահարկելու համար:
#ներառել int ավելացնել (int x, int y); int main () {int x; int y; printf ("Մուտքագրեք երկու թիվ ՝ միասին գումարելու համար"); scanf ("%d", & x); scanf ("%d", & y); printf ("Ձեր թվերի գումարը կազմում է %d / n", ավելացնել (x, y)); getchar (); } int ավելացնել (int x, int y) {վերադարձ x + y; }
- Նշենք, որ ուրվագիծը դեռ գտնվում է ծրագրի վերևում: Սա կոմպիլյատորին ասում է, թե ինչ ակնկալել, երբ գործառույթը կանչվի և ինչ կվերադառնա: Սա անհրաժեշտ է միայն այն դեպքում, եթե ցանկանում եք ֆունկցիան սահմանել ծրագրում ավելի ուշ: Դուք կարող եք ավելացնել () ավելացնել հիմնական () գործառույթից առաջ, և արդյունքը նույնը կլինի առանց ուրվագծի:
- Գործառույթի իրական ֆունկցիոնալությունը սահմանվում է ծրագրի ներքևում: Հիմնական () ֆունկցիան օգտվողից հավաքում է ամբողջ թվերը, այնուհետև դրանք ուղարկում է մշակման ենթակա add () գործառույթին: Ավելացնել () գործառույթը այնուհետև արդյունքները վերադարձնում է հիմնականին ()
- Այժմ հավելումը () սահմանվել է, այն կարող է կոչվել ծրագրի ցանկացած վայրում:
Մաս 6 -ից 6 -ից ՝ Շարունակելով սովորել
Քայլ 1. Գտեք C ծրագրավորման մի քանի գիրք:
Այս հոդվածը ներառում է հիմունքները, բայց այն միայն քորում է C ծրագրավորման մակերեսը և դրա հետ կապված բոլոր գիտելիքները: Լավ տեղեկատու գիրքը կօգնի ձեզ լուծել խնդիրները և ձեզ կփրկի ճանապարհի բազմաթիվ գլխացավերից:
Քայլ 2. Միացեք որոշ համայնքների:
Կան բազմաթիվ համայնքներ, ինչպես առցանց, այնպես էլ իրական աշխարհում, որոնք նվիրված են ծրագրավորմանը և դրա ենթակա բոլոր լեզուներին: Գտեք որոշ համախոհ C ծրագրավորողներ, որոնց հետ կարող եք փոխանակել կոդը և գաղափարները, և շուտով դուք ինքներդ ձեզ շատ բան կսովորեք:
Հնարավորության դեպքում հաճախեք մի քանի hack-a-thons: Սրանք իրադարձություններ են, որտեղ թիմերն ու անհատները ժամանակային սահմանափակումներ ունեն ծրագրեր և լուծումներ մշակելու համար, և հաճախ մեծ ստեղծագործական ունակություններ են ստեղծում: Այս կերպ կարող եք հանդիպել շատ լավ ծրագրավորողների, և hack-a-thons- ը պարբերաբար տեղի է ունենում ամբողջ աշխարհում:
Քայլ 3. Վերցրեք մի քանի դասարան:
Պետք չէ դպրոց վերադառնալ համակարգչային գիտության աստիճանի համար, բայց մի քանի դասեր վերցնելը կարող է հրաշքներ գործել ձեր սովորելու համար: Ոչինչ չի գերազանցում լեզվին լավ տիրապետող մարդկանց գործնական օգնությանը: Դուք հաճախ կարող եք դասեր գտնել տեղական համայնքային կենտրոններում և կրտսեր քոլեջներում, և որոշ համալսարաններ թույլ կտան ձեզ ստուգել իրենց համակարգչային գիտության ծրագրերը ՝ առանց գրանցվելու:
Քայլ 4. Մտածեք C ++ սովորելու մասին:
Երբ դուք տիրապետում եք C- ին, վնաս չի պատճառի սկսել C ++ - ի հայացքը: Սա C- ի առավել ժամանակակից տարբերակն է և թույլ է տալիս շատ ավելի ճկունություն ապահովել: C ++ - ը նախագծված է ՝ հաշվի առնելով օբյեկտների կառավարումը, և C ++ - ի իմացությունը կարող է հնարավորություն տալ ձեզ ստեղծել հզոր ծրագրեր գործնականում ցանկացած օպերացիոն համակարգի համար:
Խորհուրդներ
- Միշտ մեկնաբանություններ ավելացրեք ձեր ծրագրերին: Սա ոչ միայն օգնում է ուրիշներին, ովքեր կարող են նայել դրա սկզբնաղբյուրին, այլև օգնում է ձեզ հիշել, թե ինչ եք գրում և ինչու: Դուք կարող եք իմանալ, թե ինչ եք անում այն պահին, երբ գրում եք ձեր կոդը, բայց երկու -երեք ամիս անց շատ բան չեք հիշի:
- Միշտ հիշեք, որ այնպիսի հայտարարություն, ինչպիսին printf (), scanf (), getch () և այլն, վերջացրեք կիսակետով;.
- Կազմելիս շարահյուսական սխալի հանդիպելիս, եթե խաբված եք, որոնեք Google- ում (կամ մեկ այլ որոնիչում) ստացված սխալով: Հավանական է, որ ինչ -որ մեկն արդեն հանդիպել է նույն խնդրին և տեղադրել լուծում:
- Ձեր աղբյուրի կոդը պետք է ունենա *.c ընդլայնում, որպեսզի ձեր կոմպիլյատորը հասկանա, որ դա C աղբյուր ֆայլ է:
- Միշտ հիշեք, որ պրակտիկան կատարյալ է դարձնում: Որքան շատ եք զբաղվում ծրագիր գրելիս, այնքան ավելի լավ եք դրան հասնում: Այսպիսով, սկսեք պարզ, կարճ ծրագրերից մինչև ձեր դիրքերը ամրացնելը, իսկ հետո վստահ լինելուց հետո կարող եք անցնել ավելի բարդին:
- Փորձեք սովորել տրամաբանական կառուցվածք: Այն օգնում է լուծել տարբեր խնդիրներ ՝ ծածկագիր գրելիս:
