Informatika2-2012/Eloadas02

A MathWikiből
(Változatok közti eltérés)
(Változók definiálása és deklarálása)
(A programozás alapjai)
 
(egy szerkesztő 9 közbeeső változata nincs mutatva)
11. sor: 11. sor:
 
=== Eljárás, algoritmus, programozás ===
 
=== Eljárás, algoritmus, programozás ===
  
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.
+
* '''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.)
 
+
* '''Programozás''': előírni a számítógépnek, hogy mit csináljon.
+
 
* '''Eljárás (módszer)''': Gépiesen (gondolkodás nélkül) végrehajtható lépések sorozata,  amely elvezet a megoldáshoz.
 
* '''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.
 
* '''Algoritmus''': Gépiesen (gondolkodás nélkül) végrehajtható lépések '''véges''' sorozata,  amely elvezet a megoldáshoz.
24. sor: 22. sor:
  
  
Egy programozási feladat megoldási folyamata: [http://math.bme.hu/~ador/programozas1.png Kép]  
+
Példa ''módszer''-re: [http://www.ugrad.math.ubc.ca/coursedoc/math100/notes/approx/newton.html Newton módszer]<br/>
 +
Példa ''algoritmus''-ra: bináris keresés<br/>
 +
Egy programozási feladat általános megoldási folyamata: [http://math.bme.hu/~ador/programozas1.png Kép]<br/>
  
  
39. sor: 39. sor:
 
==== Változók definiálása és deklarálása ====
 
==== 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.
 
* '''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.
** valamely objektum típusát, méretét (alapvető jellemzőit) határozza meg
+
** a változó típusát, méretét (alapvető jellemzőit) határozza meg  
** hatására a deklarált azonosító használható hibajelzés nélkül
+
** 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:
 
** Példa: két változó (egy egész és egy lebegőpontos típusú) deklarálása:
 
<c>
 
<c>
47. sor: 47. sor:
 
</c>
 
</c>
  
* '''Definíció''': Definíciókor egy adott dologról pontosan megmondjuk, hogy micsoda. Emiatt szigorúan csak egyetlen egy lehet belőle egy forrásfájlban.  
+
* '''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
 
** meghatározza valamely objektum típusát, méretét
** hatására helyfoglalás történik
+
** 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:
 
** Példa: két változó (egy egész és egy lebegőpontos típusú) definiálása:
 
<c>
 
<c>
56. sor: 56. sor:
 
</c>
 
</c>
  
A definíció egyben deklaráció is.
+
''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 ====
+
===== 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 x = 2; /* ez egy globális változó, mindenhol használható a programban */
 +
 
 +
int main(void) {
 +
    if (x > 5) {
 +
        int y = 3; /* lokális változó, csak a következő } -ig él */
 +
    } else {
 +
        y = 5;  /* HIBA: ebben a blokkban nem látszik a fentebbi if-es blokkban definiált y !*/
 +
    }
 +
    return 0;
 +
}
 +
</c>
 +
 
 +
Többféle módon is kijavíthatjuk 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 x = 2;
 +
int y; /* globális változó */
 +
int main(void) {
 +
    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.)
 +
 
 +
Igazából a problémát az is megoldja, ha az ''y'' nem globális lesz, csak egy blokkal kintebb visszük (a ''main()'' függvénybe), hogy az ''if'' és az ''else'' ágban is elérhető legyen:
 +
<c>
 +
int x = 2;
 +
int main(void) {
 +
    int y; /* függvényen belüli, lokális változó, de kintebbi blokkban */
 +
    if (x > 5) {
 +
        y = 3;
 +
    } else {
 +
        y = 5;
 +
    }
 +
    return 0;
 +
}
 +
</c>
 +
 
 +
 
 +
Egy másik megoldás pedig két, egymástól független lokális változó felvétele, amiknek csak "véletlenül" ugyanaz a nevük.
 +
<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űnhet szimpatikusabbnak, mert az a legegyszerűbb, mindenhol használható a változó és kész. 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 ==
70. sor: 133. sor:
 
* Mi az a három dolog amit ellenőriznünk kell, mielőtt egy algoritmust kódolni kezdünk?
 
* 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?
 
* Mi az "eljárás" definíciója? Miben különbözik ettől az algoritmus definíciója?
 +
* Definiálj C nyelven egy ''x'' nevű és ''int'' típusú változót, valamit deklarálj egy ''y'' nevű ''float'' típusú változót!
 +
  
==== Források ====
+
=== Források ===
 
* Vitéz András, Dr. Zsóka Zoltán: A Programozás alapjai 1. c. tárgy jegyzete, BME VIK,  http://www.hit.bme.hu/~vitez/Progalap1/2011osz/Ea/ea02.pdf
 
* Vitéz András, Dr. Zsóka Zoltán: A Programozás alapjai 1. c. tárgy jegyzete, BME VIK,  http://www.hit.bme.hu/~vitez/Progalap1/2011osz/Ea/ea02.pdf
 
* Pohl László: A programozás alapjai http://www.scribd.com/doc/55046873/h-jegyzet
 
* Pohl László: A programozás alapjai http://www.scribd.com/doc/55046873/h-jegyzet
 
* Calmarius blogja: A C++ alapjai 11. http://calmarius.net/2011/12/25/basics-of-c-11-source-files-declarations-and-definitions/?lang=hu
 
* Calmarius blogja: A C++ alapjai 11. http://calmarius.net/2011/12/25/basics-of-c-11-source-files-declarations-and-definitions/?lang=hu

A lap jelenlegi, 2012. február 14., 15: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.


Példa módszer-re: Newton módszer
Példa algoritmus-ra: bináris keresés
Egy programozási feladat általános 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 x = 2; /* ez egy globális változó, mindenhol használható a programban */
 
int main(void) {
    if (x > 5) {
        int y = 3; /* lokális változó, csak a következő } -ig él */
    } else {
        y = 5;  /* HIBA: ebben a blokkban nem látszik a fentebbi if-es blokkban definiált y !*/
    }
    return 0;
}

Többféle módon is kijavíthatjuk a fordítási hibát.

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

int x = 2;
int y; /* globális változó */
int main(void) {
    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.)

Igazából a problémát az is megoldja, ha az y nem globális lesz, csak egy blokkal kintebb visszük (a main() függvénybe), hogy az if és az else ágban is elérhető legyen:

int x = 2;
int main(void) {
    int y; /* függvényen belüli, lokális változó, de kintebbi blokkban */
    if (x > 5) {
        y = 3;
    } else {
        y = 5;
    }
    return 0;
}


Egy másik megoldás pedig két, egymástól független lokális változó felvétele, amiknek csak "véletlenül" ugyanaz a nevük.

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űnhet szimpatikusabbnak, mert az a legegyszerűbb, mindenhol használható a változó és kész. 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?
  • Definiálj C nyelven egy x nevű és int típusú változót, valamit deklarálj egy y nevű float típusú változót!


Források

Személyes eszközök