Kódolási stílus – javaslatok

Czirkos Zoltán · 2016.08.28.

Megjegyzések és javaslatok a szépen írt, áttekinthető programokhoz.

Érdemes szem előtt tartani a következő dolgokat.

Olvashatóság – alapok

  • Írjunk jól olvasható kódot. Ennek a legegyszerűbb módja azt írni, amit gondolunk. Ne trükközzünk a nyelvi elemekkel a szép, egyszerű programok írása helyett!
  • Ne optimalizáljunk feleslegesen. Csak akkor, ha kiderül, hogy lassú a programunk.
  • Indentáljuk a kódot, még papíron is. Vegyük észre ezáltal azt is, hogy mennyire hasonlít a megírt kód a struktogramra. Ez segít átlátni a program szerkezetét!
  • Törekedjünk arra, hogy a programkódunk (a feladat megoldása) minél jobban hasonlítson a feladat szövegére. Ne vigyünk bele a megoldásba felesleges csavarokat! Pl. ha 1-től 100-ig ki kell írni a számokat, a szép megoldás ez:
    for (i = 1; i <= 100; ++i) printf("%d\n", i);
    A működő, de nem annyira szerencsés megoldások pedig:
    for (i = 1; i < 101; ++i) printf("%d\n", i);   // hol a „101” a feladat szövegében?
    
    for (i = 0; i < 100; ++i) printf("%d\n", i+1); // hol a „+1” a feladat szövegében?
    (True story.)
  • Használjunk néven nevezett konstansokat és felsorolt típusokat mágikus számok helyett!
  • Használjunk értelmes változóneveket, és használjunk függvényeket a részfeladatokhoz! Például, mit csinál a következő program?
    int main(void) {
        int a, b, c, d;
        
        d = 2;
        a = 0;
        while (a < 20) {
            b = 1;
            for (c = 2; b && c <= d/2; c++)
                if (d % c == 0)
                    b = 0;
            if (b) {
                printf("%d ", d);
                a++;
            }
            d++;
        }
        
        return 0;
    }

    Megoldás

    Ugyanazt, mint ez:

    bool prim(int szam) {
        int oszto;
        for (oszto = 2; oszto <= szam/2; oszto++)
            if (szam % oszto == 0)
                return false;
        return true;
    }
    
    int main(void) {
        int db, vizsgalt;
        
        vizsgalt = 2;
        db = 0;
        while (db < 20) {
            if (prim(vizsgalt)) {
                printf("%d ", vizsgalt);
                db++;
            }
            vizsgalt++;
        }
        
        return 0;
    }

Karbantarthatóság – a program struktúrája

  • Soha, de soha ne copy-pasteljünk kódot! A copy-pastelt kód helyett használjunk ciklust vagy függvényt a feladattól függően.
  • Ne használjunk goto-t, break-et, continue-t feleslegesen. Egy-két nagyon speciális esettől eltekintve szebb kódot lehet írni nélkülük.
  • Függvény – hacsak nem ez a feladata – nem csinál I/O-t. Azért függvény, hogy paraméterekben fogadjon és visszatérési értékben/paraméterben adjon vissza dolgokat. Az I/O a hívó és a felhasználói felület dolga. Az esetleges diagnosztikai kiíratások persze lehetnek kivételek, de az is inkább valami naplózó keretrendszer használatával (vagy pl. #ifdef DEBUG-okkal védve) javasolt.
  • Függvény ne hívjon kilépéssel, hasonlókkal kapcsolatos dolgokat, mert a felsőbb szintű kódot ez meglepetéssel fogja érinteni (fájlok lezárása, takarítás elmarad). Ha szükséges, akkor legyen a programnak valami fatal_error() függvénye, azt hívjuk.
  • Haladóknak: mivel a C-ben nincsenek kivételek (exception), ezért sokszor bonyolult a hibakezelés. Más lehetőségünk nem nagyon van, mint hibajelző visszatérési értékeke használata. De ekkor is különítsük el a valós paramétereket a hibajelzésre használatos flagektől, ha lehet.
  • Legyen egyértelmű specifikáció arról, hogy mik a paraméterek és kinek a felelősége ellenőrizni a bemenő paraméterek értelmességét.
  • Alakítsunk ki értelmes adatszerkezeteket.

Nyelvi eszközök

  • A for() ciklus tipikusan a „valahonnan valahová el akarok jutni, valamilyen lépésközzel” jellegű feladatokra való, a while() ciklus a „tekerjünk addig, amíg valami feltétel fennáll” jellegűekhez.
  • Ezért ha valóban ilyen feladatot oldunk meg, akkor a ciklus fejlécében ezek legyenek, a ciklus törzsében meg a tennivalók. Ne rakjuk át az iterátor léptetését a ciklustörzsbe, ne rakjuk a ciklustörzset be a fejlécbe stb.
  • Lehetőleg ne legyen üres ciklustörzs, vagy ha mégis, akkor a ciklustörzs helyére tegyünk kommentet, hogy ordítson, hogy üres.
  • Ne írjunk a feltételekhez üres igaz ágat, inkább tagadjuk a feltételt! Tehát ehelyett:
    if (x < 0)
        ;
    else
        printf("nem negatív");
    Inkább írjuk ezt:
    if (x >= 0)
        printf("nem negatív");
  • Operátorok: a mellékhatásokkal járó műveleteknél ne arra törekedjünk, hogy mindenáron a mellékhatást használjuk ki főhatásnak.
  • Ne keverjük a logikai és az aritmetikai kifejezéseket, hiába van rá mód. Például: egy szám akkor osztható egy másikkal, ha az osztás maradéka nulla. Vagyis:
    • helyes: if (szam%oszto == 0)... osztás maradéka, egyenlő, nullával.
    • (stilisztikailag) helytelen: if (!(szam%oszto))... a maradékot tagadom?! Kérdés: igaz-e az a kijelentés, hogy „Öt.”? Ez így nyilván nem is kijelentés...
  • A pointer aritmetika sok feladatnál szép és hatékony, de ha az algoritmusunk nem arra épül, kerüljük a használatát! A tömb az legyen tömb:
    • Helyes: t[10], olvashatóság szempontjából helytelen: *(t+10)
    • Ugyanez három dimenzióban: t[2][5][7] vs. *(*(*(t+2)+5)+7).
  • Az inicializálatlan változó veszélyes hibaforrás, de ez nem jelenti azt, hogy minden változónak kényszeresen kezdeti értéket kell adnunk definiáláskor. Helyes:
    double tomb[100], szum;
    
    szum = 0;
    for (i = 0; i < 100; ++i)
        szum += tomb[i];
    Helytelen stílus:
    double tomb[100], szum = 0;
    
    /*
     *
     * sok sornyi kod...
     *
     */
    
    /* hova lett a szum = 0? nem kéne az az
     * összegzés elejére? vagy már egy meglévő
     * részösszeghez adjuk hozzá ezeket is? */
    for (i = 0; i < 100; ++i)
        szum += tomb[i];
    Ha kicsit átírjuk a programot, és máshova másoljuk ezt a részt, végképp ki fog maradni az értékadás... Az erőltetett hamar-kezdeti-értékadás következménye szokott lenni az ilyen jellegű kód is:
    int oszto = 2;                /* <- inicializalt valtozo... de minek? */
    
    /* kiirja a szamok primtenyezos felbontasat */
    for (i = 2; i <= 10; i++) {
        printf("%d: ", i);
    
        szam = i;
        while (szam > 1) {
            while (szam%oszto == 0) {
                printf("%d ", oszto);
                szam /= oszto;
            }
            oszto++;
        }
    
        oszto = 2;          /* elso ranezesre: ez meg mit keres itt?! */
                            /* hiszen mar nem csinalunk vele semmit! */
                            /* most vegeztunk a primtenyezokkel! minek */
                            /* az osztonak ujra erteket adni akkor? */
    
        printf("\n");
    }
    A lenti sokkal jobb, sőt így csak egyszer kell leírni:
    for (i = 2; i <= 10; i++) {
        printf("%d: ", i);
    
        int oszto = 2;          // ennek itt a helye!
        szam = i;
        while (szam > 1) {
            while (szam%oszto == 0) {
                printf("%d ", oszto);
                szam /= oszto;
            }
            oszto++;
        }
    
        printf("\n");
    }

Pointerek, tömb átadása függvénynek, dinamikus memóriakezelés

  • C-ben egy tömböt függvénynek átadva a tömb kezdőcíme adódik át, azaz egy pointer. Ezt a pointert formálisan nem lehet megkülönböztetni az egyetlen változóra mutató pointertől:
    void intet_novel(int *i);
    int x = 3;
    intet_novel(&x);
    void tombot_kiir(int *i, int meret);
    int tomb[10];
    tombot_kiir(tomb, 10);
    Dokumentáljuk a függvényél azt, hogy egy változóra mutató pointert vagy tömböt kap! Előnyös lehet, ha a definiálatlan méretű tömb szintaxist használjuk a függvényparamétereknél. De ne feledjük, hogy ilyenkor is pointer adódik át:
    void tombot_kiir(int i[], int meret); // jól olvasható!
  • Ha egy függvény pointerrel tér vissza, a dokumentációjába kötelező berakni, hogy az dinamikusan foglalt memóriaterület vagy nem, továbbá hogy kinek a dolga felszabadítani azt, ha igen.
  • A dinamikusan foglalt memóriát akkor foglaljuk, amikor először szükség van rá (ne előbb), és akkor szabadítsuk fel, amikor már nincs rá szükség (ne később)! Annyival is nehezebb megfeledkezni bármelyikről.
  • A dinamikusan foglalt memóriaterületeket rendeljük hozzá gondolatban (és a dokumentációban) valamihez. Ez egyértelművé teszi, melyik programrésznél van a felszabadítás helye.
  • Kövessük a malloc()-free(), és az fopen()-fclose() logikáját! Ezt ismeri mindenki.
    Fájl megnyitása, fájlművelet, bezárás:
    FILE *fp;
    fp = fopen("fajl.txt", "rt");
    fprintf(fp, "Hello");
    fclose(fp);
    Saját halmaz típus:
    typedef struct Halmaz {
       int elemszam;
       int *dintomb;
    } Halmaz;
    Halmaz *h;
    h = uj_halmaz();
    halmaz_betesz(h, 5); halmaz_betesz(h, 9);
    halmaz_felszabadit(h);
    Ebben az elemeket tároló tömb is dinamikus, és a struktúrák is dinamikusan foglalódhatnak. Mégis milyen könnyű használni!