Informatika2-2012/Eloadas03

A MathWikiből
(Változatok közti eltérés)
(Függvények)
a (Függvények)
116. sor: 116. sor:
 
* a program logikai strukturálása
 
* a program logikai strukturálása
 
* áttekinthetőbb, olvashatóbb lesz a kód
 
* áttekinthetőbb, olvashatóbb lesz a kód
* elkerüljük a kódismétlést: kevesebbet kell gépelni, ill. csak egy helyen kell javítani ha hiba van (a copy-paste stílusú programozás hooszútávon nem működik)
+
* elkerüljük a kódismétlést: kevesebbet kell gépelni, ill. csak egy helyen kell javítani ha hiba van (a copy-paste stílusú programozás hosszútávon nem működik)
 
* minél általánosabban megírt egy függvény, annál valószínűbb hogy máshol (másik programban) is használható lesz  
 
* minél általánosabban megírt egy függvény, annál valószínűbb hogy máshol (másik programban) is használható lesz  
  

A lap 2012. február 22., 10:28-kori változata

Tartalomjegyzék

Adattípusok, függvények

Egyszerű adattípusok

Eddig két egyszerű adattípussal ismerkedtünk meg: int (egész szám) és float (tört szám). Most lesz még néhány típusunk amiket egy C programban használhatunk:

  • uint : unsigned int, vagyis előjel nélküli egész.
  • short : rövid egész
  • long : hosszú egész
  • char : karakter típus
  • double: dupla pontosságú lebegőpontos szám (mint a float, csak több byte-os, ezért szélesebb határok között tud számokat tárolni)
  • void : ez a "semmi" típus, függvények deklarációjánál kell pl használni, ha semmit nem ad vissza a függvény

A határok, hogy egy-egy adott típusú változó mekkora értékeket tud tárolni, a limits.h -ban vannak. A konkrét értékek architektúrafüggők, vagyis egy másik típusú gépen mások lehetnek a határok.

Egy kis program, ami kiír néhányat a határok közül (limits.c):

#include <float.h>
#include <limits.h>
#include <stdio.h>
 
int main() {
    printf("SHORT max:\t %u \n", SHRT_MAX);
    printf("INT max:\t %d \n", INT_MAX);
    printf("UINT max:\t %u \n", UINT_MAX);
    printf("LONG max:\t %ld \n", LONG_MAX);
    printf("CHAR min:\t%d \n", CHAR_MIN);
    printf("CHAR max:\t %d \n", CHAR_MAX);
    printf("FLOAT min abs value:\t %1.45lf (kb. 10 ^ -37)\n", FLT_MIN);
    return 0;
}

A limits programunk kimenete egy 32 bites gépen:

   SHORT max:	 32767 
   INT max:	 2147483647 
   UINT max:	 4294967295 
   LONG max:	 2147483647 
   CHAR min:	-128 
   CHAR max:	 127 
   FLOAT min abs value: 0.000000000000000000000000000000000000011754944 (kb 10 ^ -37)

A limits programunk kimenete egy 64 bites gépen (nézd meg a long típust):

   SHORT max:	 32767 
   INT max:	 2147483647 
   UINT max:	 4294967295 
   LONG max:	 9223372036854775807 
   CHAR min:	-128 
   CHAR max:	 127 
   FLOAT min abs value: 0.000000000000000000000000000000000000011754944 (kb 10 ^ -37)


A fenti limits.c kódban az is látszik, hogy ha printf() vagy scanf() függvénnyel szeretnéd a típusokat kiírni/beolvasni, milyen kódokat kell használni. De azért foglaljuk össze:

  • uint : %u
  • short : %d
  • long : %ld
  • char : %c
  • double: %lf
Nincs külön igazságérték-típus

A C-re épülő későbbi nyelvekben már szokott lenni bool (C++) vagy boolean (Java) típus ami csak két értéket vehet fel (Pythonban is léteztek előre definiáltan a 'True' és 'False' értékek).

C-ben nincs ilyen, itt minden ami nem nulla, az "igaz", és ami nulla az "hamis".


Kiegészítő anyag

Kíváncsiaknak bővebben (nem része a tananyagnak): http://www.cplusplus.com/reference/clibrary/climits/ http://www.cplusplus.com/reference/clibrary/cfloat/ http://www.hit.bme.hu/~vitez/Progalap1/Progalap04.pdf


Tömbök vagy adatvektorok (array)

A tömbök segítségével azonos elemekből álló adathalmazt tárolhatunk. A C-beli tömbök kicsit hasonlítanak a Python-ban tanult listákra, de azért sok fontos különbség is lesz. (Pl az egyik hogy Python listában mindegy volt a típus, C-ban viszont csak azonos típusú elemek lehetnek egy tömbben).

Általános alakjuk:

típus tömbnév[elemszam];

Például, egy 11 elemű, alfa nevű tömb deklarációja, amiben hosszú egészek lehetnek, valamint egy béta tömb ami 23 karaktert tárolhat:

int alfa[11];
char beta[23];

A deklarációkor már lefoglalódik a tömböknek a hely a memóriában, ezért előre meg kell mondanunk hogy hány elemt szeretnénk (legfeljebb) tárolni.

Egy pici kódrészlet, ami feltölti a beta karaktertömbünk első 4 elemét (0-tól sorszámozódnak az elemek):

beta[0] = 'a';
beta[1] = 'l';
beta[2] = 'm';
beta[3] = 'a';

Általában valamilyen ciklussal célszerű feltölteni vagy végigolvasni egy tömböt. Feltöltés (és rögtön kiírásis) végigolvasás for ciklussal:

char beta[23];
int i;
for (i=0; i<tomb_merete; i++) {
    chars[i] = 'a';
    printf("%c\n", chars[i]);
}

Függvények

Ahogy egyre bonyolultabb programokat írunk, célszerű függvényekbe szervezni a működést. Számos előnye van a függvények használatának:

  • a program logikai strukturálása
  • áttekinthetőbb, olvashatóbb lesz a kód
  • elkerüljük a kódismétlést: kevesebbet kell gépelni, ill. csak egy helyen kell javítani ha hiba van (a copy-paste stílusú programozás hosszútávon nem működik)
  • minél általánosabban megírt egy függvény, annál valószínűbb hogy máshol (másik programban) is használható lesz

C nyelven egy függvény deklarációja általánosan így néz ki:

visszatérési_típus függvénynév(param_típus1 param_név1, param_típus2 param_név2, ...);

Nézzünk három példát függvény deklarálására. A második nem ad vissza értéket, ezért void a visszatérési típusa. Az utolsónak pedig nincs bemenő paramétere de a zárójelek akkor is kellenek:

int maximum_ertek(int tomb[], int meret);
void irj_ki_egy_szamot(int szam);
int random_szam();

És most "töltsük is ki" az elsőt, vagyis definiáljuk:

int maximum_ertek(int tomb[], int meret) {
    int max = INT_MIN;  // include limits.h !
    int i;
    for (i=0; i<meret; i++) {
        if (tomb[i] > max) {
            max = tomb[i];
        }
    }
    return max;  // figyelni kell mindig hogya fv visszatérési típusával megegyező típusú értéket adjunk vissza!
}

A másodikat:

void irj_ki_egy_szamot(int szam) {
    printf("%d\n", szam); 
    // ez nem ad vissza értéket, ekkor a "return;" parancs el is hagyható
}
Személyes eszközök