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"); გეტჩარი (); დაბრუნება 0; }
- #Include ბრძანება ჩნდება პროგრამის დაწყებამდე და იტვირთება ბიბლიოთეკები, რომლებიც შეიცავს თქვენთვის საჭირო ფუნქციებს. ამ მაგალითში, stdio.h საშუალებას გვაძლევს გამოვიყენოთ printf () და getchar () ფუნქციები.
- Int main () ბრძანება ეუბნება შემდგენელს, რომ პროგრამა ასრულებს ფუნქციას სახელწოდებით "main" და რომ ის დააბრუნებს მთელ რიცხვს დასრულების შემდეგ. ყველა C პროგრამა ასრულებს "მთავარ" ფუნქციას.
- {} მიუთითებს, რომ ყველაფერი მათ შიგნით არის ფუნქციის ნაწილი. ამ შემთხვევაში, ისინი აღნიშნავენ, რომ ყველაფერი შიგნით არის "მთავარი" ფუნქციის ნაწილი.
- Printf () ფუნქცია აჩვენებს ფრჩხილების შინაარსს მომხმარებლის ეკრანზე. ციტატები უზრუნველყოფენ, რომ სტრიქონი შიგნით დაბეჭდილი იყოს სიტყვასიტყვით. / N თანმიმდევრობა ეუბნება შემდგენელს, რომ კურსორი გადაიტანოს შემდეგ სტრიქონზე.
- ; აღნიშნავს ხაზის დასასრულს. C კოდის უმეტეს სტრიქონი უნდა დასრულდეს მძიმით.
- Getchar () ბრძანება ეუბნება შემდგენელს, რომ დაელოდოს ღილაკის შეყვანას გადაადგილებამდე. ეს სასარგებლოა, რადგან ბევრი შემდგენელი გაუშვებს პროგრამას და დაუყოვნებლივ დახურავს ფანჯარას. ეს ხელს შეუშლის პროგრამის დასრულებას გასაღების დაჭერამდე.
- დაბრუნების 0 ბრძანება მიუთითებს ფუნქციის დასრულებაზე. გაითვალისწინეთ, თუ როგორ არის "მთავარი" ფუნქცია int ფუნქცია. ეს ნიშნავს, რომ პროგრამის დასრულების შემდეგ მას მთელი რიცხვის დაბრუნება დასჭირდება. "0" მიუთითებს იმაზე, რომ პროგრამა სწორად შესრულდა; ნებისმიერი სხვა რიცხვი ნიშნავს, რომ პროგრამა შეექმნა შეცდომას.
ნაბიჯი 4. სცადეთ პროგრამის შედგენა
შეიყვანეთ კოდი თქვენს კოდის რედაქტორში და შეინახეთ როგორც "*.c" ფაილი. შეადგინეთ იგი თქვენს შემდგენელში, როგორც წესი, მშენებლობის ან გაშვების ღილაკზე დაჭერით.
ნაბიჯი 5. ყოველთვის გააკეთეთ კომენტარი თქვენს კოდზე
კომენტარები არის კოდის ნაწილი, რომელიც არ არის შედგენილი, მაგრამ გაძლევთ საშუალებას აგიხსნათ რა ხდება. ეს სასარგებლოა იმის გასახსენებლად, თუ რისთვის არის თქვენი კოდი და სხვა დეველოპერების დასახმარებლად, რომლებიც შესაძლოა თქვენს კოდს უყურებენ.
- კომენტარის გაკეთება C ადგილას / * კომენტარის დასაწყისში და * / დასასრულს.
- გააკეთეთ კომენტარი თქვენი კოდის ყველა ძირითადი ნაწილის გარდა.
- კომენტარები შეიძლება გამოყენებულ იქნას თქვენი კოდის ნაწილების სწრაფად წაშლისთვის მათი წაშლის გარეშე. უბრალოდ დაურთეთ კოდი, რომლის გამორიცხვაც გსურთ კომენტარის ტეგებით და შემდეგ შეადგინეთ. თუ გსურთ კოდის დამატება, წაშალეთ ტეგები.
ნაწილი 6 6: ცვლადების გამოყენება
ნაბიჯი 1. ცვლადების ფუნქციის გაგება
ცვლადები საშუალებას გაძლევთ შეინახოთ მონაცემები, პროგრამის გამოთვლებიდან ან მომხმარებლის შეყვანიდან. ცვლადები უნდა განისაზღვროს, სანამ მათ გამოიყენებ და არჩევანის რამდენიმე ტიპი არსებობს.
ზოგიერთი ყველაზე გავრცელებული ცვლადი ტიპი მოიცავს int, char და float. თითოეული ინახავს სხვადასხვა ტიპის მონაცემებს
ნაბიჯი 2. ისწავლეთ როგორ გამოცხადდეს ცვლადები
ცვლადები უნდა შეიქმნას, ან „გამოცხადდეს“, სანამ ისინი გამოყენებულ იქნებიან პროგრამის მიერ. თქვენ აცხადებთ ცვლადს მონაცემების ტიპის შეყვანის შემდეგ ცვლადის სახელით. მაგალითად, ქვემოთ მოცემულია ყველა მოქმედი ცვლადი დეკლარაცია:
float x; char სახელი; int a, b, c, d;
- გაითვალისწინეთ, რომ თქვენ შეგიძლიათ გამოაცხადოთ მრავალი ცვლადი ერთ ხაზზე, თუ ისინი ერთი და იგივე ტიპისაა. უბრალოდ გამოყავით ცვლადის სახელები მძიმეებით.
- ისევე როგორც ბევრი სტრიქონი C- ში, თითოეული ცვლადის დეკლარაციის ხაზი უნდა დასრულდეს მძიმით.
ნაბიჯი 3. იცოდეთ სად გამოაცხადოთ ცვლადები
ცვლადები უნდა გამოცხადდეს თითოეული კოდის ბლოკის დასაწყისში (თქვენი კოდის ნაწილები, რომლებიც ჩასმულია {} ფრჩხილებში). თუ თქვენ ცდით ცვლადის გამოცხადებას ბლოკში, პროგრამა არ იმუშავებს სწორად.
ნაბიჯი 4. გამოიყენეთ ცვლადები მომხმარებლის შეყვანის შესანახად
ახლა, როდესაც თქვენ იცით ცვლადების მუშაობის საფუძვლები, შეგიძლიათ დაწეროთ მარტივი პროგრამა, რომელიც შეინახავს მომხმარებლის შეყვანას. თქვენ გამოიყენებთ პროგრამის სხვა ფუნქციას, სახელწოდებით scanf. ეს ფუნქცია ეძებს იმ შეყვანას, რომელიც მოცემულია კონკრეტული მნიშვნელობებისთვის.
#მოიცავს int main () {int x; printf ("შეიყვანეთ ნომერი:"); scanf ("%d", & x); printf ("თქვენ შეიყვანეთ %d", x); გეტჩარი (); დაბრუნება 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 -ზე ნაკლებია//
მე -6 ნაწილი 6: პირობითი განცხადებების გამოყენება
ნაბიჯი 1. პირობითი განცხადებების საფუძვლების გაგება
პირობითი განცხადებები არის ის, რაც ამოძრავებს პროგრამების უმეტესობას. ეს არის განცხადებები, რომლებიც განისაზღვრება როგორც ჭეშმარიტი ან მცდარი, შემდეგ კი მოქმედებენ შედეგზე დაყრდნობით. განცხადებებს შორის ყველაზე ძირითადი არის if განცხადება.
TRUE და FALSE განსხვავებულად მუშაობს C– ში, ვიდრე ის, რასაც შეიძლება შეეჩვიოთ. TRUE განცხადებები ყოველთვის სრულდება არა ნულოვანი რიცხვის ტოლით. შედარებისას, თუ შედეგი არის TRUE მაშინ ბრუნდება "1". თუ შედეგი არის ყალბი, მაშინ ბრუნდება "0". ამის გაგება დაგეხმარებათ ნახოთ როგორ დამუშავდება IF განცხადებები
ნაბიჯი 2. ისწავლეთ ძირითადი პირობითი ოპერატორები
პირობითი განცხადებები ტრიალებს მათემატიკური ოპერატორების გამოყენებისას, რომლებიც ადარებენ მნიშვნელობებს. შემდეგი სია შეიცავს ყველაზე ხშირად გამოყენებულ პირობით ოპერატორებს.
/* მეტი* /< /* ნაკლები* /> = /* მეტი ან ტოლი* /<= /* ნაკლები ან ტოლი* /== /* ტოლი* /! = /* არა ტოლი to */
10> 5 TRUE 6 <15 TRUE 8> = 8 TRUE 4 <= 8 TRUE 3 == 3 TRUE 4! = 5 TRUE
ნაბიჯი 3. დაწერეთ ძირითადი IF განცხადება
თქვენ შეგიძლიათ გამოიყენოთ IF განცხადებები იმის დასადგენად, თუ რა უნდა გააკეთოს პროგრამამ განცხადების შეფასების შემდეგ. თქვენ შეგიძლიათ დააკავშიროთ იგი სხვა პირობით განცხადებებთან მოგვიანებით, რათა შექმნათ ძლიერი მრავალჯერადი ვარიანტი, მაგრამ ახლა დაწერეთ მარტივი, რომ შეეგუოთ მათ.
#მოიცავს int main () {if (3 <5) printf ("3 არის 5 -ზე ნაკლები"); გეტჩარი (); }
ნაბიჯი 4. გამოიყენეთ ELSE/ELSE IF განცხადებები თქვენი პირობების გასაფართოებლად
თქვენ შეგიძლიათ დაეყრდნოთ IF განცხადებებს ELSE და ELSE IF განცხადებების გამოყენებით სხვადასხვა შედეგების დასამუშავებლად. სხვა განცხადებები გაშვებული თუ IF განცხადება არის ყალბი. სხვა IF განცხადებები საშუალებას გაძლევთ შეიტანოთ მრავალი IF განცხადება ერთ კოდის ბლოკში სხვადასხვა შემთხვევების მოსაგვარებლად. იხილეთ ქვემოთ მოყვანილი პროგრამის მაგალითი, რომ ნახოთ როგორ ურთიერთქმედებენ ისინი.
#ჩართეთ int main () {int ასაკი; printf ("გთხოვთ მიუთითოთ თქვენი ამჟამინდელი ასაკი:"); scanf ("%d", & ასაკი); if (ასაკი <= 12) {printf ("შენ უბრალოდ ბავშვი ხარ! / n"); } else if (ასაკი <20) {printf ("თინეიჯერობა საკმაოდ კარგია! / n"); } სხვა თუ (ასაკი <40) {printf ("შენ ჯერ კიდევ ახალგაზრდა ხარ! / n"); } else {printf ("ასაკთან ერთად მოდის სიბრძნე. / n"); } დაბრუნება 0; }
პროგრამა იღებს შეყვანას მომხმარებლისგან და იღებს მას IF განცხადებების საშუალებით. თუ ნომერი აკმაყოფილებს პირველ დებულებას, მაშინ დაბრუნდება პირველი printf განცხადება. თუ ის არ აკმაყოფილებს პირველ დებულებას, იგი მიიღება სხვა ELF IF განცხადების მეშვეობით, სანამ არ იპოვის ის, რომელიც მუშაობს. თუ ის არ ემთხვევა არცერთ მათგანს, ის გადის ELSE განცხადების ბოლოს
ნაწილი 4 დან 6: სასწავლო მარყუჟები
ნაბიჯი 1. გაიგეთ როგორ მუშაობს მარყუჟები
მარყუჟები არის პროგრამირების ერთ -ერთი ყველაზე მნიშვნელოვანი ასპექტი, რადგან ისინი საშუალებას გაძლევთ გაიმეოროთ კოდის ბლოკები, სანამ კონკრეტული პირობები არ დაკმაყოფილდება. ამან შეიძლება გაადვილოს განმეორებითი ქმედებების განხორციელება და არ შეგიშალოთ ყოველ ჯერზე რაიმე პირობითი განცხადების დაწერა.
მარყუჟების სამი ძირითადი ტიპი არსებობს: FOR, WHILE და DO… WHILE
ნაბიჯი 2. გამოიყენეთ FOR მარყუჟი
ეს არის ყველაზე გავრცელებული და სასარგებლო მარყუჟის ტიპი. ის გააგრძელებს ფუნქციის გაშვებას მანამ, სანამ FOR მარყუჟში მითითებული პირობები არ დაკმაყოფილდება. მარყუჟებისათვის საჭიროა სამი პირობა: ცვლადის ინიციალიზაცია, პირობა, რომელიც უნდა დაკმაყოფილდეს და ცვლადის განახლების გზა. თუ თქვენ არ გჭირდებათ ყველა ეს პირობა, თქვენ კვლავ უნდა დატოვოთ ცარიელი წერტილი მძიმით, წინააღმდეგ შემთხვევაში მარყუჟი სამუდამოდ გადის.
#მოიცავს int main () {int y; for (y = 0; y <15; y ++;) {printf ("%d / n", y); } getchar (); }
ზემოაღნიშნულ პროგრამაში y არის მითითებული 0 -ზე, ხოლო მარყუჟი გრძელდება მანამ, სანამ y მნიშვნელობა 15 -ზე ნაკლებია. ყოველ ჯერზე, როდესაც y მნიშვნელობა იბეჭდება, 1 ემატება y მნიშვნელობას და მარყუჟი მეორდება. ერთხელ y = 15, მარყუჟი იშლება
ნაბიჯი 3. გამოიყენეთ WHILE მარყუჟი
სანამ მარყუჟები უფრო მარტივია ვიდრე FOR მარყუჟები. მათ აქვთ მხოლოდ ერთი პირობა და მარყუჟი მოქმედებს მანამ, სანამ ეს პირობა მართალია. თქვენ არ გჭირდებათ ცვლადის ინიციალიზაცია ან განახლება, თუმცა ამის გაკეთება შეგიძლიათ მარყუჟის მთავარ სხეულში.
#მოიცავს int main () {int y; ხოლო (y <= 15) {printf ("%d / n", y); y ++; } getchar (); }
მარყუჟის შესრულებისას y ++ ბრძანება 1 ცვლის y ცვლადს. ერთხელ y დაარტყამს 16 (გახსოვდეთ, ეს მარყუჟი მიდის მანამ, სანამ y ნაკლებია ან ტოლია 15), მარყუჟი იშლება
ნაბიჯი 4. გამოიყენეთ DO
..ვაილის მარყუჟი.
ეს მარყუჟი ძალიან სასარგებლოა იმ მარყუჟებისთვის, რომლითაც გსურთ ერთხელ მაინც გაშვება. FOR და WHILE მარყუჟებში, მდგომარეობა შემოწმებულია მარყუჟის დასაწყისში, რაც იმას ნიშნავს, რომ ის ვერ გაივლის და მაშინვე ჩავარდება. გააკეთე … სანამ მარყუჟები ამოწმებენ პირობებს მარყუჟის ბოლოს, რაც უზრუნველყოფს მარყუჟის შესრულებას ერთხელ მაინც.
#მოიცავს int main () {int y; y = 5; გააკეთე {printf ("ეს მარყუჟი მუშაობს! / n"); } ხოლო (y! = 5); გეტჩარი (); }
- ეს მარყუჟი აჩვენებს შეტყობინებას, მიუხედავად იმისა, რომ მდგომარეობა არის FALSE. ცვლადი y არის 5 -ზე და WHILE მარყუჟი არის დაყენებული, როდესაც y არ არის 5 -ის ტოლი, ამიტომ მარყუჟი წყდება. შეტყობინება უკვე დაბეჭდილია, რადგან მდგომარეობა ბოლომდე არ არის შემოწმებული.
- WHILE მარყუჟი DO… სანამ კომპლექტი უნდა დასრულდეს მძიმით. ეს არის ერთადერთი შემთხვევა, როდესაც მარყუჟი სრულდება მძიმით.
ნაწილი 6 -დან 6: ფუნქციების გამოყენება
ნაბიჯი 1. გაეცანით ფუნქციების საფუძვლებს
ფუნქციები არის კოდის ბლოკები, რომელთა გამოყენება შესაძლებელია პროგრამის სხვა ნაწილის მიერ. ისინი ძალიან აადვილებენ კოდის გამეორებას და ეხმარებიან პროგრამას გაუადვილოს წაკითხვა და შეცვლა. ფუნქციები შეიძლება შეიცავდეს ამ სტატიაში ნასწავლ ყველა ადრე დაფარულ ტექნიკას და სხვა ფუნქციებსაც კი.
- ყველა ზემოთ მოყვანილი მაგალითის დასაწყისში მთავარი () ხაზი არის ფუნქცია, ისევე როგორც getchar ()
- ფუნქციები აუცილებელია ეფექტური და ადვილად წასაკითხი კოდისთვის. კარგად გამოიყენეთ ფუნქციები თქვენი პროგრამის გასაუმჯობესებლად.
ნაბიჯი 2. დაიწყეთ მონახაზი
ფუნქციები საუკეთესოდ იქმნება მაშინ, როდესაც თქვენ ასახავთ იმას, რისი მიღწევაც გსურთ, სანამ დაიწყებთ რეალურ კოდირებას. ფუნქციების ძირითადი სინტაქსია "return_type name (არგუმენტი 1, არგუმენტი 2 და ა.შ.);". მაგალითად, ფუნქციის შესაქმნელად, რომელიც ამატებს ორ რიცხვს:
int დამატება (int x, int y);
ეს შექმნის ფუნქციას, რომელიც დაამატებს ორ მთელ რიცხვს (x და y) და შემდეგ აბრუნებს ჯამს მთლიანი რიცხვის სახით
ნაბიჯი 3. დაამატეთ ფუნქცია პროგრამას
თქვენ შეგიძლიათ გამოიყენოთ მონახაზი პროგრამის შესაქმნელად, რომელსაც იღებს ორი მთელი რიცხვი, რომელშიც მომხმარებელი შედის და შემდეგ ამატებს მათ ერთად. პროგრამა განსაზღვრავს როგორ მუშაობს "დამატება" ფუნქცია და გამოიყენებს მას შეყვანის ნომრების მანიპულირებისთვის.
#მოიცავს int add (int x, int y); int main () {int x; int y; printf ("შეიყვანეთ ორი რიცხვი ერთად დასამატებლად:"); scanf ("%d", & x); scanf ("%d", & y); printf ("შენი რიცხვების ჯამი არის %d / n", დაამატე (x, y)); გეტჩარი (); } int დამატება (int x, int y) {დაბრუნება x + y; }
- გაითვალისწინეთ, რომ მონახაზი კვლავ მდებარეობს პროგრამის ზედა ნაწილში. ეს ეუბნება შემდგენელს, რას უნდა ელოდოს ფუნქციის გამოძახებისას და რას დაუბრუნებს ის. ეს აუცილებელია მხოლოდ იმ შემთხვევაში, თუ გსურთ განსაზღვროთ ფუნქცია მოგვიანებით პროგრამაში. თქვენ შეგიძლიათ განსაზღვროთ add () მთავარ () ფუნქციამდე და შედეგი იქნება იგივე მონახაზის გარეშე.
- ფუნქციის ფაქტობრივი ფუნქციონირება განისაზღვრება პროგრამის ბოლოში. მთავარი () ფუნქცია აგროვებს რიცხვებს მომხმარებლისგან და შემდეგ უგზავნის მათ დამუშავების add () ფუნქციას. 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 წყაროს ფაილი.
- ყოველთვის გახსოვდეთ, რომ პრაქტიკა სრულყოფილებას ხდის. რაც უფრო მეტს ვარჯიშობთ პროგრამის წერაზე, მით უკეთესად მიიღებთ მას. ასე რომ, დაიწყეთ მარტივი, მოკლე პროგრამებით, სანამ არ დაიმკვიდრებთ ფეხს, შემდეგ კი, როდესაც დარწმუნდებით, რომ შეგიძლიათ გადავიდეთ უფრო რთულზე.
- შეეცადეთ ისწავლოთ ლოგიკის აგება. ეს ხელს უწყობს კოდის წერისას სხვადასხვა პრობლემის მოგვარებას.
