Բովանդակություն

• Քայլեր
• Մաս 1 -ից 6 -ից. Նախապատրաստում
• Մաս 2 -ից 6 -ից. Փոփոխականների օգտագործումը
• Մաս 3 -ից 6 -ից. Պայմանների ստեղծում
• Մաս 4 -ից 6 -ից. Սովորում ենք աշխատել օղակների հետ
• Մաս 5 -ից 6 -ից. Գործառույթների օգտագործումը
• Մաս 6 -ից 6 -ը ՝ Լեզվի հետագա ուսուցում
• Խորհուրդներ

C լեզուն ծրագրավորման ամենահին լեզուներից է: Այն մշակվել է անցյալ դարի 70-ական թվականներին, բայց այն դեռ բավականին հզոր է այն բանի շնորհիվ, որ պատկանում է ցածր մակարդակի ծրագրավորման գործիքներին, որոնք իմաստալից հապավումներ են օգտագործում տարբեր հրամանների համար: C լեզուն սովորելը նաև հիանալի հիմք է ավելի բարդ լեզուների անցնելու համար, և այստեղ ձեռք բերված գիտելիքները օգտակար կլինեն գրեթե բոլոր ծրագրավորման լեզուներում և կօգնեն ներգրավվել անկախ ծրագրերի մշակման մեջ: Այս լեզուն սովորելու համար կարդացեք այս հոդվածի տեղեկատվությունը:

Քայլեր

Մաս 1 -ից 6 -ից. Նախապատրաստում

1. 1 Ներբեռնեք և տեղադրեք կազմողը: C լեզուն պետք է կազմվի այնպիսի ծրագրով, որը լեզվի ծածկագիրը կվերածի մեքենայական ազդանշանների: Կազմողները սովորաբար անվճար են և հասանելի են տարբեր օպերացիոն համակարգերի համար:
   • Windows- ի համար փորձեք օգտագործել Microsoft Visual Studio Express կամ MinGW:
   • Mac- ի համար Xcode- ը համարվում է լավագույն կազմողներից մեկը:
   • Linux- ի համար GCC- ն ամենահայտնին է:
2. 2 Իմացեք հիմունքները: C լեզուն ծրագրավորման ամենահին և ամենահզոր լեզուներից է: Այն նախատեսված էր Unix օպերացիոն համակարգի համար, սակայն ընդլայնվել և տեղափոխվել է գրեթե բոլոր օպերացիոն համակարգերին: C- ի ժամանակակից մարմնավորումը C ++ է:
   • C լեզուն հիմնականում բաղկացած է գործառույթներից, և այդ գործառույթներում կարող եք օգտագործել փոփոխականներ, պայմաններ և օղակներ ՝ տեղեկատվություն պահելու և տվյալները շահարկելու համար:
3. 3 Ստուգեք ամենապարզ ծածկագիրը: Նայեք ստորև բերված ամենապարզ ծրագրի ծածկագրին ՝ տեսնելու համար, թե ինչպես է լեզվի որոշ բաղադրիչներ փոխազդում միմյանց հետ և հասկանալու, թե ինչպես է գործում ծրագիրը:

   #include stdio.h> int main () {printf ("Բարև աշխարհ n"); getchar (); վերադարձ 0; }

   • Թիմ #ներառում աշխատում է նույնիսկ ծրագրի մեկնարկից առաջ և գործարկում է գրադարաններ, որոնք պարունակում են ձեզ անհրաժեշտ գործառույթները: Վերոնշյալ օրինակում ստդիո.հ թույլ է տալիս օգտագործել գործառույթները ծրագրում printf () եւ getchar ().
   • Թիմ int հիմնական () հրամայում է կոմպիլյատորին գործարկել «հիմնական» հիմնական գործառույթը, որն ավարտելուց հետո կվերադարձնի կոնկրետ ամբողջ թիվ: Բոլոր C ծրագրերը օգտագործում են «հիմնական» գործառույթը:
   • Բրեկետներ {} ասել, որ դրանց ամբողջ բովանդակությունը գործառույթի մի մասն է: Այս դեպքում նրանք նշանակում են, որ փակագծերի բովանդակությունը «հիմնական» գործառույթի մի մասն է:
   • Գործառույթը printf () օգտվողի էկրանին ցուցադրում է փակագծերի բովանդակությունը: Մեջբերումները ապահովում են, որ փակագծերի բովանդակությունը դիտարկվեն որպես տեքստ: Վերահսկիչ հաջորդականություն n համակարգչին ասում է, որ կուրսորը տեղափոխի հաջորդ տող:
   • Կիսակետ ; նշում է տողի վերջը: C կոդի տողերի մեծ մասը պետք է ավարտվի այս նշանով:
   • Թիմ getchar () ասում է համակարգչին սպասել կոճակի սեղմմանը, նախքան որևէ այլ բան անելը: Սա շատ օգտակար է, քանի որ շատ օպերացիոն համակարգեր կատարում են ծրագիրը, իսկ հետո անմիջապես փակում պատուհանը: Այս դեպքում ծրագիրը չի ավարտվում մինչև կոճակը սեղմելը:
   • Թիմ վերադարձ 0 ցույց է տալիս ծրագրի ավարտը: Խնդրում ենք նկատի ունենալ, որ «հիմնական» գործառույթը վերաբերում է գործառույթներին ներ... Սա նշանակում է, որ այն պետք է վերադարձնի որոշակի արժեք ծրագրի ավարտից հետո: Eroրոյական «0» նշանակում է ճիշտ կատարված ծրագիր, իսկ ցանկացած այլ թիվ ՝ սխալ:
4. 4 Փորձեք կազմել ծրագիրը: Մուտքագրեք ձեր կոդը կոդի խմբագրիչում և պահեք այն որպես « *. C» ֆայլ: Կազմեք այն կազմողի հետ: Սովորաբար դա պահանջում է սեղմել «Կառուցել» կամ «Գործարկել» կոճակը:
5. 5 Համոզվեք, որ մեկնաբանեք ստեղծված կոդը: Մեկնաբանությունները կոդի մի մասն են, որը կազմված չէ, բայց թույլ է տալիս բացատրել, թե կոնկրետ ինչ է կատարվում ծրագրում: Նրանք օգտակար են ինքներդ ձեզ հիշեցնելու համար կոդի նպատակը և բացատրելու, թե ինչպես է այն աշխատում այլ մշակողների համար, ովքեր կարող են ուսումնասիրել ծածկագիրը:
   • C- ով մեկնաբանություն գրելու համար օգտագործեք աստղանիշով առաջի շեղ /* բացատրական տեքստի սկզբում և աստղանիշ ՝ առջևի շեղ գծով */ դրա վերջում:
   • Մեկնաբանեք ձեր ծածկագրի բոլոր հիմնական մասերը:
   • Մեկնաբանությունները կարող են օգտագործվել կոդի որոշ հատվածներ աշխատանքից արագ հեռացնելու համար ՝ առանց դրանք հեռացնելու: Պարզապես մեկնաբանության մեջ դրեք այն կոդը, որը ցանկանում եք անջատել և կազմեք ծրագիրը: Եթե ​​ցանկանում եք վերադարձնել կոդը, պարզապես հեռացրեք մեկնաբանությունների պիտակները:

Մաս 2 -ից 6 -ից. Փոփոխականների օգտագործումը

1. 1 Հասկացեք, թե ինչպես են աշխատում փոփոխականները: Փոփոխականները թույլ են տալիս հավաքել և պահպանել հաշվարկների արդյունքում ստացված տվյալները բուն ծրագրում կամ օգտագործողի մուտքագրման միջոցով: Փոփոխականներն օգտագործելուց առաջ պետք է նշվեն: Դա կարելի է անել տարբեր եղանակներով:
   • Առավել հաճախ օգտագործվող փոփոխականների թվում են փոփոխականները ներ, ածխ եւ բոց... Նրանցից յուրաքանչյուրը պահում է տարբեր տեսակի տվյալներ:
2. 2 Իմացեք, թե ինչպես են փոփոխականները հայտարարվում ձեր ծրագրում: Փոփոխականները պետք է նշանակվեն կամ «հայտարարվեն», նախքան դրանք ծրագրում օգտագործելը: Դուք կարող եք փոփոխական հայտարարել ՝ նշելով օգտագործված տվյալների տեսակը և փոփոխականի անունը: Օրինակ, հետևյալ բոլոր օրինակները վավեր են.

   բոց x; char անունը; int a, b, c, d;

   • Նկատի ունեցեք, որ դուք հնարավորություն ունեք միանգամից մի քանի փոփոխական հայտարարելու նույն տողում, քանի դեռ դրանք բոլորը նույն տիպի են: Այս դեպքում փոփոխականների անունները պարզապես բաժանվում են ստորակետներով:
   • Ինչպես C տողերի մեծ մասը, այնպես էլ փոփոխական հայտարարագրման տողը պետք է ավարտվի ստորակետով:
3. 3 Հասկացեք, թե որտեղ կարող եք փոփոխականներ հայտարարել ձեր ծածկագրում: Հարմարության համար խորհուրդ է տրվում փոփոխականներ հայտարարել ծածկագրի յուրաքանչյուր բլոկի սկզբում (հատվածը, որը պարուրված է գանգուր փակագծերում {}): Եթե ​​փորձեք փոփոխական հայտարարել կոդում դրա առաջին օգտագործումից հետո, ծրագիրը ճիշտ չի աշխատի:
4. 4 Օգտվողի կողմից մուտքագրված տվյալները պահելու համար օգտագործեք փոփոխականներ: Այժմ, երբ ծանոթ եք փոփոխականների աշխատանքին, կարող եք փորձել գրել մի պարզ ծրագիր, որը պահում է օգտվողի մուտքը: Այն կպահանջի ևս մեկ գործառույթ սկանֆ... Այս գործառույթը որոնում է մուտքագրված տվյալները `փոփոխականներին հատուկ արժեքներ նշանակելու համար:

   #include stdio.h> int main () {int x; printf ("Մուտքագրեք համարը."); scanf ("% d", & x); printf ("Դուք մուտքագրեցիք% d", x); getchar (); վերադարձ 0; }

   • Ձևաչափի ճշգրտիչ "% d" ասում է գործառույթներ սկանֆ կարդալ օգտատիրոջ կողմից մուտքագրված տասնորդական ամբողջ թիվը:
   • Նախածանց & փոփոխականի անվան առաջ x տեղեկացնում գործառույթները սկանֆ, որտեղ կարող եք գտնել փոփոխականի արժեքը այն փոխելու համար և պահում է մուտքագրված ամբողջ արժեքը:
   • Վերջնական հրաման printf կարդում է մուտքագրված փոփոխականի արժեքը և ցուցադրում այն ​​օգտագործողին:
5. 5 Սովորեք փոփոխականներ շահարկել: Մուտքագրվող փոփոխականները շահարկելու համար կարող եք օգտագործել մաթեմատիկական արտահայտություններ: Այս դեպքում, մաթեմատիկական արտահայտությունների համար ամենակարևորն է հիշել այն տարբերակիչ հատկությունը, որին հավասար է միավորի նշանը = փոփոխականին տալիս է արժեք և կրկնակի հավասարության նշանը == համեմատում է այս նշանի երկու կողմերի արժեքները `հետևողականությունը ստուգելու համար:

   x = 3 * 4; / * սահմանում է «x» - ը 3 * 4 կամ 12 * / x = x + 3; / * ավելացնում է 3 -ը «x» սկզբնական արժեքին և դրան տալիս նոր արժեք * / x == 15; / * ստուգում է, արդյոք «x» փոփոխականը տասնհինգ է * / x 10; / * ստուգում է, եթե «x» - ը տասից փոքր է * /

Մաս 3 -ից 6 -ից. Պայմանների ստեղծում

1. 1 Իմացեք C.- ում պայմանավորման հիմունքները: Programsրագրերի մեծ մասը կառուցված է պայմանական հայտարարությունների վրա: Դրանք արտահայտություններ են, որոնք ստուգվում են ճշմարիտ (UEՇՄԱՐ) կամ կեղծ (ՍՈALՏ) և, կախված արդյունքից, որոշում են հետագա անելիքները: Ամենապարզ պայմանի օպերատորը օպերատորն է ԵԹԵ.
   • TRUE և FALSE ընտրանքները տարբեր կերպ են աշխատում C- ում, քան ծրագրավորման այն այլ լեզուները, որոնց դուք կարող եք սովոր լինել: TRշմարիտ TRUE միշտ վերադարձնում է ոչ զրո թիվը: Եթե ​​համեմատություն եք անում, և արդյունքը TRԻՇՏ է, ծրագիրը վերադարձնում է «1»: Եթե ​​արդյունքը ԿԵSE Է, վերադարձվող արժեքը «0» է: Այս հատկությունը իմանալը կօգնի ձեզ հասկանալ, թե ինչպես են մշակվում ԵԹԵ արտահայտությունները:
2. 2 Իմացեք հիմնական պայմանական օպերատորները: Պայմանական արտահայտությունները հիմնված են արժեքները համեմատող մաթեմատիկական օպերատորների օգտագործման վրա: Ստորև բերված է առավել հաճախ օգտագործվող պայմանական օպերատորների ցանկը:

   > / * / / / * ավելի փոքր * /> = / * մեծ կամ հավասար * / = / * փոքր կամ հավասար * / == / * հավասար * /! = / * հավասար չէ * /
   

   10> 5 UEԻՇՏ 6 15 UEՇՄԱՐՏ 8> = 8 UEՇՄԱՐ 4 = 8 UEՇՄԱՐՏ 3 == 3 UEՇՄԱՐՏ 4! = 5 UEՇՄԱՐՏ

3. 3 Ստեղծեք IF նախադասության հիմնական օրինակ: IF- ի պայմանի հայտարարությունը կարող է օգտագործվել որոշելու համար, թե ինչ պետք է անի ծրագիրը `պայմանը բավարարված լինել -չլինելուց հետո գնահատելուց հետո: Այս օպերատորը կարող է զուգակցվել այլ պայմանական պայմանների հետ ՝ ստեղծելու հզոր բազմափուլ աշխատանքային հոսք, բայց առայժմ փորձեք գրել թեթև օրինակ ՝ նախ ծանոթանալու պայմանների օգտագործմանը:

   #include stdio.h> int main () {if (3 5) printf ("3 -ը 5 -ից փոքր է"); getchar (); }

4. 4 Օգտագործեք ELSE / ELSE IF հայտարարություն `ձեր նշած պայմանները ընդլայնելու համար: Դուք կարող եք ընդլայնել IF հայտարարությունը ՝ օգտագործելով ELSE և ELSE IF հայտարարություններ, որոնք կլուծեն տարբեր արդյունքներ: ELSE- ն ուժի մեջ է մտնում, երբ արտահայտության IF թեստը վերադարձնում է FALSE: ELSE IF- ն թույլ է տալիս մեկ տողում ներառել որոշակի իրավիճակների համար IF- ի տարբեր պայմանների ստուգում: Վերանայեք ստորև նշված ծրագրի ծածկագիրը `հասկանալու համար, թե ինչպես են այս բոլոր տարբերակներն փոխազդում:

   #include stdio.h> 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; }

   • Readsրագիրը կարդում է օգտվողի մուտքագրումը և անցնում այն ​​հաջորդական պայմանական ստուգումների շարքով: Եթե ​​մուտքագրված թիվը համապատասխանում է առաջին պայմանին, ապա ցուցադրվում է առաջին արտահայտությունը printf... Եթե ​​առաջին պայմանը չի բավարարվում, ապա չեկը անցնում է յուրաքանչյուր այլ ELF IF պայմանի, մինչև իսկական արդյունքը չգտնվի: Եթե ​​այս պայմաններից ոչ մեկը չի համապատասխանում, ապա տեղեկատվությունը մշակվում է ծրագրի վերջում գտնվող ELSE- ի վերջին հայտարարությամբ:

Մաս 4 -ից 6 -ից. Սովորում ենք աշխատել օղակների հետ

1. 1 Հասկացեք, թե ինչպես են աշխատում հանգույցները: Օղակները ծրագրավորման ամենակարևոր ասպեկտներից են, քանի որ դրանք թույլ են տալիս կրկնել առանձին կոդերի բլոկներ մինչև որոշակի պայմանի կատարումը:Սա հեշտացնում է ծրագրավորմամբ կրկնվող գործողությունների գրանցումը և ձեզ փրկում է ամեն անգամ նոր պայմաններ գրելուց, երբ ցանկանում եք, որ ծրագիրը ինչ -որ բան անի:
   • Օղակների երեք հիմնական տեսակ կա ՝ FOR, WHILE և DO ... WHILE:
2. 2 Օգտագործեք FOR հանգույց: Սա օղակներից ամենահայտնին և օգտակարն է: Այն շարունակում է կատարել տվյալ գործառույթը մինչև FOR- ում սահմանված պայմանների կատարումը: FOR loops- ի համար պահանջվում է սահմանել երեք պայման ՝ փոփոխական նախաստորագրված, պայման, որը պետք է կատարվի և փոփոխականի արժեքի թարմացման եղանակ: Եթե ​​ձեզ պետք չեն այս երեք պայմաններն էլ, ապա պետք է թողնել բացատ, որի տեղում պետք է լինի ստորակետ, որի դեպքում հանգույցը հավերժ կլինի:

   #include stdio.h> int main () {int y; (y = 0; y 15; y ++) {printf ("% d n", y); } getchar (); }

   • Վերոնշյալ ծրագրում փոփոխականի սկզբնական արժեքն է յ զրո է, և օղակը շարունակվում է այնքան ժամանակ, քանի դեռ փոփոխականի արժեքը մնում է 15 -ից պակաս: Ամեն անգամ, երբ նոր արժեք է ցուցադրվում յ, այն ավելանում է մեկով և ցիկլը կրկնվում է: Մի անգամ փոփոխականը յ ստացվում է 15, ցիկլը ավարտվում է:
3. 3 Օգտագործեք WHILE հանգույց: WHILE loops- ն ավելի պարզ է, քան FOR loops- ը: Նրանք դնում են միայն մեկ պայման և օղակը գործում է այնքան ժամանակ, քանի դեռ այս պայմանը բավարարված է: Անհրաժեշտ չէ այստեղ փոփոխականը նախաստորագրել կամ թարմացնել, բայց դա կարող եք անել հենց հանգույցի հիմնական մասում:

   #include stdio.h> int main () {int y; իսկ (y = 15) {printf ("% d n", y); y ++; } getchar (); }

   • Թիմ y ++ ավելացնում է մեկը փոփոխականի արժեքին յ ամեն անգամ, երբ օղակը կատարվում է: Մի անգամ փոփոխականը յ դառնում է 16 -ի (նկատի ունեցեք, որ օղակը պետք է գործի այնքան ժամանակ, որքան փոփոխականը փոքր կամ հավասար 15), ցիկլը ավարտվում է:
4. 4 Կիրառեք մի հանգույց ԱՆԵԼ..ԲԱՅԼ... Այս ցիկլը շատ օգտակար է, երբ ցիկլի գործողությունները պետք է կատարվեն առնվազն մեկ անգամ: FOR և WHILE օղակներում վիճակը ստուգվում է հենց սկզբից, այսինքն ՝ եթե ստացվում է կեղծ արդյունք, պայմանով նշված գործողությունը բաց է թողնվում և չի կատարվում: DO ... WHILE հանգույցը ստուգում է պայմանները ամենավերջում, ինչը թույլ է տալիս առնվազն մեկ անգամ կատարել օղակի գործողությունները:

   #include stdio.h> int main () {int y; y = 5; անել {printf ("The loop is running! n"); } while (y! = 5); getchar (); }

   • Այս հանգույցը կցուցադրի տրամադրված հաղորդագրությունը, չնայած պայմանի թեստը կեղծ է: Փոփոխական յ սահմանվում է հինգ, և օղակը պետք է կրկնի, երբ փոփոխականը հավասար չէ հինգի, ուստի օղակը դուրս է գալիս: Հաղորդագրությունը մեկ անգամ ցուցադրվում է էկրանին, քանի որ վիճակը ստուգվում է միայն վերջում:
   • WHOLE կետը DO ... WHILE հանգույցում պետք է ավարտվի ստորակետով: Սա միակ հանգույցն է, որը վերջում պահանջում է ստորակետ:

Մաս 5 -ից 6 -ից. Գործառույթների օգտագործումը

1. 1 Հասկացեք գործառույթների օգտագործման հիմունքները: Գործառույթները կոդի բլոկներ են, որոնք կարող եք զանգահարել ձեր ծրագրի տարբեր մասերում: Դրանք ավելի հեշտ են դարձնում ծածկագիրը կրկնելը և օգնում են ավելի դյուրին հասկանալ բուն ծրագրի սկզբունքները և հետագա փոփոխել այն: Գործառույթները կարող են ներառել վերը նշված բոլոր հնարքները և նույնիսկ այլ տեսակի գործառույթներ:
   • Տող հիմնական () վերը նշված բոլոր օրինակների սկզբում մի գործառույթ է, ինչպես տողը getchar ()
   • Գործառույթներն էական նշանակություն ունեն ձեր կոդը արդյունավետ կազմակերպելու և ընթերցումը դյուրին դարձնելու համար: Useիշտ օգտագործեք գործառույթները `ձեր ծրագիրը ռացիոնալ կառուցելու համար:
2. 2 Սկսեք գործառույթների հայտարարումից: Լավագույնն այն է, որ ձեր ծրագրի հենց սկզբում հայտարարեք գործառույթներ ՝ նշելու դրանց նպատակը նախքան կոդավորումը սկսելը: Ֆունկցիաների հիմնական շարահյուսությունն է «return_function անունը (փաստարկ 1, փաստարկ 2 և այլն);»: Օրինակ, երկու թիվ գումարող գործառույթ սահմանելու համար դուք պետք է գրեք հետևյալ ծածկագիրը.

   int ավելացնել (int x, int y);

   • Սա կհայտարարի գործառույթ, որը ավելացնում է երկու ամբողջ թիվ (x եւ յ), իսկ հետո գումարը վերադարձնում է որպես ամբողջ թիվ:
3. 3 Գործառույթը ներառել ծրագրում: Նախկինում հայտարարված գործառույթը կարող է օգտագործվել ծրագիր ստեղծելու համար, որը վերցնում է օգտագործողի կողմից մուտքագրված երկու թիվ և դրանք ավելացնում միասին: Նման ծրագիրը թույլ կտա ցուցադրել «ավելացնել» գործառույթի աշխատանքը և հասկանալ, թե ինչպես կարող եք այն օգտագործել ՝ մուտքագրված տվյալները կառավարելու համար:

   #ներառել stdio.h> 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; }

   • Նկատի ունեցեք, որ գործառույթի հայտարարագիրը դեռ ծրագրի վերևում է: Այն պատմում է կոմպիլյատորին, թե ինչ ակնկալել, երբ գործառույթը կանչվի և կոնկրետ ինչ այն պետք է վերադառնա արդյունքում: Սա անհրաժեշտ է միայն այն դեպքում, եթե ցանկանում եք ծրագրի տեքստում կանչել ստորև նշված գործառույթը: Programրագրի գործառույթը ավելացնել () կարող է մինչև գործել հիմնական ()և արդյունքը նույնը կլինի առանց հայտարարագրի:
   • Functionրագրի վերջում որոշվում է որոշակի գործառույթի փաստացի ֆունկցիոնալությունը: Գործառույթը հիմնական () օգտվողից հավաքում է թվային տվյալներ, այնուհետև դրանք փոխանցում գործառույթին ավելացնել () մշակման համար: Եվ գործառույթը ավելացնել () ավարտված արդյունքը վերադարձնում է գործառույթին հիմնական ()
   • Երբ գործառույթը ավելացնել () արդեն հայտարարագրված է, այն կարելի է զանգել ծրագրի ցանկացած վայրում:

Մաս 6 -ից 6 -ը ՝ Լեզվի հետագա ուսուցում

1. 1 Փնտրեք գրքեր C ծրագրավորման վերաբերյալ: Այս հոդվածը ներառում է միայն լեզվի հիմունքները, որոնք ընկած են C ծրագրավորման հնարավորությունների և դրա հետ կապված բոլոր տեղեկությունների մակերեսին: Լավ գիրքը կօգնի ձեզ լուծել ծագած խնդիրները և ձեզ կփրկի շատ գլխացավեր լեզվի հետ հետագա աշխատանքի ընթացքում:
2. 2 Միացեք ծրագրավորման տարբեր համայնքներին: Կան բազմաթիվ համայնքներ, ինչպես առցանց, այնպես էլ իրական աշխարհում, որոնք նվիրված են ծրագրավորմանը բոլոր հնարավոր լեզուներով: Որոնեք «C ծրագրավորողների լողավազանի» նման մի բան ՝ կոդի օրինակներ և գաղափարներ փոխանակելու համար: Շուտով կնկատեք, որ շատ բան եք սովորել համայնքից:
   • Հնարավորության դեպքում հաճախեք հաքաթոնների: Սրանք իրադարձություններ են, որտեղ ծրագրավորողների և անհատ ծրագրավորողների թիմերը պետք է սահմանափակ ժամանակում ստեղծեն ծրագիր և գտնեն դրա համար հատուկ լուծում ՝ միաժամանակ ցուցադրելով զգալի հնարամտություն: Այսպիսով, դուք կարող եք հանդիպել բազմաթիվ լավ ծրագրավորողների, իսկ հաքաթոններն իրենք պարբերաբար անցկացվում են ամբողջ աշխարհում:
3. 3 Գրանցվեք դասընթացների: Կոդ գրել սովորելու համար հարկավոր չէ քոլեջ գնալ, բայց ծրագրավորման համապատասխան դասընթացի ընդամենը մի քանի դասերի հաճախելը շատ բան կավելացնի ձեր գիտելիքներին: Ոչինչ չի գերազանցում այն ​​մարդկանց օգնությանը, ովքեր ունեն լեզվի գործնական օգտագործման մեծ փորձ: Սովորաբար դասընթացներ են անցկացվում տարբեր համայնքային կենտրոնների, մասնագիտական ​​քոլեջների և համալսարանների կողմից, ինչը թույլ է տալիս սովորել համակարգչային որոշակի գիտություններ ՝ առանց լիարժեք կրթության ուսումնական հաստատություն գնալու անհրաժեշտության:
4. 4 Մտածեք C ++ սովորելու մասին: Երբ դուք հարմար եք C ծրագրավորման լեզվին, ոչինչ չի խանգարի ձեզ ուշադիր նայել C ++ - ին: Այն C լեզվի ավելի ժամանակակից տարբերակ է ՝ ավելի ճկունությամբ: C ++-ը մոդելավորվում է օբյեկտի վրա հիմնված ծրագրավորման պարադիգմայից հետո, այնպես որ C ++-ի իմացությունը հնարավորություն կտա ձեզ ստեղծել հզոր ծրագրեր գրեթե ցանկացած օպերացիոն համակարգի համար:

Խորհուրդներ

• Համոզվեք, որ մեկնաբանեք ձեր կոդը: Մեկնաբանությունները կօգնեն ոչ միայն նրանց, ովքեր հետագայում կփորձեն հասկանալ ձեր կոդը, այլև թույլ կտան հիշել, թե ինչ, որտեղ և ինչու եք գրել: Հավանաբար, այս պահին դուք քաջատեղյակ եք, թե կոնկրետ ինչ եք անում, բայց երկու -երեք ամիս անց արդեն շատ բան կմոռանաք:
• Երբեք մի մոռացեք, որ printf (), scanf (), getch () և նմանատիպ կետերը դրեք ստորակետով (;), բայց երբեք մի դրեք այս նշանը IF կետից կամ WHILE կամ FOR loops- ից հետո:
• Բախվելով կազմավորման շարահյուսական սխալի, որը ձեզ խանգարում է, փորձեք սխալմամբ բացատրություններ փնտրել ՝ օգտագործելով Google որոնման համակարգը (կամ որևէ այլ որոնիչ): Հավանականություն կա, որ ինչ -որ մեկը արդեն հանդիպել է նույն սխալի ձեզանից առաջ և հրապարակել դրա հնարավոր շտկումը:
• Ձեր աղբյուրի կոդը պետք է ունենա *. C ընդլայնում, որպեսզի համակարգիչը հասկանա, որ դա C աղբյուր ֆայլ է:
• Միշտ հիշեք, որ գործնականում կատարելությունը ծնվում է: Որքան շատ եք զբաղվում ծրագրավորումով, այնքան ավելի լավ են դառնում ձեր հմտությունները:Հետևաբար, սկսեք պարզ, կարճ ծրագրերից ՝ մի փոքր ծանոթանալու համար, և երբ բավականաչափ վստահ եք ծրագրավորելու համար, անցեք ավելի բարդ ծրագրերի ստեղծմանը:
• Սովորեք տրամաբանորեն կառուցել ՝ օգնելու ձեզ լուծել տարբեր խնդիրներ ՝ կոդ գրելիս: