Nilalaman

• Mga hakbang
• Bahagi 1 ng 6: Paghahanda
• Bahagi 2 ng 6: Paggamit ng Mga variable
• Bahagi 3 ng 6: Paglikha ng Mga Kundisyon
• Bahagi 4 ng 6: Pag-aaral na gumana sa mga loop
• Bahagi 5 ng 6: Paggamit ng Mga Pag-andar
• Bahagi 6 ng 6: Karagdagang pag-aaral ng wika
• Mga Tip

Ang wikang C ay isa sa pinakamatandang wika sa pagprograma. Ito ay binuo noong dekada 70 ng huling siglo, ngunit ito ay pa rin malakas dahil sa ang katunayan na ito ay kabilang sa mga tool sa mababang antas ng programa na gumagamit ng mga makabuluhang pagpapaikli para sa iba't ibang mga utos. Ang pag-aaral ng wikang C ay isa ring mahusay na batayan para sa paglipat sa mas kumplikadong mga wika, at ang kaalamang nakuha dito ay magiging kapaki-pakinabang sa halos lahat ng mga wika sa pagprograma at makakatulong sa iyo na makisali sa malayang pag-unlad ng aplikasyon. Upang magsimulang matuto ng wikang ito, basahin ang impormasyon sa artikulong ito.

Mga hakbang

Bahagi 1 ng 6: Paghahanda

1. 1 I-download at i-install ang tagatala. Ang wikang C ay dapat na ipunin sa isang programa na magbibigay kahulugan sa code ng wika sa mga signal ng makina. Ang mga tagatala ay karaniwang libre at magagamit para sa iba't ibang mga operating system.
   • Para sa Windows, subukang gamitin ang Microsoft Visual Studio Express o MinGW.
   • Para sa Mac, ang Xcode ay itinuturing na isa sa mga pinakamahusay na tagatala.
   • Para sa Linux, ang GCC ang pinakatanyag.
2. 2 Alamin ang mga pangunahing kaalaman. Ang wikang C ay isa sa pinakaluma at pinakamakapangyarihang wika ng pagprograma. Ito ay inilaan para sa operating system ng Unix, ngunit pinalawak at na-port sa halos lahat ng mga operating system. Ang modernong pagkakatawang-tao ng C ay C ++.
   • Ang wika ng C ay pangunahing binubuo ng mga pagpapaandar, at sa mga pagpapaandar na ito maaari kang gumamit ng mga variable, kundisyon, at mga loop upang mag-imbak ng impormasyon at manipulahin ang data.
3. 3 Suriin ang pinakasimpleng code. Tingnan ang code para sa pinakasimpleng programa sa ibaba upang makita kung paano nakikipag-ugnayan ang ilan sa mga bahagi ng wika sa bawat isa, at upang maunawaan kung paano gumagana ang mismong programa.

   #include stdio.h> int main () {printf ("Hello World n"); getchar (); ibalik ang 0; }

   • Koponan # isama tumatakbo kahit bago magsimula ang programa at magpatakbo ng mga aklatan na naglalaman ng mga pagpapaandar na kailangan mo. Sa halimbawa sa itaas stdio.h Pinapayagan kang gamitin ang mga pagpapaandar sa programa printf () at getchar ().
   • Koponan int main () Sinasabi sa tagatala na patakbuhin ang pangunahing pagpapaandar na "pangunahing", na magbabalik ng isang tukoy na integer kapag natapos na. Ang lahat ng mga programa ng C ay gumagamit ng "pangunahing" pagpapaandar.
   • Mga brace {} sabihin na ang lahat ng kanilang nilalaman ay bahagi ng pagpapaandar. Sa kasong ito, nangangahulugan sila na ang mga nilalaman ng panaklong ay bahagi ng "pangunahing" pag-andar.
   • Pag-andar printf () ipinapakita ang mga nilalaman ng panaklong sa screen ng gumagamit. Tinitiyak ng pag-quote na ang mga nilalaman ng mga braket ay itinuturing na teksto. Pagkontrol ng pagkakasunud-sunod n Sinasabi sa computer na ilipat ang cursor sa susunod na linya.
   • Semicolon ; marka ang katapusan ng linya. Karamihan sa mga linya ng C code ay dapat magtapos sa character na ito.
   • Koponan getchar () Sinasabi sa computer na maghintay para sa isang pindutin ang pindutin bago gumawa ng anupaman. Ito ay napaka kapaki-pakinabang tulad ng maraming mga operating system na naisakatuparan ang programa at pagkatapos ay agad na isara ang window. Sa kasong ito, ang programa ay hindi nagtatapos hanggang ang pindutan ay pinindot.
   • Koponan ibalik ang 0 ay nagpapahiwatig ng pagtatapos ng programa. Mangyaring tandaan na ang "pangunahing" pagpapaandar ay tumutukoy sa mga pagpapaandar int... Nangangahulugan ito na dapat itong ibalik ang isang tukoy na halaga kapag natapos ang programa. Ang zero na "0" ay nagpapahiwatig ng isang wastong naisakatuparan na programa, at anumang iba pang numero ay nagpapahiwatig ng isang error.
4. 4 Subukang i-compile ang programa. I-type ang iyong code sa code editor at i-save ito bilang isang " *. C" file. Compile ito sa isang tagatala. Karaniwang nangangailangan ito ng pag-click sa pindutang "Bumuo" o "Patakbuhin".
5. 5 Siguraduhing magbigay ng puna sa nabuong code. Ang mga komento ay bahagi ng code na hindi naipon, ngunit pinapayagan kang ipaliwanag kung ano ang eksaktong nangyayari sa programa. Kapaki-pakinabang ang mga ito para sa pagpapaalala sa iyong sarili ng layunin ng code at ipaliwanag kung paano ito gumagana sa iba pang mga developer na maaaring tuklasin ang code.
   • Upang magsulat ng isang komento sa C, gumamit ng isang forward slash gamit ang isang asterisk /* sa simula ng nagpapaliwanag na teksto at isang asterisk na may isang forward slash */ sa pagtatapos nito.
   • I-comment ang lahat ng mga pangunahing bahagi ng iyong code.
   • Maaaring gamitin ang mga komento upang mabilis na maibukod ang ilang mga bahagi ng code mula sa trabaho nang hindi inaalis ang mga ito. Ilagay lamang ang code na nais mong hindi paganahin sa isang komento at i-compile ang programa. Kung nais mong ibalik ang code, alisin lamang ang mga tag ng komento.

Bahagi 2 ng 6: Paggamit ng Mga variable

1. 1 Maunawaan kung paano gumagana ang mga variable. Pinapayagan ka ng mga variable na mangolekta at mag-imbak ng data na nakuha bilang isang resulta ng mga kalkulasyon sa mismong programa o sa pamamagitan ng pag-input ng gumagamit. Dapat markahan ang mga variable bago magamit. Maaari itong magawa sa iba't ibang mga paraan.
   • Kabilang sa mga pinaka-karaniwang ginagamit na variable ay mga variable int, char at lumutang... Ang bawat isa sa kanila ay nag-iimbak ng iba't ibang uri ng data.
2. 2 Alamin kung paano ipinahayag ang mga variable sa iyong programa. Dapat italaga ang mga variable, o "ideklara", bago ito magamit sa isang programa. Maaari mong ideklara ang isang variable sa pamamagitan ng pagtukoy sa ginamit na uri ng data at ang pangalan ng variable. Halimbawa, ang lahat ng mga sumusunod na halimbawa ay may bisa:

   lumutang x; pangalan ng karakter; int a, b, c, d;

   • Tandaan na mayroon kang kakayahang magdeklara ng maraming mga variable nang sabay-sabay sa parehong linya hangga't lahat sila ay magkaparehong uri. Sa kasong ito, ang mga variable na pangalan ay simpleng pinaghihiwalay ng mga kuwit.
   • Tulad ng karamihan sa mga linya sa C, ang bawat variable na linya ng deklarasyon ay dapat magtapos sa isang kalahating titik.
3. 3 Maunawaan kung saan maaari mong ideklara ang mga variable sa iyong code. Para sa kaginhawaan, inirerekumenda na ideklara ang mga variable sa simula ng bawat bloke ng code (ang bahagi na nakapaloob sa mga kulot na brace {}). Kung susubukan mong ideklara ang isang variable pagkatapos ng unang paggamit nito sa code, ang programa ay hindi gagana nang tama.
4. 4 Gumamit ng mga variable upang maiimbak ang data na ipinasok ng gumagamit. Ngayon na pamilyar ka sa kung paano gumagana ang mga variable, maaari mong subukang magsulat ng isang simpleng programa na nag-iimbak ng input ng gumagamit. Mangangailangan ito ng isa pang pagpapaandar scanf... Hinahanap ng pagpapaandar na ito ang ipinasok na data upang magtalaga ng mga tukoy na halaga sa mga variable.

   # isama ang stdio.h> int main () {int x; printf ("Magpasok ng isang numero:"); scanf ("% d", & x); printf ("Nagpasok ka ng% d", x); getchar (); ibalik ang 0; }

   • Format specifier "% d" sabi function scanf basahin ang isang decimal integer na ipinasok ng gumagamit.
   • Pauna & bago ang variable na pangalan x nagpapaalam sa mga pagpapaandar scanf, kung saan mahahanap mo ang halaga ng variable upang baguhin ito, at maiimbak ang ipinasok na halaga ng integer.
   • Pangwakas na utos printf binabasa ang halaga ng ipinasok na variable at ipinapakita ito sa gumagamit.
5. 5 Alamin na manipulahin ang mga variable. Maaari mong gamitin ang mga expression sa matematika upang manipulahin ang mga variable na ipinasok mo. Sa kasong ito, para sa mga expression ng matematika, pinakamahalagang alalahanin ang natatanging tampok na katumbas ng pag-sign ng unit = nagtatalaga ng isang halaga sa isang variable at ang dobleng katumbas na pag-sign == ihinahambing ang mga halaga sa magkabilang panig ng pag-sign na ito upang suriin para sa pagkakapare-pareho.

   x = 3 * 4; Itinatakda ng / * ang "x" sa 3 * 4, o 12 * / x = x + 3; / * nagdaragdag ng 3 sa orihinal na halagang "x" at nagtatalaga ng isang bagong halaga dito * / x == 15; / * suriin kung ang variable na "x" ay labinlimang * / x 10; / * suriin kung ang "x" ay mas mababa sa sampung * /

Bahagi 3 ng 6: Paglikha ng Mga Kundisyon

1. 1 Maunawaan ang mga pangunahing kaalaman sa pag-condition sa C. Karamihan sa mga programa ay itinatayo sa mga kondisyong pahayag. Ang mga ito ay mga expression na nasubok para sa totoo (TUNAY) o maling (MALI) at, depende sa resulta, matukoy kung ano ang susunod na gagawin. Ang pinakasimpleng operator ng kundisyon ay ang operator KUNG.
   • Ang TUNAY at MALI na mga pagpipilian ay gumagana nang iba sa C kaysa sa iba pang mga wika ng programa na maaaring nakasanayan mo. Ang isang totoong TUNAY ay laging nagbabalik ng isang hindi numero ng numero. Kung gumagawa ka ng paghahambing at ang resulta ay TUNAY, ibabalik ng programa ang "1". Kung ang resulta ay MALI, ang bumalik na halaga ay "0". Ang pag-alam sa tampok na ito ay makakatulong sa iyo na maunawaan kung paano panghawakan ang mga expression ng KUNG.
2. 2 Alamin ang pangunahing mga kondisyong operator. Ang mga kondisyon na ekspresyon ay batay sa paggamit ng mga operator ng matematika na ihinahambing ang mga halaga. Nasa ibaba ang isang listahan ng pinakakaraniwang ginagamit na mga kondisyunal na operator.

   > / * mas malaki sa * / / * mas mababa sa * /> = / * mas malaki sa o katumbas ng * / = / * mas mababa sa o katumbas ng * / == / * katumbas ng * /! = / * hindi pantay * /
   

   10> 5 TUNAY 6 15 TUNAY 8> = 8 TUNAY 4 = 8 TUNAY 3 == 3 TUNAY 4! = 5 TUNAY

3. 3 Lumikha ng isang pangunahing halimbawa ng isang sugnay na IF. Ang pahayag ng kundisyon na KUNG maaaring magamit upang matukoy kung ano ang dapat gawin ng programa pagkatapos masuri kung ang isang kundisyon ay natugunan o hindi. Ang operator na ito ay maaaring pagsamahin sa iba pang mga kundisyon upang lumikha ng isang malakas na multivariate workflow, ngunit sa ngayon subukan ang pagsusulat ng isang magaan na halimbawa upang pamilyar lamang sa paggamit ng mga kundisyon muna.

   # isama ang stdio.h> int main () {kung (3 5) printf ("3 ay mas mababa sa 5"); getchar (); }

4. 4 Gumamit ng isang pahayag na ELSE / ELSE IF upang mapalawak ang mga kundisyong tinukoy mo. Maaari mong pahabain ang isang pahayag na KUNG sa pamamagitan ng paggamit ng mga pahayag ng ELSE at ELSE IF, na hahawak sa iba't ibang mga resulta. Ang ELSE ay magkakabisa kapag ang isang pagsubok sa KUNG isang expression ay nagbabalik ng MALI. ELSE KUNG pinapayagan kang isama sa isang solong linya ang isang tseke para sa iba't ibang mga kundisyon sa KON para sa ilang mga sitwasyon. Suriin ang code ng programa sa ibaba upang maunawaan kung paano nakikipag-ugnayan ang lahat ng mga opsyong ito.

   # isama ang stdio.h> int main () {int age; printf ("Mangyaring ipasok ang iyong kasalukuyang edad:"); scanf ("% d", at edad); kung (edad = 12) {printf ("Bata ka pa! n"); } iba pa kung (edad 20) {printf ("Mabuti na maging isang tinedyer! n"); } iba pa kung (edad 40) {printf ("Ikaw ay bata pa sa puso! n"); } iba pa {printf ("Ang karunungan ay darating sa paglipas ng mga taon. n"); } ibalik ang 0; }

   • Binabasa ng programa ang pag-input ng gumagamit at nilalakad ito sa isang serye ng sunud-sunod na mga kondisyonal na pagsusuri. Kung natutugunan ng ipinasok na numero ang unang kundisyon, ipinapakita ang unang expression printf... Kung ang unang kundisyon ay hindi natutugunan, pagkatapos ay ang tseke ay nagpapatuloy sa bawat susunod na KUNG KAHULANG kundisyon hanggang sa matagpuan ang isang tunay na resulta. Kung wala sa mga kundisyong ito ang natutugunan, ang impormasyon ay naproseso ng huling pahayag ng ELSE sa pagtatapos ng programa.

Bahagi 4 ng 6: Pag-aaral na gumana sa mga loop

1. 1 Maunawaan kung paano gumagana ang mga loop. Ang mga loop ay isa sa pinakamahalagang aspeto ng pagprograma, dahil pinapayagan ka nilang muling tumakbo sa mga indibidwal na mga bloke ng code hanggang sa matugunan ang isang tiyak na kundisyon.Ginagawa nitong mas madali ang pagtatala ng programatic na paulit-ulit na mga pagkilos at nai-save ka mula sa pagkakaroon ng pagsusulat ng mga bagong kundisyon sa tuwing nais mong gumawa ng isang bagay ang programa.
   • Mayroong tatlong pangunahing uri ng mga loop: PARA, BASTA, at GAWIN ... HABANG.
2. 2 Gumamit ng isang FOR loop. Ito ang pinakatanyag at kapaki-pakinabang ng mga loop. Patuloy itong isinasagawa ang ibinigay na pagpapaandar hanggang sa matugunan ang mga kundisyon na itinakda sa PARA SA. PARA sa mga loop ay nangangailangan ng tatlong mga kundisyon upang matukoy: ang variable na naisasimulan, ang kundisyon na natutugunan, at kung paano na-update ang halaga ng variable. Kung hindi mo kailangan ang lahat ng tatlong mga kondisyong ito, kailangan mong iwanan ang isang puwang na may isang titikting titik sa kanilang lugar, kung saan ang loop ay magiging walang hanggan.

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

   • Sa program sa itaas, ang paunang halaga ng variable ay y ay zero, at ang loop ay nagpapatuloy hangga't ang halaga ng variable ay mananatiling mas mababa sa 15. Sa tuwing makikita ang isang bagong halaga y, tataas ito ng isa at inuulit ang ikot. Kapag ang variable y lumalabas na 15, nagtatapos ang ikot.
3. 3 Gumamit ng isang WHILE loop. Habang ang mga loop ay mas simple kaysa sa SA mga loop. Nagtatakda lamang sila ng isang kundisyon at tumatakbo ang loop hangga't natutugunan ang kundisyong ito. Hindi mo kailangang simulan o i-update ang variable dito, ngunit maaari mo itong gawin sa pangunahing katawan ng loop mismo.

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

   • Koponan y ++ nagdaragdag ng isa sa halaga ng isang variable y sa tuwing naisasagawa ang loop. Kapag ang variable y nagiging pantay sa 16 (tandaan na ang loop ay dapat tumakbo hangga't ang variable mas mababa o pantay 15), nagtatapos ang ikot.
4. 4 Mag-apply ng isang loop GAWIN...SABI... Ang siklo na ito ay lubhang kapaki-pakinabang kapag ang pagpapatakbo ng pag-ikot ay kailangang gumanap kahit isang beses. Sa PARA at habang ang mga loop, ang kalagayan ay nasuri sa simula pa lamang, iyon ay, kung ang isang maling resulta ay natanggap, ang operasyon na tinukoy ng kundisyon ay nilaktawan at hindi ginanap. Ang DO ... Habang ang tseke ay sinusuri ang mga kundisyon sa pinakadulo, na nagbibigay-daan sa iyo upang maisagawa ang mga pagkilos na loop nang hindi bababa sa isang beses.

   # isama ang stdio.h> int main () {int y; y = 5; gawin ang {printf ("Tumatakbo ang loop! n"); } habang (y! = 5); getchar (); }

   • Ipapakita ng loop na ito ang ibinigay na mensahe, kahit na ang pagsubok sa kundisyon ay hindi totoo. Variable y ay nakatakda sa limang, at ang loop ay dapat ulitin kung ang variable ay hindi katumbas ng lima, kaya't lumabas ang loop. Ang mensahe ay ipinapakita sa screen nang isang beses, dahil ang kondisyon ay nasuri lamang sa pinakadulo.
   • Ang sugnay na WHILE sa DO ... WHILE loop ay dapat magtapos sa isang kalahating titik. Ito ang nag-iisang loop na nangangailangan ng isang kalahating titik sa dulo.

Bahagi 5 ng 6: Paggamit ng Mga Pag-andar

1. 1 Maunawaan ang mga pangunahing kaalaman sa paggamit ng mga pag-andar. Ang mga pagpapaandar ay may sariling mga bloke ng code na maaari mong tawagan sa iba't ibang bahagi ng iyong programa. Ginagawa nilang mas madali upang ulitin ang code at tulungan itong gawing mas madaling maunawaan ang mga prinsipyo mismo ng programa at upang higit itong baguhin. Maaaring isama ng mga pagpapaandar ang lahat ng mga trick na nabanggit sa itaas, at kahit na iba pang mga uri ng pag-andar.
   • Linya pangunahing () sa pinakadulo simula ng lahat ng mga halimbawa sa itaas ay isang pagpapaandar, tulad ng string getchar ()
   • Mahalaga ang mga pagpapaandar para sa pag-aayos ng iyong code nang mahusay at ginagawang mas madaling basahin. Gamitin nang tama ang mga pagpapaandar upang mabuo ang iyong programa nang may katwiran.
2. 2 Magsimula sa pamamagitan ng pagdedeklara ng mga pagpapaandar. Mahusay na ideklara ang mga pagpapaandar sa pinakadulo simula ng iyong programa upang ipahiwatig ang kanilang layunin bago ka magsimula sa pag-coding. Ang pangunahing syntax para sa mga pagpapaandar ay "pangalan ng return_unction (argumento 1, argumento 2, at iba pa);". Halimbawa, upang tukuyin ang isang pagpapaandar na nagdaragdag ng dalawang numero, isusulat mo ang sumusunod na code:

   int add (int x, int y);

   • Ipapahayag nito ang isang pagpapaandar na nagdaragdag ng dalawang integer (x at y) at pagkatapos ay ibabalik ang kabuuan bilang isang integer.
3. 3 Isama ang pagpapaandar sa programa. Ang dating idineklarang pagpapaandar ay maaaring magamit upang lumikha ng isang programa na tumatagal ng dalawang numero na ipinasok ng gumagamit at isasama sila. Papayagan ka ng nasabing programa na ipakita ang pagpapatakbo ng "idagdag" na pag-andar at maunawaan kung paano mo ito magagamit upang pamahalaan ang ipinasok na data.

   # isama ang stdio.h> int idagdag (int x, int y); int main () {int x; int y; printf ("Ipasok ang dalawang numero upang idagdag:"); scanf ("% d", & x); scanf ("% d", & y); printf ("Ang kabuuan ng mga inilagay na numero ay% d n", idagdag (x, y)); getchar (); } int add (int x, int y) {return x + y; }

   • Tandaan na ang deklarasyon ng pagpapaandar ay nasa tuktok pa rin ng programa. Sinasabi nito sa tagatala kung ano ang aasahan kapag tinawag ang pagpapaandar at kung ano ang eksaktong dapat itong ibalik bilang isang resulta. Kailangan lamang ito kung nais mong tawagan ang isang pagpapaandar sa ibaba sa teksto ng programa. Pag-andar ng programa magdagdag () maaaring maging hanggang sa gumana pangunahing ()at ang resulta ay magiging pareho nang walang deklarasyon.
   • Ang aktwal na pagpapaandar ng isang partikular na pagpapaandar ay natutukoy sa pagtatapos ng programa. Pag-andar pangunahing () nangongolekta ng numerong data mula sa gumagamit at pagkatapos ay pinapakain ito sa isang pagpapaandar magdagdag () para sa pagpoproseso. At ang pagpapaandar magdagdag () ipinapasa ang natapos na resulta pabalik sa pagpapaandar pangunahing ()
   • Kapag ang pagpapaandar magdagdag () ay idineklara na, maaari itong tawagan kahit saan sa programa.

Bahagi 6 ng 6: Karagdagang pag-aaral ng wika

1. 1 Maghanap ng mga libro sa C programming. Sinasaklaw lamang ng artikulong ito ang mga pangunahing kaalaman sa wika, na nakasalalay sa ibabaw ng mga kakayahan sa C programa at lahat ng nauugnay na impormasyon. Ang isang mahusay na libro ay makakatulong sa iyo na malutas ang mga problemang lilitaw at i-save ka ng maraming sakit ng ulo sa proseso ng karagdagang pagtatrabaho sa wika.
2. 2 Sumali sa iba't ibang mga pamayanan sa pagprograma. Maraming mga pamayanan, kapwa online at sa totoong mundo, na nakatuon sa pagprograma sa bawat posibleng wika. Maghanap para sa isang bagay tulad ng "C programmer 'pool" upang magbahagi ng mga halimbawa ng code at ideya. Malapit mong mapansin na marami kang natutunan mula sa pamayanan.
   • Dumalo ng mga hackathons hangga't maaari. Ito ang mga kaganapan kung saan ang mga koponan ng programmer at indibidwal na developer ay dapat lumikha ng isang programa sa isang limitadong dami ng oras at maghanap ng isang tukoy na solusyon para dito, habang ipinapakita ang likas na talino sa talino. Kaya maaari mong matugunan ang maraming magagaling na programmer, at ang mga hackathon mismo ay regular na gaganapin sa buong mundo.
3. 3 Mag-sign up para sa mga kurso. Hindi mo kailangang pumunta sa kolehiyo upang malaman ang mag-code, ngunit ang pagdalo sa ilang klase lamang ng nauugnay na kurso sa pagprograma ay magdaragdag ng maraming sa iyong kaalaman. Walang makakatalo sa tulong ng mga taong maraming karanasan sa praktikal na paggamit ng wika. Karaniwan ang mga kurso ay inaalok ng iba't ibang mga sentro ng pamayanan, mga propesyonal na kolehiyo at unibersidad, na pinapayagan kang mag-aral ng ilang mga agham ng computer nang hindi na kinakailangang pumunta sa isang institusyong pang-edukasyon para sa isang ganap na edukasyon.
4. 4 Isaalang-alang ang pag-aaral ng C ++. Kapag komportable ka na sa wikang C programa, wala kang pipigilan na tumingin nang malapit sa C ++. Ito ay isang mas modernong bersyon ng wikang C na may higit na kakayahang umangkop. Ang C ++ ay na-modelo pagkatapos ng isang object-oriented program paradigm, kaya ang pag-alam sa C ++ ay magbibigay-daan sa iyo upang lumikha ng mga makapangyarihang programa para sa halos anumang operating system.

Mga Tip

• Tiyaking magbigay ng puna sa iyong code. Makakatulong ang mga komento hindi lamang sa mga susubukan pang maunawaan ang iyong code sa paglaon, ngunit papayagan din kang matandaan kung ano, saan at bakit ka nagsulat. Marahil, sa ngayon ay alam na alam mo kung ano ang eksaktong ginagawa mo, ngunit pagkatapos ng dalawa o tatlong buwan ay marami ka nang makakalimutan.
• Huwag kalimutan na wakasan ang printf (), scanf (), getch (), at mga katulad nito sa isang semicolon (;), ngunit huwag kailanman ilagay ang character na ito pagkatapos ng isang sugnay na KUNG HABI o PARA sa mga loop.
• Nahaharap sa isang error sa pag-syntax ng pag-complo na nakakagambala sa iyo, subukang maghanap ng mga paliwanag nang hindi tama gamit ang isang search engine sa Google (o anumang iba pang search engine). Mayroong isang pagkakataon na ang isang tao ay nakaranas ng parehong error bago ka at nai-publish ang isang posibleng pag-aayos para dito.
• Ang iyong source code ay dapat mayroong isang *. C extension upang maunawaan ng computer na ito ay isang C source file.
• Laging tandaan na sa pagsasagawa, ipinanganak ang pagiging perpekto. Kung mas maraming pag-e-program, mas mahusay ang iyong kakayahan.Samakatuwid, magsimula sa simple, maikling mga programa upang makakuha ng kaunting pamilyar, at kapag may kumpiyansa ka nang mag-programa, magpatuloy sa paglikha ng mas kumplikadong mga programa.
• Alamin ang istraktura nang lohikal upang matulungan kang malutas ang iba't ibang mga problema kapag nagsusulat ng code.