Nilalaman

• Upang humakbang
• Bahagi 1 ng 6: Ang mga paghahanda
• Bahagi 2 ng 6: Paggamit ng mga variable
• Bahagi 3 ng 6: Mga kondisyon na pahayag
• Bahagi 4 ng 6: Mga loop
• Bahagi 5 ng 6: Paggamit ng mga tampok
• Bahagi 6 ng 6: Patuloy na matuto
• Mga Tip

Ang C ay isa sa mga mas matandang wika sa pagprograma. Ito ay binuo noong dekada 1970 ngunit kilala pa rin bilang isang malakas na wika dahil ito ay isang mababang antas na wika na malapit sa wika ng makina. Ang Pag-aaral C ay isang mahusay na pagpapakilala sa pag-program sa mas kumplikadong mga wika, at ang kaalamang nakukuha mo ay kapaki-pakinabang para sa halos anumang wika sa pagprograma, at maaaring makatulong sa iyo na sa kalaunan ay makarating sa pag-unlad ng app. Magbasa pa upang makapagsimula sa pag-program sa C.

Upang humakbang

Bahagi 1 ng 6: Ang mga paghahanda

1. Mag-download at mag-install ng isang tagatala. Ang C code ay dapat munang maipon ng isang programa na maaaring bigyang kahulugan ang code at i-convert ito sa isang wikang mauunawaan ng makina. Ang mga tagatala ay karaniwang magagamit nang libre, at maaari kang mag-download ng iba't ibang mga tagatala para sa bawat operating system.
   • Para sa Windows, Microsoft Visual Studio Express o MinGW.
   • Para sa Mac, ang XCode ay isa sa mga pinakamahusay na C compiler.
   • Sa Linux, ang gcc ay isa sa mga pinakatanyag na pagpipilian.
2. Ang pangunahing kaalaman. Ang C ay isa sa mga mas matandang wika ng programa, ngunit napakalakas. Una itong idinisenyo para sa operating system ng Unix, ngunit sa kalaunan ay naging karaniwan sa halos bawat system. Ang "modernong" bersyon ng C ay C ++.
   • Ang C ay binubuo ng lahat ng mga pagpapaandar, at sa loob ng mga pagpapaandar na ito maaari kang gumamit ng mga variable, kondisyon na pahayag at mga loop para sa pagtatago at pagmamanipula ng data.
3. Suriin ang ilang mga linya ng simpleng code. Dumaan sa (napaka) simpleng programa sa ibaba upang makakuha ng isang unang ideya kung paano gumagana ang magkakaibang mga bahagi ng wika, at kung paano gumana ang mga programa.

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

   • Ang takdang aralin # isama ay inilalagay sa simula ng isang programa, at naglo-load ng mga aklatan (code library) na naglalaman ng mga pagpapaandar na kailangan mo. Sa halimbawang ito stdio.h Siguraduhin mo printf () at getchar () maaaring magamit.
   • Ang takdang aralin int main () Sinasabi sa tagatala na ang programa ay gumagamit ng "pangunahing" pag-andar at ibabalik nito ang isang integer pagkatapos ipatupad ito. Ang lahat ng mga programa ng C ay tumatakbo bilang isang "pangunahing" pagpapaandar.
   • Ang mga palatandaan {} ipahiwatig na ang lahat sa loob ay bahagi ng "pangunahing" pagpapaandar.
   • Ang pagpapaandar printf () ipinapakita ang mga nilalaman ng mga braket sa screen ng gumagamit. Tinitiyak ng mga marka ng panipi na ang string ay literal na nai-print. Ang n sinasabi sa tagatala na ilipat ang cursor sa susunod na linya.
   • Ang senyales ; ay nagpapahiwatig ng pagtatapos ng isang linya. Karamihan sa mga linya ng code ay dapat magtapos sa isang semicolon.
   • Ang takdang aralin getchar ()sinabi sa tagatala na maghintay para sa isang keystroke bago magpatuloy. Kapaki-pakinabang ito sapagkat maraming mga tagataguyod ang nagpapatakbo ng programa at pagkatapos ay agad na isinara ang window. Pinipigilan nito ang programa na lumabas hanggang mapindot ang isang key.
   • Ang takdang aralin ibalik ang 0 ay nagpapahiwatig ng pagtatapos ng pagpapaandar. Tandaan na ang "pangunahing" pagpapaandar ay isang int pagpapaandar ay. Nangangahulugan ito na dapat itong ibalik ang isang integer kapag tapos na ang programa. Ang isang "0" ay nagpapahiwatig na ang programa ay naisakatuparan nang tama; anumang iba pang numero ay nagpapahiwatig ng isang error na napansin.
4. Subukang i-compile ang programa. Ipasok ang code sa iyong code editor at i-save ito bilang isang " *. C" file. I-compile ito ngayon sa iyong tagatala, karaniwang sa pamamagitan ng pagpindot sa Build o Run.
5. Palaging isama ang isang paliwanag sa iyong code. Ito ay dapat na isang regular na bahagi ng programa, ngunit hindi ito maiipon. Tutulungan ka ng tutorial na ito na tandaan kung para saan ang code, at magsilbing gabay para sa mga programmer na tumitingin at / o nais na gamitin ang iyong code.
   • Upang magdagdag ng komento sa C, ilagay ang a /* sa simula ng komento at a */ sa dulo.
   • Magkomento kahit saan maliban sa pinaka-pangunahing mga bahagi ng iyong code.
   • Maaaring gamitin ang mga komento upang mabilis na maitago ang mga bahagi ng code nang hindi inaalis ang mga ito. Palibutan ang code sa pamamagitan ng paglalagay nito sa mga tag ng komento at pagkatapos ay ipagsama ang programa. Kung nais mong gamitin muli ang code, alisin ang mga tag.

Bahagi 2 ng 6: Paggamit ng mga variable

1. Ang pagpapaandar ng mga variable. Pinapayagan ka ng mga variable na mag-imbak ng data, alinman sa mga resulta sa pagkalkula o pag-input ng gumagamit. Dapat tukuyin ang mga variable bago mo magamit ang mga ito, at maraming uri upang pumili mula sa.
   • Ang ilan sa mga mas karaniwang variable ay int, char at lumutang. Ang bawat isa sa mga ito ay nag-iimbak ng magkakaibang uri ng data.
2. Alamin kung paano idineklara ang mga variable. Ang mga variable ay dapat munang bigyan ng isang tiyak na uri, o "idineklara", bago ito magamit sa isang C program. Nagdeklara ka ng variable sa pamamagitan ng pagtukoy sa uri ng data, na sinusundan ng pangalan ng variable. Halimbawa, ang mga sumusunod na deklarasyon ay may bisa sa C lahat:

   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 magkaparehong uri. Ang tanging bagay ay pinaghiwalay mo ang mga variable sa isang kuwit.
   • Tulad ng maraming mga linya sa C, ipinag-uutos na paghiwalayin ang bawat variable na deklarasyon sa isang kalahating titik.
3. Alamin kung saan idedeklara ang mga variable. Ang mga variable ay dapat ideklara sa simula ng isang bloke ng code (Ang mga bahagi ng code na nakapaloob sa {}). Kung susubukan mong ideklara ang isang variable sa ibang pagkakataon, ang programa ay hindi gagana nang maayos.
4. Gumamit ng mga variable upang maiimbak ang input ng gumagamit. Ngayong alam mo na ang mga pangunahing kaalaman sa kung paano gumagana ang mga variable, maaari kang magsulat ng isang simpleng programa na tumatanggap at nag-iimbak ng input mula sa gumagamit. Gumagamit ka ng isa pang pagpapaandar ng C para dito, katulad scanf. Ang pagpapaandar na ito ay naghahanap ng mga espesyal na halaga sa isang string.

   # isama ang stdio.h> int main () {int x; printf ("Mangyaring maglagay ng numero:"); scanf ("% d", & x); printf ("Ang bilang ay% d", x); getchar (); ibalik ang 0; }

   • Ang "% d" string / string scanf upang maghanap para sa isang integer sa input ng gumagamit.
   • Ang & para sa variable X nagsasabi scanf kung saan hahanapin ang variable upang baguhin ito, at iimbak ang integer bilang variable na iyon.
   • Ang huling utos printf binabasa ang variable at ipinapakita ang resulta sa gumagamit.
5. Pag-edit ng mga variable. Maaari mong i-edit ang data na iyong naimbak sa mga variable gamit ang mga expression ng matematika. Ang pangunahing pagkakaiba na dapat tandaan para sa mga expression ng matematika ay ang isang solong isa = iniimbak ang halaga ng variable, habang == ang mga halaga sa magkabilang panig ng character upang matiyak na pantay ang mga ito.

   x = 3 * 4; / * italaga ang "x" sa 3 * 4, o 12 * / x = x + 3; / * nagdaragdag ito ng 3 sa nakaraang halaga ng "x", at itinatakda ang bagong halaga bilang variable * / x == 15; / * suriin kung ang "x" ay katumbas ng 15 * / x 10; / * suriin kung ang halaga ng "x" ay mas mababa sa 10 * /

Bahagi 3 ng 6: Mga kondisyon na pahayag

1. Maunawaan ang mga pangunahing kaalaman sa mga kondisyong pahayag. Ang mga kondisyon na pahayag ay ang nasa gitna ng karamihan sa mga programa. Ito ang mga pahayag na alinman sa TAMA o MALI, at ibabalik ang isang resulta nang naaayon. Ang pinakasimpleng ng mga pahayag na ito ay ito 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 sa pagtutugma ng isang hindi numero ng numero. Kapag nagsagawa ka ng mga paghahambing at ang resulta ay TUNAY, isang "1" ang ibabalik. Kung ang resulta ay MALI, isang "0" ang ibabalik. Ang pag-unawa dito ay makakatulong upang gumana sa mga pahayag ng IF.
2. Alamin ang karaniwang mga kondisyong 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 katumbas ng * /
   

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

3. Ang pangunahing pahayag ng KUNG. Maaari mong gamitin ang mga pahayag ng IF upang matukoy kung ano ang dapat gawin ng programa pagkatapos na masuri ang pahayag. Maaari mo itong pagsamahin sa iba pang mga kondisyonal na pahayag upang lumikha ng malakas, kumplikadong mga pag-andar, ngunit pinapanatili naming madali upang masanay sa ngayon.

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

4. Gumamit ng ELSE / ELSE IF na mga pahayag upang mapalawak ang iyong mga kondisyon. Maaari kang bumuo sa mga pahayag na KUNG sa pamamagitan ng paggamit ng mga pahayag ng ELSE at ELSE IF upang maproseso ang iba't ibang mga resulta. Ang iba pang mga pahayag ay naisakatuparan lamang kung ang pahayag na KUNG ay MALI. ELSE KUNG mga pahayag ay nagbibigay-daan sa iyo upang gumamit ng maraming mga pahayag sa KAS sa loob ng parehong code block at sa gayon ay lumikha ng mas kumplikadong mga kundisyon. Tingnan ang sample na programa sa ibaba upang malaman kung paano ito gumagana.

   # isama ang stdio.h> int main () {int age; printf ("Ipasok ang iyong edad:"); scanf ("% d", at edad); kung (edad = 12) {printf ("Ikaw ay bata pa! n"); } iba pa kung (edad 20) {printf ("Napakaganda ng pagiging isang binatilyo! n"); } iba pa kung (edad 40) {printf ("Ikaw ay bata pa 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 pinapatakbo ito sa pamamagitan ng isang bilang ng mga pahayag na KUNG. Kung natutugunan ng numero ang unang pahayag, ito ang magiging una printf ibinalik ang pahayag. Kung hindi nito nasiyahan ang unang pahayag, susuriin nito kung ang isa sa mga sumusunod na ELSE KUNG pahayag ay nasiyahan hanggang sa makita mo ang isang bagay na gumagana. Kung wala sa mga pahayag ang kasiya-siya, ang huling pahayag ng ELSE ay naisakatuparan.

Bahagi 4 ng 6: Mga loop

1. 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 matugunan ang ilang mga kundisyon. Napakadali nito sa pagpapatupad ng mga paulit-ulit na pagkilos, at hindi na kailangang magsulat ng mga bagong kondisyong pahayag tuwing nais mong may mangyari.
   • Mayroong tatlong magkakaibang mga loop: PARA, BASTA at GAWIN ... HABANG.
2. Ang PARA loop. Ito ang pinakakaraniwan at kapaki-pakinabang na uri ng loop. Mapapanatili nito ang pagpapatakbo ng isang pagpapaandar hanggang sa matugunan ang ilang mga kundisyon, tulad ng tinukoy sa PARA loop. PARA sa mga loop ay nangangailangan ng 3 mga kundisyon: pagsisimula ng variable, ang kundisyon na natutugunan, at ang variable na mai-update. Kung hindi mo kailangan ang lahat ng mga kundisyong ito, pagkatapos ay maglalagay ka ng isang walang laman na puwang na may isang kalahating titik, kung hindi man ang loop ay magpapatuloy sa walang katiyakan.

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

   • Sa program sa itaas y itakda sa 0, at ang loop ay magpapatuloy hangga't ang halaga ng y ay mas mababa sa 15. Anumang oras ang halaga ng y ay naka-print sa screen, 1 ay idinagdag sa halaga ng y at ang loop ay paulit-ulit. Bilang ba iyon y = 15, ang loop ay magambala.
3. Ang WHILE loop. Habang ang mga loop ay medyo mas simple kaysa sa SA mga loop. Ang mga ito ay mayroon lamang 1 kundisyon at ang loop ay nagpapatuloy hangga't ang kundisyong iyon ay natutugunan. Hindi kailangang simulan o i-update ang isang variable, ngunit magagawa mo iyon sa loop mismo.

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

   • Ang y ++ Ang utos ay nagdaragdag ng 1 sa variable ysa tuwing naisasagawa ang loop. Kung y dumating sa 16 (tandaan na ang loop na ito ay nagpapatuloy hangga't y "mas mababa sa o katumbas ng" 15), ang loop ay ihihinto.
4. Ang GAWIN...WHILE loop. Ang loop na ito ay lubhang kapaki-pakinabang para sa mga loop na nais mong tiyakin na ang mga ito ay tapos na kahit isang beses. Sa PARA at habang ang mga loop, ang kalagayan ay nasuri sa simula ng loop, na nangangahulugang ang loop ay nakumpleto o hindi. GAWIN ... Habang ang mga loop ay suriin lamang kung ang kalagayan ay natupad sa huli at samakatuwid ay naisagawa 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 mensahe kahit na ang kondisyon ay MALI. Ang variable y ay nakatakda sa 5 at ang WHILE loop ay magpapatuloy ng habang y hindi katumbas ng 5, pagkatapos kung saan nagtatapos ang loop. Ang mensahe ay ipinakita na sa screen dahil nasuri lamang ito sa dulo na natutugunan ang kundisyon.
   • Ang WHILE loop sa DO ... WHILE dapat magtapos sa isang kalahating titik. Ito ang tanging oras na nagtatapos ang isang loop na may isang kalahating titik.

Bahagi 5 ng 6: Paggamit ng mga tampok

1. Ang pangunahing kaalaman sa mga pagpapaandar. Ang mga pagpapaandar ay may sariling mga bloke ng code na maaaring tawagan mula sa isa pang bahagi ng isang programa. Ginagawa nitong mas madali upang ulitin ang code at mga programa na mas madali, kapwa basahin at baguhin. Ginagamit ng mga pagpapaandar ang lahat ng mga diskarteng inilarawan sa itaas, at maging ang iba pang mga pagpapaandar.
   • Ang panuntunan pangunahing () sa simula ng lahat ng nakaraang mga halimbawa ay isang pagpapaandar, pati na rin getchar ()
   • Ang mga pagpapaandar ay inilaan upang gawing mas mahusay ang pagbabasa at pagsulat ng code. Gumamit ng mahusay na paggamit ng mga tampok upang streamline ang iyong programa.
2. Magsimula sa isang maikling paglalarawan. Ang mga pagpapaandar ay maaaring pinakamahusay na idisenyo sa pamamagitan ng unang paglalarawan kung ano ang nais mong makamit bago ka magsimula sa aktwal na pag-coding. Ang pangunahing syntax ng isang pagpapaandar sa C ay "pangalan ng return_type (argument1, argument2, atbp.);". Halimbawa, upang lumikha ng isang pagpapaandar na nagdaragdag ng dalawang numero, gawin ang sumusunod:

   int add (int x, int y);

   • Lumilikha ito ng isang pag-andar para sa pagdaragdag ng dalawang mga integer (X at y), at ang kabuuan ay nagbabalik bilang isang integer.
3. Idagdag ang pagpapaandar sa isang programa. Maaari mong gamitin ang maikling paglalarawan upang lumikha ng isang programa para sa pagdaragdag ng dalawang integer na ipinasok ng gumagamit. Tutukuyin ng programa kung paano gumagana ang function na "idagdag" at gamitin ito upang maproseso ang mga ipinasok na numero.

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

   • Tandaan na ang maikling paglalarawan ay nasa simula 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 mo rin magdagdag () tukuyin para sa pagpapaandar pangunahing () kaya ang resulta ay kapareho ng walang maikling paglalarawan.
   • Ang pagpapatakbo ng pagpapaandar ay tinukoy sa pagtatapos ng programa. Ang pagpapaandar pangunahing () Kinukuha ang mga integer ng gumagamit at pagkatapos ay isulong ang mga ito sa pagpapaandar magdagdag () ipoproseso. Ang pagpapaandar magdagdag () pagkatapos ay ibabalik ang resulta sa pangunahing ()
   • Ngayon magdagdag () ay tinukoy, maaari itong tawagan kahit saan sa loob ng programa.

Bahagi 6 ng 6: Patuloy na matuto

1. Dumaan sa ilang mga libro sa programa sa C. Ang artikulong ito ay mapupunta lamang sa mga pangunahing kaalaman, at iyon lamang ang dulo ng iceberg na tinatawag na C at lahat ng bagay na kasama nito. Ang isang mahusay na libro ay makakatulong malutas ang mga problema at mai-save ka ng maraming sakit ng ulo sa paglaon.
2. Sumali sa isang pangkat. Maraming mga pangkat, kapwa online at sa totoong mundo, na nakatuon sa mga wika ng programa ng pagprograma at pag-program ng lahat ng uri. Humanap ng ilang magkaparehong C programmer upang makipagpalitan ng code at mga ideya, at malalaman mo na sa isang maikling dami ng oras na natutunan mo nang higit pa kaysa sa naisip mong posible.
   • Pumunta sa ilang mga hack-a-thons kung posible. Ito ang mga kaganapan kung saan ang mga koponan at indibidwal ay kailangang magkaroon ng solusyon at ang kaukulang programa para sa isang problema sa loob ng isang tiyak na oras, isang bagay na nangangailangan ng maraming pagkamalikhain. Maaari mong matugunan ang maraming magagaling na programmer, at ang mga hack-a-thons ay naayos sa buong mundo.
3. Kumuha ng kurso. Hindi mo talaga kailangang bumalik sa paaralan upang sanayin bilang isang programmer, ngunit hindi nasasaktan na kumuha ng kurso at talagang palakasin ang bilis ng iyong pag-aaral. Walang maaaring makipagkumpitensya sa direktang tulong mula sa mga taong may kasanayan sa isang partikular na paksa. Madalas kang makahanap ng kurso sa malapit, o subukang maghanap para sa isang kurso sa online.
4. Isaalang-alang din ang pag-aaral ng C ++. Kapag na-master mo na ang C, hindi masakit na magpatuloy sa C ++. Ito ang mas modernong variant ng C, at nag-aalok ng higit na kakayahang umangkop. Ang C ++ ay dinisenyo para sa pagtatrabaho sa mga bagay, at ang kakayahang gumana sa C ++ ay nagbibigay-daan sa iyo upang sumulat ng mga makapangyarihang programa para sa halos anumang operating system.

Mga Tip

• Palaging magbigay ng puna sa iyong mga programa. Hindi lamang ito nakakatulong sa iba na maunawaan ang iyong source code, ngunit ito rin ay upang matulungan kang matandaan kung ano ang na-encode at kung bakit. Maaari mong malaman ngayon kung ano ang iyong ginagawa, ngunit pagkatapos ng halos 2-3 buwan, malamang na wala ka nang ideya.
• Huwag kalimutang tapusin ang isang pahayag tulad ng printf (), scanf (), getch (), atbp na may isang kalahating titik (;) ngunit huwag kailanman ilagay ito pagkatapos ng mga pahayag tulad ng "kung", "habang" o "para sa" mga loop.
• Kung nakatagpo ka ng isang error sa syntax sa oras ng pag-ipon at natigil ka, gamitin ang iyong paboritong search engine upang malaman kung ano ang ibig sabihin ng mensahe ng error. Mayroong isang magandang pagkakataon na may ibang nag-post ng isang solusyon para sa parehong problema.
• Ang source code ay dapat mayroong *. C extension upang malaman ng tagatala na ito ay isang C file.
• Tandaan, ang pagsasanay ay ginagawang perpekto. Kung mas maraming pagsasanay sa mga programa sa pagsulat, mas mahusay ka. Kaya't magsimula sa simple, maikling mga programa hanggang sa magkaroon ka ng matatag na landas, pagkatapos ay magpatuloy sa mga mas kumplikadong programa.
• Alamin ang tungkol sa lohika. Nakakatulong ito na malutas ang iba't ibang mga problema habang nagta-coding ka.