Informatika2-2013/Osszefoglalas1 6

Menetrend

Az összefoglalás elején leírom, hogy a gyakorlatokon mikrõl volt szó.

A tervezettbõl eddig kész: 20%

Várható befejezés: 01:00

1. gyakorlat

A gyakorlat elején gcc-vel fordítottunk egy "hello world" programot. Hasznos tudni, hogy hogyan lehet így terminálból fordítani egy C programot.

Majd megtanultuk a Codeblocks / Codelite használatát, ezekbõl nem igazán tudnánk mit visszakérdezni, ezeket a kényelem kedvéért mutattuk meg.

A gyakorlat végén pedig egy nagyon egyszerû kiegészítendõ feladatot oldottunk meg, aminek annyi volt a lényege, hogy lássátok hogyan kell deklarálni változókat (pl: int x;) és hogyan kell használni egyszerû elágazást.

2. gyakorlat

Megtanultuk hogyan lehet scanf-el beolvasni:

int z;
scanf("%d", &z);

Ekkor még nem tudtuk miért kell az & jel a z elé, de mostmár tudjuk, hogy ez azért kellett, hogy a változóba beleírhassa a felhasználó által beírt értéket. Emlékezzük vissza miért nem lehet ezt pointer nélkül megoldani:

void swap(int x, int y){
    int temp = x;
    x = y
    y = temp;
}
 
void swap2(int* x, int* y){
    int temp = *x;
    *x = *y
    *y = temp;
}
 
int main(void){
    int a = 6;
    int b = 8;
    swap(a, b);
    printf("%d %d", a, b); // 6 8-at ír ki
    swap2(&a, &b);
    printf("%d %d", a, b); // 8 6-ot ír ki
    return 0;
}

Itt az elsõ swap függvén igaz úgy tûnik hogy megcseréli a változók értékét, de valójában csak a róluk készült másolatok értéket cserélte meg, és így a main-ben nem történt csere. Viszont a swap2 pointereken keresztül jól megcseréli a valódi a és b változó értékét.

A gyakorlat része volt még a ciklusokkal való ismerkedés:

for(inicializálás; feltétel; inkrementálás){
    utasítások
}
 
while(feltétel){
    utasítások
}
 
do{
    utasítások
} while(feltétel);

A for ciklust sokszor használtuk, tömbökön való végigjáráshoz, leszámolásokhoz, mindenféléhez. while-t kevésbé, de végülis helyettesíthetõ egy for(;feltétel;) ciklussal. do while-t pedig mégkevésbé használtuk, ennek ugye a sajátossága, hogy amikor belép a ciklusba elõször akkor nem ellenõrzi a feltételt, tehát ha egy mindig hamis feltételünk van a ciklus magja akkor is lefut egyszer.

Ciklusokkal megkerestük folyamatosan érkezõ számoknak a minimumát vagy maximumát, ez azon az egyszerû ötleten alapult, hogy mindig mentettük az eddig talált legkisebb számot (minimum esetén) és ezzel hasonlítottuk össze az éppen érkezõt. Majd aszerint hogy kisebb volt az eddigi legkisebbnél a most vizsgált vagy sem, beállítottuk ezt a legkisebbnek, vagy csak mentünk tovább.

3. Gyakorlat

A gyakorlat elején megtudtuk, hogy a változóink végesek, így nem tárolhatunk bennük akármekkora számot.

Írtunk for ciklusokkal pár feladatot, majd áttértünk a gyakorlat anyagára, amik a típusok voltak.

Tömböket is megtanultunk használni, egy egyszerû példa:

#include<stdio.h>
 
int main(void) {
    int t[20];     // Itt hozzuk letre a tombot, elore megadjuk a meretet
    int i;
    t[5] = 5 * 5;             // Igy tudunk egy elemenek erteket adni
    t[6] = t[5] + 11;         // Vagy felhasznalni ertekkent
    for(i = 0; i < 20; i++) { // Ez a ciklus vegzi el a munkankat
        t[i] = i * i;
    }
    return 0;
}

4. Gyakorlat

A gyakorlat két nagyon fontos dolgot vezetett be, a függvényeket és a pointereket.

v_ért fv_név(p_típus1 p_név1, p_típus2 p_név2){
    /*  */
    return érték;
}

Függvényeknek definíciója a visszatérési értékükkel kezdõdik, majd a függvény neve és zárójelben a bemeneti paraméterek. Mint minden blokkal rendelkezõ szerkezetnél itt is kapcsos zárójellel kell elkezdeni és bezárni a blokkot, azaz a függvény magját. Ha a függvényben valahol return-ölünk egy értéket, a függvény visszatér, kilép, azaz a return utáni rész már nem fut le. Ezért az alábbi két függvény ekvivalens:

int fv(int a){
    if(a < 0){
        return -a;
    }
    else{
        return a;
    }
}
 
int fv2(int a){
    if(a < 0){
        return -a;
    }
    return a;   // Ez csak akkor fut le ha az if feltétele hamis volt, mert különben a függvény visszatér -a-val
}

Függvényeket lehet értékként is használni, így ha van egy átlag függvényünk, nem kell külön változóba elmenteni az általa visszaadott értéket:

printf("%lf", atlag(3.2, 6));

Pointerekrõl már írtam korábban, amit még megemlítenék, hogy a tömbök pointerek és a pointerek tömbök. Így ha t egy tömb vagy pointer, akkor t[0] és *t ekvivalens, továbbá, ha létezik i. indexû eleme, akkor t[i] és *(t+i) is ekvivalensek.

5. Gyakorlat

A gyakorlat elsõ felében dinamikus memóriakezelésrõl volt szó. Korábban csak fix méretû tömböket tudtunk létrehozni:

int t[20];

Ha dinamikusan foglalunk le memóriát akkor bármilyen pozitív egész változó méretû tömböt lefoglalhatunk:

int m;          // ebbe olvassuk be a tömb méretét
scanf("%d",&m);  
int *vec = (int *)malloc(m * sizeof(int)); // itt foglaljuk le a memóriát a tömbnek