Ang C ay isa sa mga mas matandang wika sa pagprograma. Ito ay binuo noong dekada 70, ngunit napakalakas pa rin nito salamat sa kung gaano ito mababang antas. Ang Pag-aaral C ay isang mahusay na paraan upang ipakilala ang iyong sarili sa mas kumplikadong mga wika din, at ang kaalamang nakukuha mo ay magiging kapaki-pakinabang sa halos bawat wika ng programa at maaaring makatulong sa iyo na makapunta sa pag-unlad ng app. Upang malaman kung paano magsimulang mag-program sa C, tingnan ang Hakbang 1 sa ibaba.
Mga hakbang
Bahagi 1 ng 6: Paghahanda
Hakbang 1. Mag-download at mag-install ng isang tagatala
Ang C code ay kailangang maiipon ng isang programa na nagpapakahulugan sa code sa mga signal na mauunawaan ng makina. Ang mga tagataguyod ay karaniwang libre, at ang iba't ibang mga tagataguyod ay magagamit para sa iba't ibang mga operating system.
- Para sa Windows, subukan ang Microsoft Visual Studio Express o MinGW.
- Para sa Mac, ang XCode ay isa sa pinakamahusay na C compiler.
- Para sa Linux, ang gcc ay isa sa mga pinakatanyag na pagpipilian.
Hakbang 2. Maunawaan ang mga pangunahing kaalaman
Ang C ay isa sa mga mas matandang wika ng programa, at maaaring maging napakalakas. Dinisenyo ito para sa mga operating system ng Unix, ngunit na-port at pinalawak para sa halos lahat ng mga operating system. Ang modernong bersyon ng C ay C ++.
Ang C ay mahalagang binubuo ng mga pagpapaandar, at sa mga pagpapaandar na ito maaari kang gumamit ng mga variable, kondisyon na pahayag, mga loop upang mag-imbak at manipulahin ang data
Hakbang 3. Suriin ang ilang pangunahing code
Tingnan ang (napaka) pangunahing programa sa ibaba upang makakuha ng isang magandang ideya tungkol sa kung paano gumagana ang ilan sa iba't ibang mga aspeto ng wika, at upang makakuha ng isang ideya kung paano gumana ang mga programa.
#include int main () {printf ("Hello, World! / n"); getchar (); ibalik ang 0; }
- Ang utos na # isama ay nangyayari bago magsimula ang programa, at naglo-load ng mga aklatan na naglalaman ng mga pagpapaandar na kailangan mo. Sa halimbawang ito, hinayaan tayo ng stdio.h na gamitin ang mga pagpapaandar ng printf () at getchar ().
- Ang int main () utos ay nagsasabi sa tagatala na ang programa ay nagpapatakbo ng pagpapaandar na tinatawag na "pangunahing" at ibabalik nito ang isang integer kapag natapos na ito. Ang lahat ng mga programa ng C ay nagpapatakbo ng isang "pangunahing" pagpapaandar.
- Ipinapahiwatig ng {} na ang lahat sa loob ng mga ito ay bahagi ng pagpapaandar. Sa kasong ito, ipinapahiwatig nila na ang lahat sa loob ay bahagi ng "pangunahing" pag-andar.
- Ipinapakita ng pagpapaandar ng printf () ang mga nilalaman ng panaklong sa screen ng gumagamit. Tinitiyak ng mga quote na ang string sa loob ay na-print nang literal. Sinasabi ng pagkakasunud-sunod ng / n sa tagatala na ilipat ang cursor sa susunod na linya.
- Ang; nagsasaad ng pagtatapos ng isang linya. Karamihan sa mga linya ng C code ay kailangang magtapos sa isang kalahating titik.
- Sinasabi ng utos ng getchar () sa tagatala na maghintay para sa isang input ng keystroke bago lumipat. Kapaki-pakinabang ito sapagkat maraming mga tagatala ang tatakbo sa programa at agad na isara ang window. Pinipigilan nito ang programa mula sa pagtatapos hanggang ang isang key ay pinindot.
- Ang utos ng return 0 ay nagpapahiwatig ng pagtatapos ng pagpapaandar. Tandaan kung paano ang "pangunahing" pagpapaandar ay isang int function. Nangangahulugan ito na kakailanganin ang isang integer upang maibalik kapag natapos ang programa. Ang isang "0" ay nagpapahiwatig na ang programa ay gumaganap nang tama; anumang iba pang mga numero ay nangangahulugan na ang programa ay tumakbo sa isang error.
Hakbang 4. Subukang i-compile ang programa
Ipasok ang code sa iyong code editor at i-save ito bilang isang "*.c" na file. I-compile ito sa iyong tagatala, karaniwang sa pamamagitan ng pag-click sa pindutan na Bumuo o Patakbuhin.
Hakbang 5. Palaging magkomento sa iyong code
Ang mga komento ay bahagi ng code na hindi naipon, ngunit pinapayagan kang ipaliwanag kung ano ang nangyayari. Kapaki-pakinabang ito para sa pagpapaalala sa iyong sarili kung para saan ang iyong code, at para sa pagtulong sa ibang mga developer na maaaring tumitingin sa iyong code.
- Upang magkomento sa lugar ng C / * sa simula ng komento at * / sa dulo.
- Magkomento sa lahat maliban sa pinaka pangunahing mga bahagi ng iyong code.
- Maaaring magamit ang mga komento upang mabilis na alisin ang mga bahagi ng iyong code nang hindi tinatanggal ang mga ito. Isama lamang ang code na nais mong ibukod sa mga tag ng komento at pagkatapos ay ipagsama. Kung nais mong idagdag ang code, alisin ang mga tag.
Bahagi 2 ng 6: Paggamit ng Mga variable
Hakbang 1. Maunawaan ang pagpapaandar ng mga variable
Pinapayagan ka ng mga variable na mag-imbak ng data, alinman sa mga pagkalkula sa programa o mula sa pag-input ng gumagamit. Kailangang tukuyin ang mga variable bago mo magamit ang mga ito, at maraming uri upang pumili mula sa.
Ang ilan sa mga mas karaniwang uri ng variable ay may kasamang int, char, at float. Ang bawat isa ay nag-iimbak ng magkakaibang uri ng data
Hakbang 2. Alamin kung paano idineklara ang mga variable
Ang mga variable ay kailangang maitatag, o "ideklara", bago ito magamit ng programa. Idineklara mo ang isang variable sa pamamagitan ng pagpasok ng uri ng data na sinusundan ng pangalan ng variable. Halimbawa, ang mga sumusunod ay lahat ng wastong deklarasyon ng variable:
lumutang x; pangalan ng karakter; int a, b, c, d;
- Tandaan na maaari mong ideklara ang maraming mga variable sa parehong linya, hangga't ang mga ito ay ang parehong uri. Paghiwalayin lamang ang mga pangalan ng variable sa mga kuwit.
- Tulad ng maraming mga linya sa C, ang bawat variable na linya ng deklarasyon ay kailangang magtapos sa isang kalahating titik.
Hakbang 3. Alamin kung saan ipahayag ang mga variable
Dapat ideklara ang mga variable sa simula ng bawat block ng code (Ang mga bahagi ng iyong code na nakapaloob sa {} mga braket). Kung susubukan mong ideklara ang isang variable sa ibang pagkakataon sa bloke, ang programa ay hindi gagana nang tama.
Hakbang 4. Gumamit ng mga variable upang maiimbak ang input ng gumagamit
Ngayon alam mo na ang mga pangunahing kaalaman sa kung paano gumagana ang mga variable, maaari kang magsulat ng isang simpleng programa na mag-iimbak ng input ng gumagamit. Gumagamit ka ng isa pang pagpapaandar sa programa, na tinatawag na scanf. Hinahanap ng pagpapaandar na ito ang input na ibinigay para sa mga tukoy na halaga.
# isama ang int main () {int x; printf ("Magpasok ng isang numero:"); scanf ("% d", & x); printf ("Nagpasok ka ng% d", x); getchar (); ibalik ang 0; }
- Sinasabi sa string na "% d" ang scanf na maghanap ng mga integer sa input ng gumagamit.
- Ang & bago ang variable x ay nagsasabi sa scanf kung saan mahahanap ang variable upang mabago ito, at maiimbak ang integer sa variable.
- Basahin ng huling utos ng printf ang input integer sa gumagamit.
Hakbang 5. Manipula ang iyong mga variable
Maaari mong gamitin ang mga expression sa matematika upang manipulahin ang data na naimbak mo sa iyong mga variable. Ang pinakamahalagang pagkakaiba na dapat tandaan para sa mga expression ng matematika ay ang isang solong = nagtatakda ng halaga ng variable, habang inihambing ng == ang mga halaga sa magkabilang panig upang makita kung pantay ang mga ito.
x = 3 * 4; Itinatakda ng / * ang "x" sa 3 * 4, o 12 * / x = x + 3; / * nagdaragdag ng 3 sa orihinal na halaga ng "x", at itinatakda ang bagong halaga bilang variable * / x == 15; / * suriin upang makita kung ang "x" ay katumbas ng 15 * / x <10; / * sinusuri kung ang halaga ng "x" ay mas mababa sa 10 * /
Bahagi 3 ng 6: Paggamit ng Mga Pahayag na Kondisyon
Hakbang 1. Maunawaan ang mga pangunahing kaalaman sa mga kondisyong pahayag
Ang mga kondisyon na pahayag ay kung ano ang nagtutulak sa karamihan ng mga programa. Ang mga ito ay mga pahayag na tinutukoy na maging TUNAY o MALI, at pagkatapos ay kumilos batay sa resulta. Ang pinaka-pangunahing mga pahayag ay ang kung pahayag.
Ang TAMA at MALI na gawain ay naiiba sa C kaysa sa maaaring nakasanayan mo. Ang mga TUNAY na pahayag ay laging nagtatapos na katumbas ng isang nonzero na numero. Kapag nagsagawa ka ng mga paghahambing, kung ang resulta ay TUNAY pagkatapos ay ibabalik ang isang "1". Kung ang resulta ay MALI, pagkatapos ang isang "0" ay ibabalik. Ang pag-unawa dito ay makakatulong sa iyo na makita kung paano iproseso ang mga pahayag
Hakbang 2. Alamin ang pangunahing mga kondisyunal na operator
Ang mga kondisyon na pahayag ay umiikot sa paggamit ng mga operator ng matematika na ihinahambing ang mga halaga. Naglalaman ang sumusunod na 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 sa * /
10> 5 TUNAY 6 <15 TUNAY 8> = 8 TUNAY 4 <= 8 TUNAY 3 == 3 TUNAY 4! = 5 TUNAY
Hakbang 3. Sumulat ng isang pangunahing pahayag na KUNG
Maaari mong gamitin ang mga pahayag ng IF upang matukoy kung ano ang susunod na dapat gawin ng programa pagkatapos masuri ang pahayag. Maaari mo itong pagsamahin sa iba pang mga kondisyonal na pahayag sa paglaon upang lumikha ng malakas na maraming pagpipilian, ngunit sa ngayon sumulat ng isang simpleng isa upang masanay sa kanila.
# isama ang int main () {kung (3 <5) printf ("3 ay mas mababa sa 5"); getchar (); }
Hakbang 4. Gumamit ng IBA / IBA KUNG mga pahayag upang mapalawak ang iyong mga kundisyon
Maaari kang bumuo sa mga pahayag na KUNG sa pamamagitan ng paggamit ng mga pahayag ng ELSE at ELSE IF upang hawakan ang iba't ibang mga resulta. Tumatakbo ang ibang pahayag kung MALI ang pahayag na KUNG. ELSE KUNG mga pahayag ay nagbibigay-daan sa iyo upang isama ang maraming mga pahayag sa IF sa isang code block upang hawakan ang iba't ibang mga kaso. Tingnan ang halimbawang programa sa ibaba upang makita kung paano sila nakikipag-ugnayan.
# isama ang int main () {int age; printf ("Mangyaring ipasok ang iyong kasalukuyang edad:"); scanf ("% d", at edad); kung (edad <= 12) {printf ("Bata ka lang! / n"); } iba pa kung (edad <20) {printf ("Ang pagiging isang tinedyer ay medyo mahusay! / n"); } iba pa kung (edad <40) {printf ("Bata ka pa rin sa puso! / n"); } iba pa {printf ("Sa edad ay dumarating ang karunungan. / n"); } ibalik ang 0; }
Kinukuha ng programa ang input mula sa gumagamit at dadalhin ito sa pamamagitan ng mga pahayag na KUNG. Kung natutugunan ng numero ang unang pahayag, ibinalik ang unang pahayag ng printf. Kung hindi nito nasiyahan ang unang pahayag, ito ay dadalhin sa bawat pahayag ng ELSE IF hanggang sa matagpuan nito ang isa na gumagana. Kung hindi ito tumutugma sa anuman sa kanila, dumadaan ito sa pahayag na ELSE sa dulo
Bahagi 4 ng 6: Mga Loop sa Pagkatuto
Hakbang 1. Maunawaan kung paano gumagana ang mga loop
Ang mga loop ay isa sa pinakamahalagang aspeto ng programa, dahil pinapayagan ka nilang ulitin ang mga bloke ng code hanggang sa matugunan ang mga tukoy na kundisyon. Maaari nitong gawing napakadaling ipatupad ang mga paulit-ulit na pagkilos, at pinipigilan kang magsulat ng mga bagong kondisyong pahayag sa tuwing nais mong may mangyari.
Mayroong tatlong pangunahing uri ng mga loop: PARA SA, habang, at GAWIN … HABANG
Hakbang 2. Gumamit ng isang PARA sa loop
Ito ang pinakakaraniwan at kapaki-pakinabang na uri ng loop. Ito ay magpapatuloy sa pagpapatakbo ng pagpapaandar hanggang sa matugunan ang mga kundisyon na itinakda sa FOR loop. PARA sa mga loop ay nangangailangan ng tatlong mga kundisyon: pagsisimula ng variable, ang kundisyon upang matugunan, at ang paraan ng pag-update ng variable. Kung hindi mo kailangan ang lahat ng mga kundisyong ito, kakailanganin mong mag-iwan ng isang blangko na puwang na may isang kalahating titik, kung hindi man ang loop ay tatakbo magpakailanman.
# isama ang int main () {int y; para sa (y = 0; y <15; y ++;) {printf ("% d / n", y); } getchar (); }
Sa program sa itaas, ang y ay nakatakda sa 0, at ang loop ay nagpapatuloy hangga't ang halaga ng y ay mas mababa sa 15. Sa tuwing ang halaga ng y ay nai-print, 1 ay idinagdag sa halaga ng y at ang loop ay paulit-ulit. Kapag y = 15, masisira ang loop
Hakbang 3. Gumamit ng isang WHILE loop
Habang ang mga loop ay mas simple kaysa sa SA mga loop. Mayroon lamang silang isang kundisyon, at ang loop ay kumikilos hangga't totoo ang kondisyong iyon. Hindi mo kailangang simulan o i-update ang variable, kahit na magagawa mo iyon sa pangunahing katawan ng loop.
# isama ang int main () {int y; habang (y <= 15) {printf ("% d / n", y); y ++; } getchar (); }
Ang utos na y ++ ay nagdaragdag ng 1 sa variable ng y sa tuwing naisasagawa ang loop. Kapag ang y ay umabot sa 16 (tandaan, ang loop na ito ay napupunta hangga't ang y ay mas mababa sa o katumbas ng 15), masira ang loop
Hakbang 4. Gumamit ng isang DO
.. WHILE loop.
Ang loop na ito ay lubhang kapaki-pakinabang para sa mga loop na nais mong matiyak na tumakbo nang hindi bababa sa isang beses. Sa PARA at habang ang mga loop, ang kalagayan ay nasuri sa simula ng loop, nangangahulugang hindi ito maaaring pumasa at mabigo kaagad. GAWIN … Habang ang mga loop ay suriin ang mga kundisyon sa dulo ng loop, tinitiyak na ang loop ay gumaganap ng hindi bababa sa isang beses.
# isama ang int main () {int y; y = 5; gawin ang {printf ("Tumatakbo ang loop na ito! / n"); } habang (y! = 5); getchar (); }
- Ipapakita ng loop na ito ang mensahe kahit na ang kondisyon ay MALI. Ang variable y ay nakatakda sa 5 at ang WHILE loop ay nakatakda upang tumakbo kapag ang y ay hindi katumbas ng 5, kaya natatapos ang loop. Na-print na ang mensahe dahil ang kondisyon ay hindi naka-check hanggang sa katapusan.
- Ang WHILE loop sa isang GAWIN … HABANG ang hanay ay dapat tapusin sa isang kalahating titik. Ito lamang ang oras na ang isang loop ay natapos sa isang kalahating titik.
Bahagi 5 ng 6: Paggamit ng Mga Pag-andar
Hakbang 1. Maunawaan ang mga pangunahing kaalaman sa pag-andar
Ang mga pagpapaandar ay may sariling mga bloke ng code na maaaring tawagan ng iba pang mga bahagi ng programa. Ginagawa nilang napakadali upang ulitin ang code, at nakakatulong silang gawing mas simple ang programa na basahin at baguhin. Maaaring isama ng mga pagpapaandar ang lahat ng mga diskarteng dati nang natakpan na natutunan sa artikulong ito, at kahit na iba pang mga pagpapaandar.
- Ang pangunahing () linya sa simula ng lahat ng mga halimbawa sa itaas ay isang pagpapaandar, tulad ng getchar ()
- Mahalaga ang mga pagpapaandar sa mahusay at madaling basahin na code. Gumamit ng mahusay na paggamit ng mga pagpapaandar upang i-streamline ang iyong programa.
Hakbang 2. Magsimula sa isang balangkas
Ang mga pagpapaandar ay pinakamahusay na nilikha kapag binabalangkas mo kung ano ang nais mong makamit bago mo simulan ang aktwal na pag-coding. Ang pangunahing syntax para sa mga pagpapaandar ay "pangalan ng return_type (argument1, argument2, atbp.);". Halimbawa, upang lumikha ng isang pagpapaandar na nagdaragdag ng dalawang numero:
int add (int x, int y);
Lilikha ito ng isang pagpapaandar na nagdaragdag ng dalawang mga integer (x at y) at pagkatapos ay ibabalik ang kabuuan bilang isang integer
Hakbang 3. Idagdag ang pagpapaandar sa isang programa
Maaari mong gamitin ang balangkas upang lumikha ng isang programa na tumatagal ng dalawang mga integer na ipinasok ng gumagamit at pagkatapos ay idinagdag silang magkasama. Tutukuyin ng programa kung paano gumagana ang function na "idagdag" at gamitin ito upang manipulahin ang mga numero ng pag-input.
# isama ang int add (int x, int y); int main () {int x; int y; printf ("Ipasok ang dalawang numero upang maidagdag:"); scanf ("% d", & x); scanf ("% d", & y); printf ("Ang kabuuan ng iyong mga numero ay% d / n", idagdag (x, y)); getchar (); } int add (int x, int y) {return x + y; }
- Tandaan na ang balangkas ay matatagpuan pa rin sa tuktok ng programa. Sinasabi nito sa tagatala kung ano ang aasahan kapag tinawag ang pagpapaandar at kung ano ang ibabalik nito. Kailangan lamang ito kung nais mong tukuyin ang pagpapaandar sa ibang pagkakataon sa programa. Maaari mong tukuyin ang add () bago ang pangunahing () pagpapaandar at ang resulta ay magiging pareho nang walang balangkas.
- Ang aktwal na pag-andar ng pagpapaandar ay tinukoy sa ilalim ng programa. Kinokolekta ng pangunahing () pagpapaandar ang mga integer mula sa gumagamit at pagkatapos ay ipinapadala ang mga ito sa pag-andar ng add () upang maproseso. Ang function na magdagdag () pagkatapos ay ibabalik ang mga resulta sa pangunahing ()
- Ngayon ang idagdag () ay tinukoy, maaari itong tawagan saanman sa programa.
Bahagi 6 ng 6: Pagpapatuloy sa Alamin
Hakbang 1. Maghanap ng ilang mga libro sa C programa
Saklaw ng artikulong ito ang mga pangunahing kaalaman, ngunit gasgas lamang ito sa ibabaw ng C program at lahat ng nauugnay na kaalaman. Ang isang mahusay na libro ng sanggunian ay makakatulong sa iyo na malutas ang mga problema at mai-save ka mula sa maraming sakit ng ulo sa kalsada.
Hakbang 2. Sumali sa ilang mga pamayanan
Maraming mga pamayanan, kapwa online at sa totoong mundo, na nakatuon sa pagprograma at lahat ng mga wikang kinakailangan. Humanap ng ilang magkaparehong C programmer upang ipagpalit ang code at mga ideya, at malalaman mo sa lalong madaling panahon ang iyong sarili.
Dumalo ng ilang mga hack-a-thons kung posible. Ito ang mga kaganapan kung saan ang mga koponan at indibidwal ay may mga limitasyon sa oras upang makabuo ng mga programa at solusyon, at kadalasang nagtataguyod ng maraming pagkamalikhain. Maaari mong matugunan ang maraming magagaling na programmer sa ganitong paraan, at regular na nangyayari ang mga hack-a-thons sa buong mundo
Hakbang 3. Kumuha ng ilang mga klase
Hindi mo na kailangang bumalik sa paaralan para sa isang degree sa Computer Science, ngunit ang pagkuha ng ilang mga klase ay maaaring gumawa ng mga kababalaghan para sa iyong pag-aaral. Walang makakatalo sa tulong ng kamay mula sa mga taong may kasanayan sa wika. Madalas kang makakahanap ng mga klase sa mga lokal na sentro ng pamayanan at junior kolehiyo, at papayagan ka ng ilang pamantasan na i-audit ang kanilang mga programa sa agham ng computer nang hindi na kinakailangang magpatala.
Hakbang 4. Isaalang-alang ang pag-aaral ng C ++
Sa sandaling mahawakan mo ang C, hindi masaktan na magsimulang tingnan ang C ++. Ito ang mas modernong bersyon ng C, at nagbibigay-daan para sa higit na kakayahang umangkop. Ang C ++ ay dinisenyo kasama ang paghawak ng bagay sa isip, at ang pag-alam sa C ++ ay maaaring paganahin kang lumikha ng mga makapangyarihang programa para sa halos anumang operating system.
Mga Tip
- Palaging magdagdag ng mga komento sa iyong mga programa. Hindi lamang ito nakakatulong sa iba na maaaring tingnan ang source code nito, ngunit makakatulong din ito sa iyo na matandaan kung ano ang sinusulat mo at kung bakit. Maaari mong malaman kung ano ang iyong ginagawa sa sandaling isinulat mo ang iyong code, ngunit pagkatapos ng dalawa o tatlong buwan, hindi mo na masyadong maaalala.
- Palaging tandaan na tapusin ang isang pahayag tulad ng printf (), scanf (), getch (), atbp na may isang semi-colon (;) ngunit huwag ipasok ang mga ito pagkatapos ng isang pahayag na kontrol tulad ng 'kung', 'habang' o 'para sa' mga loop.
- Kapag nakakaranas ng isang error sa syntax kapag nag-iipon, kung stumped ka, maghanap sa Google (o ibang search engine) na may natanggap mong error. Ang mga posibilidad na ang isang tao ay nakaranas na ng parehong problema at nag-post ng isang solusyon.
- Ang iyong source code ay kailangang magkaroon ng isang *.c extension, upang maunawaan ng iyong tagabuo na ito ay isang C source file.
- Laging tandaan na ang pagsasanay ay ginagawang perpekto. Ang mas maraming pagsasanay sa pagsulat ng isang programa, mas mahusay kang makukuha rito. Kaya't magsimula ka sa simple, maikling mga programa hanggang sa makuha mo ang iyong pagtapak, at pagkatapos ay tiwala ka na maaari kang magpatuloy sa mas kumplikado.
- Subukang malaman ang pagbuo ng lohika. Nakakatulong ito upang matugunan ang iba't ibang mga problema habang nagsusulat ng isang code.
