Szakkörök‎ > ‎Algoritmus szakkör‎ > ‎2005-2006‎ > ‎

1. óra

Tervezés

Ezen az órán kipróbáltunk két programtervezési módszert: Az egyik a program felülről lefelé finomítással való megtervezése volt; a másik a futásidőben használt adatok jobb csoportosítása rekord adatstruktúrákkal. Mindkét módszer a program felépítésének az átláthatóságát javította.

Felülről lefelé finomítás

Kezdetben feltételezzük, hogy van egy számítógép-parancs, ami pont a mi feladatunkat oldja meg. Ilyenkor igencsak egyszerű a programunk: meghívja ezt a parancsot. Mivel sajnos ritkán van ilyen szerencsénk, tovább kell lépnünk: a következő lépésben implementáljuk ezt a parancsot mi magunk! Bontsuk fel néhány összefüggő egységre, és most azt képzéljük, hogy ugyan az eredeti parancsra még mindig nincs számítógép-parancsunk, de ezekre az egységekre már van. Tehát az eredeti parancs helyett írunk egy eljárást, ami kiadja ezeket a parancsokat. (A parancsokon kívűl esetleg tartalmazhat néhány elágazást, vagy más vezérlési szerkeztet.) Látható, hogy az itt kiadott parancsok helyett is eljárásokat kell írnunk, és az azokban kiadott parancsok helyett is, és így tovább mindaddig, amíg el nem jutunk egy egyszerüségig, ami már könnyen leprogramozható. Az általános tanács az, hogy minden eljárás valami jól körülhatárolható, viszonylag egyszerü dolgot csináljon.

Lehetséges, hogy írunk majd olyan eljárást is, amit több különböző felsőbbszintű eljárás is meghív, ez különösen jó dolog.

Rekord adatsruktúra

Az objektum-orientált filozófia egyik fontos része az az elv, hogy az összetartozó adatokat egy helyen kell tárolni. Ez könnyen alkalmazható programunk átláthatóbbá tételére OO-t nem támogató nyelveken is, mint pl. Pascal, C. Erre Pascalban a RECORD, C-ben pedig a struct nyelvi elem szolgál. Például, ha 1000 racionális számot akarunk tárolni tört alakban, akkor azt eddig így csináltuk:

CONST
    maxn = 1000;
VAR
    szamlalok: ARRAY [1..maxn] OF INTEGER;
    nevezok: ARRAY [1..maxn] OF INTEGER;

Sokkal szemléletesbb azonban a következő megoldás:

CONST
    maxn = 1000;
TYPE
    TRac = RECORD
        szamlalo, nevezo: INTEGER;
    END;
VAR
    szamok: ARRAY [1..maxn] OF TRac;

Rekordokat természetesen nem csak tömbökben vehetünk fel, példánkban a TRac egy a nyelv beépített típusaival (INTEGER, STRING) egyenértékűen használható típus. A rekordokban tárolt adattagok a . operátorral érhetők el:

VAR
    a, b: TRac;
BEGIN
    a.szamlalo := 1; a.nevezo := 2;
    b.szamlalo := 42; b.nevezo := 84;
    szamok[1] := a;
    szamok[2] := a;
    szamok[3].szamlalo := 53;
    szamok[3].nevezo := 37;
END.

Az előbbi programrészben például az is a jó, hogy írhatunk TRac típusú paramétereket átvevő pl. összadó, szorzó, egyszerüsítő eljárásokat, és ha a programunk többi részében azokat használjuk, akkor ha egyszer majd át akarunk állni pl. komplex számokra is, akkor csak azokat az eljárásokat kell módosítani.
OO nyelvekben lehetőség van az adatsrtuktúra típusok, és a rajtuk műveleteket végző eljárások szorosabb összekapcsolására, adatrejtésre, és az adatstruktúrák egymásra építésére is. Kisebb programoknál ezekre még nincs olyan nagy szükség...

A példa C-ben

Az eredeti deklarációk:

#define MAXN 1000

int szamlalok[maxn];
int nevezok[maxn];

A struktúrált deklarációk:

#define MAXN 1000

struct SRac {
    int szamlalo;
    int nevezo;
};

SRac szamok[maxn];

int main() {
    SRac a, b;
    a.szamlalo = 1; a.nevezo = 2;
    b.szamlalo = 42; b.nevezo = 84;
    szamok[0] = a; szamok[1] = b;
    szamok[2].szamlalo = 53;
    szamok[2].nevezo = 37;
}

Feladat