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

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

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

Քայլել

6-րդ մաս 1-ին. Նախապատրաստական ​​աշխատանքները

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

   #incd stdio.h> int main () {printf ("Ողջույն, աշխարհ! n"); getchar (); վերադարձ 0; }

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

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

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

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

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

   # ներառել stdio.h> int main () {int x; printf ("Խնդրում ենք մուտքագրել համար."); scanf ("% d", & x); printf («Համարը% d է», x); getchar (); վերադարձ 0; }

   • Ի «% d» լարային / լարային սկանֆ օգտագործողի մուտքագրում ամբողջ թիվ որոնելու համար:
   • Ի & փոփոխականի համար X պատմում է սկանֆ որտեղ գտնել այն փոփոխվողը, որպեսզի փոխի այն և պահի ամբողջ թիվը որպես այդ փոփոխական:
   • Վերջին հրամանը տպագիր կարդում է փոփոխականը և արդյունքը ցուցադրում է օգտագործողին:
5. Փոփոխականների խմբագրում: Դուք կարող եք փոփոխել ձեր պահած տվյալները փոփոխականներում ՝ օգտագործելով մաթեմատիկական արտահայտություններ: Մաթեմատիկական արտահայտությունների համար հիշելու հիմնական տարբերությունն այն մեկն է = պահպանում է փոփոխականի արժեքը, մինչդեռ == բնույթի երկու կողմերի արժեքները ՝ համոզվելու համար, որ դրանք հավասար են:

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

6-րդ մասի 3-րդ մասը. Պայմանական հայտարարություններ

1. Հասկացեք պայմանական պնդումների հիմունքները: Condրագրերի մեծ մասի հիմքում ընկած են պայմանական հայտարարությունները: Սրանք հայտարարություններ են, որոնք կամ UEՇՄԱՐՏԱԿԱՆ են, կամ ՍՈՒՏ, և համապատասխանաբար արդյունք են տալիս: Այս պնդումներից ամենապարզը դա է եթե հայտարարություն
   • C- ում TRՇՄԱՐՏՈՒԹՅՈՒՆԸ և ՍՈՒՏԸ այլ կերպ են աշխատում, քան այն, ինչ դուք կարող էիք սովոր լինել: UEՇՄԱՐՏԱԿԱՆ հայտարարությունները միշտ ավարտվում են ոչ զրո համարին համապատասխանությամբ: Երբ համեմատություններ ես կատարում, և արդյունքը isՇՄԱՐՏ է, վերադարձվում է «1» -ը: Եթե ​​արդյունքը կեղծ է, ապա վերադարձվում է «0»: Սա հասկանալը օգնում է աշխատել IF հայտարարությունների հետ:
2. Իմացեք ստանդարտ պայմանական օպերատորներին: Պայմանական պնդումները պտտվում են մաթեմատիկական օպերատորների օգտագործման շուրջ, որոնք համեմատում են արժեքները: Հաջորդ ցուցակը պարունակում է առավել հաճախ օգտագործվող պայմանական գործարկիչներ:

   > / * ավելի մեծ է, քան * / / * պակաս, քան * /> = / * ավելի մեծ է կամ հավասար է * / = / * պակաս կամ հավասար է * * / == / * հավասար է * /! = / * հավասար չէ * /
   

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

3. ԵԹԵ հիմնական հայտարարությունը: Դուք կարող եք օգտագործել ԵԹԵ հայտարարությունները `որոշելու համար, թե ինչ պետք է անի ծրագիրը հայտարարությունը գնահատելուց հետո: Կարող եք համատեղել սա պայմանական այլ հայտարարությունների հետ `հզոր, բարդ գործառույթներ ստեղծելու համար, բայց մենք առայժմ կպահպանենք այն ընտելացնելը:

   # ներառել stdio.h> int main () {if (3 5) printf ("3-ը 5-ից պակաս է"); getchar (); }

4. Ձեր պայմաններն ընդլայնելու համար օգտագործեք ELSE / ELSE IF հայտարարությունները: Դուք կարող եք հիմնվել IF հայտարարությունների վրա ՝ օգտագործելով ELSE և ELSE IF հայտարարությունները ՝ տարբեր արդյունքներ մշակելու համար: ELSE հայտարարությունները կատարվում են միայն այն դեպքում, եթե IF հայտարարությունը կեղծ է: ELSE IF հայտարարությունները թույլ են տալիս օգտագործել մի քանի IF հայտարարություններ նույն կոդային բլոկի ներսում և այդպիսով ստեղծել ավելի բարդ պայմաններ: Տե՛ս ստորև բերված ծրագրի օրինակին ՝ իմանալու, թե ինչպես է դա գործում:

   # ներառել stdio.h> int main () {int տարիքը; printf ("Մուտքագրեք ձեր տարիքը."); scanf ("% d", & տարիքը); if (տարիքը = 12) {printf ("Դուք դեռ երեխա եք! n"); } else if (20 տարեկան) {printf ("Հոյակապ է դեռահաս լինելը: n"); } other if (40 տարեկան) {printf ("Դուք դեռ սրտով երիտասարդ եք! n"); } else {printf ("Տարիքի հետ գալիս է իմաստությունը: n"); } վերադարձ 0; }

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

6-րդ մասի 4-ը ՝ օղակները

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

   # ներառել stdio.h> int main () {int y; համար (y = 0; y 15; y ++;) {printf ("% d n", y); } getchar (); }

   • Վերոհիշյալ ծրագրում յ դրված է 0-ի վրա, և հանգույցը կշարունակվի այնքան ժամանակ, որքան արժեքն է յ 15-ից պակաս է: timeանկացած ժամանակ արժեքը յ տպվում է էկրանին, 1-ին ավելացնում են արժեքը յ և օղակը կրկնվում է: Դա հաշվա՞ծ է յ = 15, օղակն ընդհատվելու է:
3. ՈՍԿԵ հանգույցը: ՈՐՊԵՍ օղակները մի փոքր ավելի պարզ են, քան ՝ օղակների համար: Սրանք ունեն ընդամենը 1 պայման և հանգույցը շարունակվում է այնքան ժամանակ, քանի դեռ այդ պայմանը բավարարված է: Կարիք չկա փոփոխել նախնական կամ թարմացնել, բայց դա կարող եք անել հենց օղակում:

   # ներառել stdio.h> int main () {int y; while (y = 15) {printf ("% d n", y); y ++; } getchar (); }

   • Ի y ++ հրամանը փոփոխականին ավելացնում է 1 յամեն անգամ, երբ օղակը կատարվում է: Եթե յ հասել է 16-ին (հիշեք, որ այս օղակը շարունակվում է այնքան ժամանակ, որքան յ «15-ից պակաս կամ հավասար»), օղակը կդադարեցվի:
4. Ի ԱՆԵԼ..ԼՈՒՐ հանգույց. Այս օղակը շատ օգտակար է այն օղակների համար, որոնք ցանկանում եք համոզվել, որ դրանք գոնե մեկ անգամ են արվում: FOR և WHILE օղակներում պայմանը ստուգվում է օղակի սկզբում, ինչը նշանակում է, որ օղակն ավարտված է, թե ոչ: ԱՆ ...ԵՔ ... ՈՐՊԵՍ հանգույցները ստուգում են միայն այն դեպքում, եթե պայմանը կատարվել է վերջում, և, հետևաբար, կատարվում են առնվազն մեկ անգամ:

   # ներառել stdio.h> int main () {int y; y = 5; do {printf ("Օղակն աշխատում է! n"); } while (y! = 5); getchar (); }

   • Այս օղակը կցուցադրի հաղորդագրությունը, նույնիսկ եթե պայմանը կեղծ է: Փոփոխական յ սահմանվում է 5 և WHILE հանգույցը կշարունակվի այնքան ժամանակ յ 5-ին հավասար չէ, որից հետո հանգույցն ավարտվում է: Հաղորդագրությունն արդեն ցուցադրվել է էկրանին, քանի որ այն միայն ստուգվում է վերջում, որ պայմանը բավարարված է:
   • ԱՍԵԼՈՒ հանգույցն ԱՆՈՒՄ ... ԱՆԳԱՄ պետք է ավարտվի ստորակետով: Սա միակ դեպքն է, երբ օղակն ավարտվում է կետանիշով:

6-րդ մասի 5-րդ մասը. Հատկություններ օգտագործելը

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

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

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

   # ներառել stdio.h> int ավելացնել (int x, int y); int հիմնական () {int x; int y; printf («Խնդրում ենք մուտքագրել երկու թիվ ՝ ավելացնելու համար.»); scanf ("% d", & x); scanf ("% d", & y); printf («Թվերի գումարը% d n է», ավելացնել (x, y)); getchar (); } int ավելացնել (int x, int y) {վերադարձ x + y; }

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

6-րդ մասի 6-րդ մասը. Շարունակեք սովորել

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

Խորհուրդներ

• Միշտ մեկնաբանեք ձեր ծրագրերը: Սա ոչ միայն օգնում է ուրիշներին հասկանալ ձեր աղբյուրը, այլ նաև օգնում է ձեզ հիշել, թե ինչ եք կոդավորել և ինչու: Դու հիմա կարող ես իմանալ, թե ինչ ես անում, բայց շուրջ 2-3 ամիս անց հավանականությունը մեծ է, որ այլևս գաղափար չունես:
• Մի մոռացեք, որ տպեք (f), scanf (), getch () և այլն, ինչպես օրինակ, վերջակետը (;) ավարտեք, բայց երբեք մի դրեք այն «եթե», «մինչդեռ» կամ «համար» օղակների արտահայտություններից հետո:
• Եթե ​​կազմման ժամանակ շարահյուսական սխալի եք հանդիպել և խրվել եք, օգտագործեք ձեր նախընտրած որոնիչը ՝ պարզելու, թե ինչ է նշանակում սխալի հաղորդագրությունը: Մեծ հավանականություն կա, որ մեկ ուրիշն արդեն տեղադրեց նույն խնդրի լուծումը:
• Աղբյուրի կոդը պետք է ունենա *. C ընդլայնում, որպեսզի կազմողը իմանա, որ C ֆայլ է:
• Հիշեք, պրակտիկան կատարյալ է դառնում: Որքան շատ զբաղվեք գրելու ծրագրերով, այնքան ավելի լավ կդառնաք: Այսպիսով, սկսեք պարզ, կարճ ծրագրերից, մինչև որ ամուր հիմք ունենաք, ապա անցեք ավելի բարդ ծրագրերի:
• Իմացեք տրամաբանության մասին: Սա օգնում է լուծել տարբեր խնդիրներ, մինչ դուք կոդավորում եք: