A C az egyik régebbi programozási nyelv. A 70-es években fejlesztették ki, de még mindig nagyon erős, köszönhetően annak alacsony szintjének. A C tanulás nagyszerű módja annak, hogy bonyolultabb nyelveken is bemutatkozzon, és a megszerzett ismeretek hasznosak lesznek szinte minden programozási nyelvben, és segíthetnek az alkalmazásfejlesztésben. A programozás C nyelven történő elindításának módjáról lásd az alábbi 1. lépést.
Lépések
Rész 1 /6: Felkészülés
1. lépés: Töltse le és telepítse a fordítóprogramot
A C kódot olyan programnak kell összeállítania, amely a kódot a gép által érthető jelekké értelmezi. A fordítók általában ingyenesek, és különböző fordítók állnak rendelkezésre a különböző operációs rendszerekhez.
- Windows esetén próbálja ki a Microsoft Visual Studio Express vagy a MinGW szoftvert.
- Mac számára az XCode az egyik legjobb C fordító.
- Linux esetén a gcc az egyik legnépszerűbb lehetőség.
2. lépés: Az alapok megértése
A C az egyik régebbi programozási nyelv, és nagyon hatékony lehet. Unix operációs rendszerekhez tervezték, de szinte minden operációs rendszerhez átvitték és kibővítették. A C modern verziója a C ++.
A C lényegében függvényekből áll, és ezekben a függvényekben változókat, feltételes utasításokat, ciklusokat használhat az adatok tárolására és kezelésére
Lépés 3. Vizsgáljon meg néhány alapvető kódot
Vessen egy pillantást az alábbi (nagyon) alapprogramra, hogy jó képet kapjon arról, hogyan működnek együtt a nyelv egyes aspektusai, és hogy képet kapjon a programok működéséről.
#include int main () {printf ("Helló, világ! / n"); getchar (); visszatérés 0; }
- Az #include parancs a program elindítása előtt jelenik meg, és betölti a szükséges funkciókat tartalmazó könyvtárakat. Ebben a példában az stdio.h lehetővé teszi a printf () és a getchar () függvények használatát.
- Az int main () parancs megmondja a fordítónak, hogy a program futtatja a "main" nevű függvényt, és hogy egy egész számot ad vissza, amikor befejezte. Minden C program "fő" funkciót futtat.
- A {} jelzi, hogy bennük minden a funkció része. Ebben az esetben azt jelzik, hogy belül minden a "fő" funkció része.
- A printf () függvény megjeleníti a zárójelek tartalmát a felhasználó képernyőjén. Az idézetek biztosítják, hogy a benne lévő karakterlánc szó szerint legyen nyomtatva. A / n sorozat azt mondja a fordítónak, hogy vigye a kurzort a következő sorra.
- Az; sor végét jelöli. A legtöbb C -kód sorának pontosvesszővel kell végződnie.
- A getchar () parancs utasítja a fordítót, hogy várja meg a billentyűleütést, mielőtt továbblép. Ez azért hasznos, mert sok fordító futtatja a programot, és azonnal bezárja az ablakot. Ez megakadályozza a program befejezését, amíg le nem nyom egy gombot.
- A return 0 parancs a funkció végét jelzi. Vegye figyelembe, hogy a "fő" függvény egy int függvény. Ez azt jelenti, hogy a program befejezése után egész számot kell visszaadni. A "0" azt jelzi, hogy a program helyesen teljesített; bármely más szám azt jelenti, hogy a program hibába ütközött.
4. lépés: Próbálja meg lefordítani a programot
Írja be a kódot a kódszerkesztőbe, és mentse el "*.c" fájlként. Fordítsa le a fordítóban, általában a Build vagy Run gombra kattintva.
5. lépés: Mindig kommentálja a kódját
A megjegyzések része a kódnak, amelyet nem fordítanak össze, de lehetővé teszi, hogy elmagyarázza, mi történik. Ez hasznos, ha emlékezteti magát arra, hogy mire való a kódja, és segít más fejlesztőknek, akik esetleg a kódot nézik.
- Hozzászólás a C helyen / * a megjegyzés elején és * / a végén.
- Írjon megjegyzést a kód legalapvetőbb részeire kivéve.
- A megjegyzések segítségével gyorsan eltávolíthatja a kód egyes részeit anélkül, hogy törölné őket. Egyszerűen csatolja a kizárni kívánt kódot megjegyzéscímkével, majd fordítsa le. Ha vissza szeretné adni a kódot, távolítsa el a címkéket.
2. rész a 6 -ból: Változók használata
1. lépés: Ismerje meg a változók funkcióját
A változók lehetővé teszik az adatok tárolását, akár a program számításaiból, akár a felhasználói adatokból. Használat előtt meg kell határozni a változókat, és több típus közül lehet választani.
Néhány gyakoribb változótípus az int, char és float. Mindegyik más típusú adatot tárol
2. lépés Ismerje meg a változók deklarálásának módját
A változókat meg kell határozni, vagy "deklarálni", mielőtt a program használni tudná őket. Változót úgy deklarálhat, hogy megadja az adattípust, majd a változó nevét. Például a következők az összes érvényes változó deklaráció:
úszó x; char név; int a, b, c, d;
- Vegye figyelembe, hogy ugyanazon a soron több változót is deklarálhat, amennyiben azonos típusúak. Egyszerűen válassza el a változók neveit vesszővel.
- A C sok sorához hasonlóan minden változó deklarációs sornak pontosvesszővel kell végződnie.
3. lépés. Tudja, hol kell deklarálni a változókat
A változókat az egyes kódblokkok elején kell megadni (A kód azon részei, amelyek {} zárójelben vannak). Ha később megpróbál egy változót deklarálni a mondatban, a program nem fog megfelelően működni.
4. lépés: Változókkal tárolja a felhasználói adatokat
Most, hogy ismeri a változók működésének alapjait, írhat egy egyszerű programot, amely tárolja a felhasználó bevitelét. A program egy másik funkcióját fogja használni, az úgynevezett scanf. Ez a funkció megkeresi a megadott értékeket a megadott értékekhez.
#include int main () {int x; printf ("Adjon meg egy számot:"); scanf ("%d", & x); printf (" %d beírtad", x); getchar (); visszatérés 0; }
- A "%d" karakterlánc arra utasítja a Scanf -et, hogy keressen egész számokat a felhasználói beviteli mezőben.
- Az & előtti x változó megmondja a scanf -nek, hogy hol találja meg a változót, és eltárolja az egész számot a változóban.
- Az utolsó printf parancs visszaolvassa a bemeneti egész számot a felhasználónak.
5. lépés: Manipulálja a változókat
Matematikai kifejezésekkel manipulálhatja a változókban tárolt adatokat. A legfontosabb különbség a matematikai kifejezéseknél, hogy ne felejtsük el, hogy egy = beállítja a változó értékét, míg == összehasonlítja az értékeket mindkét oldalon, hogy lássa, egyenlőek -e.
x = 3 * 4; / * az "x" értéket 3 * 4 -re állítja, vagy 12 */ x = x + 3; / * hozzáad 3 -at az "x" eredeti értékéhez, és az új értéket */ x == 15 változóként állítja be; / * ellenőrzi, hogy az "x" egyenlő -e 15 */ x <10; / * ellenőrzi, hogy az "x" értéke kevesebb, mint 10 */
Rész 3 /6: Feltételes állítások használata
1. lépés: A feltételes állítások alapjainak megértése
A legtöbb programot a feltételes utasítások hajtják. Ezek olyan állítások, amelyek vagy IGAZOK vagy HAMISak, és az eredmény alapján cselekszenek. Az állítások legalapvetőbb eleme az if állítás.
Az IGAZ és a HAMIS eltérően működik C -ben, mint amit megszokhattál. Az IGAZ állítások mindig nem nulla számnak felelnek meg. Ha összehasonlítást végez, ha az eredmény IGAZ, akkor az "1" értéket adja vissza. Ha az eredmény HAMIS, akkor a "0" értéket adja vissza. Ennek megértése segít megérteni, hogyan dolgozzák fel az IF utasításokat
2. lépés Ismerje meg az alapvető feltételes operátorokat
A feltételes állítások az értékeket összehasonlító matematikai operátorok használata körül forognak. Az alábbi lista a leggyakrabban használt feltételes operátorokat tartalmazza.
/* nagyobb, mint* /< /* kisebb, mint* /> = /* nagyobb vagy egyenlő* /<= /* kisebb vagy egyenlő* /== /* egyenlő* /! = /* nem egyenlő nak nek */
10> 5 IGAZ 6 <15 IGAZ 8> = 8 IGAZ 4 <= 8 IGAZ 3 == 3 IGAZ 4! = 5 IGAZ
Lépés 3. Írjon alap IF utasítást
Az IF utasítások segítségével meghatározhatja, hogy a programnak mit kell tennie a kiértékelés után. Később kombinálhatja más feltételes állításokkal, hogy hatékony több opciót hozzon létre, de most írjon egy egyszerűt, hogy megszokja őket.
#include int main () {if (3 <5) printf ("3 kevesebb, mint 5"); getchar (); }
4. lépés Használja ELSE/ELSE IF utasításokat a feltételek kibővítéséhez
Az IF utasításokra építhet az ELSE és az ELSE IF utasításokkal a különböző eredmények kezelésére. Az ELSE utasítások akkor futnak, ha az IF utasítás HAMIS. Az ELSE IF utasítások lehetővé teszik, hogy több IF utasítást egyetlen kódblokkba foglaljon a különböző esetek kezelésére. Nézze meg az alábbi példaprogramot, hogy megtudja, hogyan hatnak egymásra.
#include int main () {int age; printf ("Kérjük, adja meg jelenlegi életkorát:"); scanf ("%d", & age); if (életkor <= 12) {printf ("Te csak gyerek vagy! / n"); } else if (<20 éves kor) {printf ("Kamasznak lenni nagyon jó! / n"); } else if (<40 éves kor) {printf ("Szívében még fiatal! / n"); } else {printf ("A korral jár a bölcsesség. / n"); } return 0; }
A program átveszi a felhasználó adatait, és átveszi az IF utasításokon. Ha a szám megfelel az első utasításnak, akkor az első printf utasítást adja vissza. Ha nem felel meg az első állításnak, akkor minden ELSE IF utasításon keresztül átmegy, amíg meg nem találja azt, amelyik működik. Ha egyiknek sem felel meg, akkor a végén az ELSE utasításon megy keresztül
4. rész a 6 -ból: Tanulási hurkok
1. lépés: Ismerje meg a hurkok működését
A hurkok a programozás egyik legfontosabb szempontja, mivel lehetővé teszik a kódblokkok ismétlését, amíg bizonyos feltételek teljesülnek. Ez nagyon megkönnyítheti az ismétlődő műveletek végrehajtását, és megakadályozza, hogy új feltételes nyilatkozatokat kelljen írnia minden alkalommal, amikor azt szeretné, hogy történjen valami.
Három fő hurkotípus létezik: FOR, WHILE és DO… WHILE
2. lépés. Használjon FOR hurkot
Ez a leggyakoribb és leghasznosabb hurok típus. Addig folytatja a funkció futtatását, amíg a FOR ciklusban meghatározott feltételek nem teljesülnek. A ciklusokhoz három feltétel szükséges: a változó inicializálása, a teljesítendő feltétel és a változó frissítési módja. Ha nincs szüksége ezekre a feltételekre, továbbra is üres helyet kell hagynia pontosvesszővel, különben a hurok örökké fut.
#include int main () {int y; mert (y = 0; y <15; y ++;) {printf ("%d / n", y); } getchar (); }
A fenti programban az y 0 -ra van állítva, és a ciklus addig folytatódik, amíg y értéke kisebb, mint 15. Minden alkalommal, amikor y értékét kinyomtatják, 1 hozzáadódik az y értékéhez, és a ciklus megismétlődik. Ha y = 15, a hurok megszakad
3. lépés. WHILE ciklus használata
Míg a hurkok egyszerűbbek, mint a FOR hurkok. Csak egy feltételük van, és a ciklus addig működik, amíg ez a feltétel igaz. Nem kell inicializálni vagy frissíteni a változót, bár ezt megteheti a ciklus törzsében.
#include int main () {int y; while (y <= 15) {printf ("%d / n", y); y ++; } getchar (); }
Az y ++ parancs minden egyes ciklus végrehajtásakor 1 -et ad hozzá az y változóhoz. Amint y eléri a 16 -ot (ne feledje, ez a ciklus mindaddig megy, amíg y kisebb vagy egyenlő, mint 15), a ciklus megszakad
4. lépés. Használja a DO
.. WHILE hurok.
Ez a ciklus nagyon hasznos olyan hurkok esetén, amelyek legalább egyszer biztosítani kívánják a futást. A FOR és WHILE ciklusokban a feltételt a ciklus elején ellenőrzik, vagyis nem tud haladni és azonnal meghiúsulni. DO… WHILE ciklusok ellenőrzik a feltételeket a ciklus végén, biztosítva, hogy a ciklus legalább egyszer végrehajtson.
#include int main () {int y; y = 5; do {printf ("Ez a ciklus fut! / n"); } while (y! = 5); getchar (); }
- Ez a ciklus akkor is megjeleníti az üzenetet, ha a feltétel HAMIS. Az y változó 5 -re van állítva, és a WHILE ciklus futásra van állítva, ha y nem egyenlő 5 -tel, tehát a ciklus befejeződik. Az üzenetet már kinyomtatta, mivel a feltétel a végéig nincs ellenőrizve.
- A WHILE ciklus a DO… WHILE halmazban pontosvesszővel zárul. Ez az egyetlen alkalom, amikor a ciklus pontosvesszővel fejeződik be.
5. rész a 6 -ból: Funkciók használata
1. lépés: Ismerje meg a funkciók alapjait
A függvények önálló kódblokkok, amelyeket a program más részei hívhatnak le. Nagyon megkönnyítik a kód megismétlését, és segítenek a program egyszerűbb olvasásában és módosításában. A funkciók magukban foglalhatják a cikkben korábban ismertetett összes technikát, sőt más funkciókat is.
- A fenti példák elején található fő () sor függvény, csakúgy, mint a getchar ()
- A funkciók elengedhetetlenek a hatékony és könnyen olvasható kódhoz. Használja ki jól a funkciókat a program egyszerűsítésére.
2. lépés. Vázlattal kezdje
A függvények akkor jönnek létre a legjobban, ha a tényleges kódolás megkezdése előtt felvázolja, hogy mit szeretne elérni. A függvények alapvető szintaxisa a "return_type name (argumentum1, argumentum2 stb.);". Például egy két számot hozzáadó függvény létrehozásához:
int add (int x, int y);
Ez létrehoz egy függvényt, amely két egész számot (x és y) ad hozzá, majd az összeget egész számként adja vissza
3. lépés: A funkció hozzáadása egy programhoz
A vázlat segítségével létrehozhat egy olyan programot, amely két egész számot vesz fel, amelyeket a felhasználó megad, majd összeadja őket. A program meghatározza az "add" funkció működését, és a bemeneti számok manipulálására használja.
#include int add (int x, int y); int main () {int x; int y; printf ("Írjon be két számot, hogy összeadja őket:"); scanf ("%d", & x); scanf ("%d", & y); printf ("A számok összege %d / n", add (x, y)); getchar (); } int add (int x, int y) {return x + y; }
- Ne feledje, hogy a vázlat továbbra is a program tetején található. Ez megmondja a fordítónak, hogy mire számíthat a függvény meghívásakor és mit ad vissza. Erre csak akkor van szükség, ha a funkciót a program későbbi részében kívánja meghatározni. A fő () függvény előtt definiálhatod az add () - t, és az eredmény a körvonal nélkül ugyanaz lenne.
- A függvény tényleges funkcionalitása a program alján található. A main () függvény összegyűjti az egész számokat a felhasználótól, majd elküldi a feldolgozandó add () függvénynek. Az add () függvény ezután visszaadja az eredményeket a main ()
- Most az add () definiálva lett, bárhol meghívható a programban.
6. rész a 6 -ból: A tanulás folytatása
1. lépés. Keressen néhány C programozási könyvet
Ez a cikk az alapokat tárgyalja, de csak a C programozás felületét és az összes kapcsolódó tudást karcolja meg. Egy jó referenciakönyv segít megoldani a problémákat, és megóv a sok fejfájástól.
2. lépés Csatlakozzon néhány közösséghez
Rengeteg közösség létezik, mind online, mind a való világban, amelyek elkötelezettek a programozás és az összes szükséges nyelv mellett. Keressen néhány hasonló gondolkodású C programozót, hogy kicserélje a kódot és az ötleteket, és hamarosan azon kapja magát, hogy sokat tanul.
Vegyen részt néhány hack-a-thons-on, ha lehetséges. Ezek olyan események, ahol a csapatoknak és az egyéneknek határidejük van a programok és megoldások kidolgozására, és gyakran elősegítik a kreativitást. Sok jó programozóval találkozhat így, és a hack-a-thons rendszeresen előfordul szerte a világon
3. Lépés. Vegyen néhány órát
Nem kell visszamennie az iskolába számítástechnika szakon, de néhány óra elvégzése csodákat tehet a tanulással. Semmi sem veri a nyelvet jól ismerő emberek gyakorlati segítségét. Gyakran találhat osztályokat a helyi közösségi központokban és az ifjúsági főiskolákon, és egyes egyetemek lehetővé teszik számítástechnikai programjaik ellenőrzését anélkül, hogy beiratkoznának.
4. lépés. Fontolja meg a C ++ tanulását
Ha már megérti a C -t, nem ártana elkezdeni a C ++ -ra nézni. Ez a C modernebb változata, és sokkal nagyobb rugalmasságot tesz lehetővé. A C ++ az objektumkezelést szem előtt tartva készült, és a C ++ ismerete lehetővé teszi, hogy gyakorlatilag bármilyen operációs rendszer számára hatékony programokat hozzon létre.
Tippek
- Mindig írjon megjegyzéseket a programjaihoz. Ez nemcsak másoknak segít, akik esetleg megnézik a forráskódját, hanem segít emlékezni arra is, hogy mit ír és miért. Lehet, hogy tudja, mit csinál, abban a pillanatban, amikor írja a kódját, de két -három hónap elteltével nem fog sokra emlékezni.
- Mindig ne felejtse el befejezni az olyan utasításokat, mint a printf (), scanf (), getch () stb., Pontosvesszővel (;), de soha ne illessze be őket egy vezérlő utasítás után, mint az „if”, „while” vagy „for” ciklusok.
- Ha szintaktikai hibát észlel a fordítás során, és tanácstalan, keressen rá a Google -ra (vagy egy másik keresőmotorra) a kapott hibával. Valószínűleg valaki már tapasztalta ugyanazt a problémát, és közzétette a megoldást.
- A forráskódnak *.c kiterjesztéssel kell rendelkeznie, hogy a fordító megérthesse, hogy ez egy C forrásfájl.
- Ne feledje, hogy a gyakorlat teszi a mestert. Minél többet gyakorol egy programot, annál jobban ért hozzá. Kezdje tehát egyszerű, rövid programokkal, amíg meg nem kapja a lábát, majd ha biztos abban, hogy továbbléphet a bonyolultabbra.
- Próbáld meg megtanulni a logikaépítést. Segít megoldani a különböző problémákat kódírás közben.
