Informatika2-2012/Eloadas02

A MathWikiből
(Változatok közti eltérés)
a (A programozás alapjai)
(Változók, adatok, adattípusok)
58. sor: 58. sor:
 
* Később lesz szó egyéb dolgok (pl. függvények) deklarációjáról és definíciójáról is.
 
* Később lesz szó egyéb dolgok (pl. függvények) deklarációjáról és definíciójáról is.
  
==== Röviden a láthatóságról ====
+
===== Röviden a láthatóságról =====
  
Ha létrehozol
+
Egy változó ''láthatóságán'' azt értjük, hogy a programkód mely részeiből érhető el, hol használható. Az egyszerű szabály az, hogy a változó azon a blokkon belül érhető el, ahol deklaráltuk. Itt blokknak számít egyrészt maga a teljes c-forrásfájl (ami egyelőre a teljes programunkat jelenti) (az itt deklaráltak globális változók lesznek), másrészt minden kapcsos zárójelek közötti rész egy-egy újabb blokk (ezen belül lokális változóink lesznek).
  
?Figyelnünk kell az algoritmus futásidejére, és tár(memória)igényére, pontosabban arra, hogy ezek hogyan függenek össze a bemenet méretével. kezelhetetlen problémák : exponenciális, vagy rosszabb futásidő/tárigény?
+
Például a következő kódrészlet le sem fordul:
 +
 
 +
<c>
 +
int main(void) {
 +
    int x = 2;
 +
    if (x > 5) {
 +
        int y = 3;
 +
    } else {
 +
        y = 5;  /* HIBA: ebben a blokkban nem látszik a fentebbi if-es blokkban definiált y !*/
 +
    }
 +
    return 0;
 +
}
 +
</c>
 +
 
 +
Kétféle módon javíthatjuk ki a fordítási hibát.
 +
 
 +
Az első esetben egy ''y'' nevű '''globális''' változót veszünk fel az ''x'' mellé:
 +
<c>
 +
int main(void) {
 +
    int x = 2;
 +
    int y; /* globális változó */
 +
    if (x > 5) {
 +
        y = 3;
 +
    } else {
 +
        y = 5;
 +
    }
 +
    return 0;
 +
}
 +
</c>
 +
(Itt arra kell még figyelni, hogy ha véletlenül ottmarad az "int" szó az 5. vagy 7. sorban, akkor ott egy új, lokális ''y'' változó fog létrejönni, és abban a blokkban az új lesz az érvényes, nem a külső ''y''. Az azonos nevű változók közül mindig a "lokálisabb" az érvényes.)
 +
 
 +
 
 +
A második esetben pedig két, egymástól független lokális változónk lesz, csak "véletlenül" ugyanolyan névvel.
 +
<c>
 +
int main(void) {
 +
    int x = 2;
 +
    if (x > 5) {
 +
        int y = 3;
 +
    } else {
 +
        int y = 5;
 +
    }
 +
    return 0;
 +
}
 +
</c>
 +
 
 +
Egyelőre a globális változós megoldás tűnik szimpatikusabbnak, de később, ha majd függvényeket is tudunk írni, jobb lesz a változókat a függvényeken belül, lokálisan deklarálni.
 +
Egy nagyobb programnál a globális változók áttekinthetetlenné és rugalmatlanná teszik a program felépítését. De erről majd később részletesebben.
  
 
== Ellenőrző kérdések ==
 
== Ellenőrző kérdések ==

A lap 2012. február 13., 23:44-kori változata

Tartalomjegyzék

A programozás alapjai

A számítógép felépítése

A számítógép fő részegységei: Kép

  • processzor (beolvassa a memóriából az utasításokat és az adatokat, az utasítások alapján műveleteket végez, az eredményt visszaírja a memóriába; valamint vezérli a perifériákat - adatokat olvas belőlük, ill. ír ki)
  • memória (általános tároló, mely utasításokat és adatokat tartalmaz)
  • perifériák (pl. háttértároló (ahol az elmentett fájlok találhatók); beviteli eszközök: billentyűzet, egér; megjelenítő eszközök: monitor)


Eljárás, algoritmus, programozás

  • Programozás: előírni a számítógépnek, hogy mit csináljon. (Ebben a félévben csak imperatív programozás: lépésről lépésre előírjuk, hogy mit kell tenni, kb. mint egy recept leírása.)
  • Eljárás (módszer): Gépiesen (gondolkodás nélkül) végrehajtható lépések sorozata, amely elvezet a megoldáshoz.
  • Algoritmus: Gépiesen (gondolkodás nélkül) végrehajtható lépések véges sorozata, amely elvezet a megoldáshoz.


Mielőtt az algoritmust kódolni kezdjük, meg kell győződni róla, hogy mindhárom feltétel teljesül:

  • helyes : Valóban azt a feladatot oldja meg, amire szánjuk.
  • teljes : Minden lehetséges esetben megoldja.
  • véges : Véges sok lépésben befejeződik.


Egy programozási feladat megoldási folyamata: Kép


Változók, adatok, adattípusok

  • Változó: Az olyan adatot, amelyet meg lehet változtatni, változónak nevezzük. (pl: int x;)
  • Konstans: Az olyan adatot, amelynek értéke nem változtatható meg, konstansnak nevezzük. (pl: 12)

A C erősen típusos nyelv, ráadásul statikusan típusos, azaz a változókról meg kell mondani, hogy milyenfajta adatok tárolására alkalmasak. Például int jelöli azt, hogy egész számokat tárolhat, float pedig azt hogy lebegőpontos tört számot.

(A Python dinamikusan típusos, ott az értéknek van típusa, nem a változónak. Ezért nem kellett definiálni a változókat, azokban bármilyen adat lehetett. Ez egyszerűsíti a programírást, viszont növeli a hibalehetőséget.)

Változók definiálása és deklarálása

  • Deklaráció: A deklarációkor egy adott dologról jelezzük a fordítónak, hogy létezik, de ott még nem fejtjük ki azt.
    • a változó típusát, méretét (alapvető jellemzőit) határozza meg
    • utána a deklarált azonosító használható a kódban
    • Példa: két változó (egy egész és egy lebegőpontos típusú) deklarálása:
 int alma;
 float barack;
  • Definíció: Definíciókor egy adott dologról pontosan megmondjuk, hogy micsoda. Ez változók esetén azt jelenti, hogy már értéket is kap.
    • meghatározza valamely objektum típusát, méretét
    • hatására helyfoglalás is történik a memóriában
    • Példa: két változó (egy egész és egy lebegőpontos típusú) definiálása:
 int alma = 3;
 float barack = 2.6;

Megjegyzések:

  • A definíció egyben deklaráció is.
  • Később lesz szó egyéb dolgok (pl. függvények) deklarációjáról és definíciójáról is.
Röviden a láthatóságról

Egy változó láthatóságán azt értjük, hogy a programkód mely részeiből érhető el, hol használható. Az egyszerű szabály az, hogy a változó azon a blokkon belül érhető el, ahol deklaráltuk. Itt blokknak számít egyrészt maga a teljes c-forrásfájl (ami egyelőre a teljes programunkat jelenti) (az itt deklaráltak globális változók lesznek), másrészt minden kapcsos zárójelek közötti rész egy-egy újabb blokk (ezen belül lokális változóink lesznek).

Például a következő kódrészlet le sem fordul:

int main(void) {
    int x = 2;
    if (x > 5) {
        int y = 3;
    } else {
        y = 5;  /* HIBA: ebben a blokkban nem látszik a fentebbi if-es blokkban definiált y !*/
    }
    return 0;
}

Kétféle módon javíthatjuk ki a fordítási hibát.

Az első esetben egy y nevű globális változót veszünk fel az x mellé:

int main(void) {
    int x = 2;
    int y; /* globális változó */
    if (x > 5) {
        y = 3;
    } else {
        y = 5;
    }
    return 0;
}

(Itt arra kell még figyelni, hogy ha véletlenül ottmarad az "int" szó az 5. vagy 7. sorban, akkor ott egy új, lokális y változó fog létrejönni, és abban a blokkban az új lesz az érvényes, nem a külső y. Az azonos nevű változók közül mindig a "lokálisabb" az érvényes.)


A második esetben pedig két, egymástól független lokális változónk lesz, csak "véletlenül" ugyanolyan névvel.

int main(void) {
    int x = 2;
    if (x > 5) {
        int y = 3;
    } else {
        int y = 5;
    }
    return 0;
}

Egyelőre a globális változós megoldás tűnik szimpatikusabbnak, de később, ha majd függvényeket is tudunk írni, jobb lesz a változókat a függvényeken belül, lokálisan deklarálni. Egy nagyobb programnál a globális változók áttekinthetetlenné és rugalmatlanná teszik a program felépítését. De erről majd később részletesebben.

Ellenőrző kérdések

(Ilyesmi, vagy akár konkrétan ezek várhatóak a gyakorlat eleji mini Zh-n !)

  • Rajzold le a számítógép egyszerűsített felépítését (3 doboz)!
  • Mi az a három dolog amit ellenőriznünk kell, mielőtt egy algoritmust kódolni kezdünk?
  • Mi az "eljárás" definíciója? Miben különbözik ettől az algoritmus definíciója?

Források

Személyes eszközök