Informatika2-2012/Eloadas03

A MathWikiből
(Változatok közti eltérés)
a (Kiegészítő anyag)
a (Adattípusok, függvények)
103. sor: 103. sor:
 
http://www.cplusplus.com/reference/clibrary/cfloat/ <br />
 
http://www.cplusplus.com/reference/clibrary/cfloat/ <br />
 
http://www.hit.bme.hu/~vitez/Progalap1/Progalap04.pdf <br />
 
http://www.hit.bme.hu/~vitez/Progalap1/Progalap04.pdf <br />
 +
 +
  
 
=== Tömbök vagy adatvektorok (array) ===
 
=== Tömbök vagy adatvektorok (array) ===
138. sor: 140. sor:
 
}
 
}
 
</c>
 
</c>
 +
 +
  
 
=== Függvények ===
 
=== Függvények ===

A lap 2012. február 22., 10:39-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
Túlcsordulás

Próbáljuk ki, mi történik ha feszegetjük a határokat: Legyen két int változónk, amiket összeadva már nagyobb értéket kapunk a tárolható maximálisnál:

#include <stdio.h>
#include <limits.h>
 
int main() {
    int egyik = INT_MAX;
    printf("egyik: %d \n", egyik);
    int masik = 1;
    printf("masik: %d \n", egyik);
    int osszeg = egyik + masik;
    printf("osszeg: %d \n", osszeg);
    return 0;
}

És a kimenet:

  egyik: 2147483647 
  masik: 2147483647 
  osszeg: -2147483648 

Egy jó nagy negatív számot kaptunk. Ezt hívják túlcsordulásnak. Ezért kell körülbelül előre megbecsülni hogy a programunk mekkora számokkal fog dolgozni, és ha sejtjük hogy nagyon nagy (vagy nagyon kicsi) számok is előfordulhatnak, akkor inkább long ill. double típusokat használjunk int és float helyett. Ennek az lesz az ára, hogy kicsit több memóriát fog foglalni a programunk a futása közben.


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