9. hét: parancssor, fájlkezelés, modulok

#include <stdio.h>

int main(int argc, char *argv[]) {
    /* argv[0] a program neve, és argv[argc]=NULL.
     * ezért 1-től argc-1-ig kell mennie a ciklusnak. */
    for (int i = 1; i < argc; ++i)
        printf("%d. %s\n", i, argv[i]);
    
    return 0;
}

#include <stdio.h>

int main(int argc, char *argv[]) {
    /* a buktato: argv[0], vagyis a nulladik parancssori argumentum
     * a program neve. ez beleszamit a kapott argumentumok szamaba,
     * ezert pontosan 2 argumentum eseten argc erteke 3 lesz! */
    if (argc == 3)
        printf("Ket parancssori argumentumot kaptam.\n");
    else
        printf("Hiba: nem pontosan ket argumentumot kaptam!\n");
    
    return 0;
}

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {
    double a, b, e;
    
    if (argc != 4) {
        printf("Harom argumentum kell: ket szam, es kozte egy muveleti jel!\n");
        return 1;
    }
    
    /* az argumentumokat sztringkent (!) kapjuk, ezekbol
     * az sscanf-fel kiolvashato a szamertek. */
    if (sscanf(argv[1], "%lf", &a) != 1
        || sscanf(argv[3], "%lf", &b) != 1) {
        printf("Az elso es a harmadik argumentum legyen szam!\n");
        return 1;
    }
    
    if (strlen(argv[2]) != 1) {
        printf("A masodik argumentum egy muveleti jel legyen!\n");
        return 1;
    }
    /* argv[2] a masodik parameter, argv[2][0] annak legelso karaktere. */
    if (argv[2][0] != '+' && argv[2][0] != '-'
        && argv[2][0] != '*' && argv[2][0] != '/') {
        printf("A masodik argumentum egy muveleti jel legyen!\n");
        return 1;
    }
    
    switch (argv[2][0]) {
        case '+': e = a+b; break;
        case '-': e = a-b; break;
        case '*': e = a*b; break;
        case '/': e = a/b; break;
        default: /* lehetetlen */ break;
    }
    
    printf("Az eredmeny: %g\n", e);
    return 0;
}

A következő dolgokra kell figyelni:

• A main két paramétere int argc és char *argv[]. Az utóbbi a paramétereket tartalmazza sztring formájában, az előbbi pedig a paraméterek száma +1. argv[0] a program neve, innen adódik a +1 – erre figyelni kell, amikor indexeljük a tömböt, illetve argc-t vizsgáljuk. Ha 1 paraméter van, argc értéke 2 lesz!
• Mivel char *argv[] sztringeket tartalmaz, konvertálni kell azokat szám formába. Lent nem teszem, de az sscanf függvény visszatérési értéke lehetővé tenné ennek ellenőrzését.

A memória foglalásoknál meg kell nézni, hogy sikeresek-e. A foglaláshoz lent egy külön függvény van, ahol ez jól látszik. A feladat megoldása egyébként elég egyszerű; inkább a lexikai tudásból igényel sokat, parancssori argumentumok kezelése stb.

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

double **foglal(int meret) {
    double **tomb;
    tomb = (double **) malloc(meret * sizeof(double *));
    if (!tomb) {
        fprintf(stderr, "Memoriafoglalasi hiba\n");
        exit(1);        /* jobb hijan kiugrunk a programbol */
    }
    for (int y = 0; y < meret; ++y) {
        tomb[y] = (double *) malloc(meret * sizeof(double));
        if (!tomb[y]) {
            fprintf(stderr, "Memoriafoglalasi hiba\n");
            exit(1);
        }
    }

    return tomb;
}

void felszabadit(double **tomb, int meret) {
    for (int y = 0; y < meret; ++y)
        free(tomb[y]);
    free(tomb);
}

int main(int argc, char *argv[]) {
    int meret = sqrt(argc - 1);
    /* nezzuk, hogy negyzetszam-e */
    if (meret * meret != argc - 1) {
        fprintf(stderr, "Nem negyzetszam a parameterek szama!\n");
        exit(1);
    }

    double **be = foglal(meret);
    double **ki = foglal(meret);

    /* beolvasas */
    for (int y = 0; y < meret; ++y)
        for (int x = 0; x < meret; ++x)
            sscanf(argv[y * meret + x + 1], "%lf", &be[y][x]);

    // negyzet kiszamitasa - ez a feladat lenyege
    for (int y = 0; y < meret; ++y)
        for (int x = 0; x < meret; ++x) {
            double osszeg = 0;
            int i;
            for (int i = 0; i < meret; ++i)
                osszeg += be[y][i] * be[i][x];

            ki[y][x] = osszeg;
        }

    /* kiiras */
    for (int y = 0; y < meret; ++y) {
        for (int x = 0; x < meret; ++x)
            printf("%8.4lf ", ki[y][x]);
        printf("\n");
    }

    felszabadit(be, meret);
    felszabadit(ki, meret);

    return 0;
}

Ez szinte ugyanaz, mint a félév eleji változat, amelyik a billentyűzetről olvasott. Fájlból olvasni, fájlba írni semmivel nem nehezebb: minden függvény neve elé még egy f betű kerül ( printf-fprintf, scanf-fscanf), és első paraméter a fájl, amin dolgozni kell.

#include <stdio.h>

char kodol(char c) {
    /* ez a ketto specialis, mert "tulpordul" */
    if (c=='z') return 'a';
    if (c=='Z') return 'A';
    /* tobbi kodolando */
    if ((c>='a' && c<'z') || (c>='A' && c<'Z'))
        return c+1;
    /* ha nem ezek, marad valtozatlanul */
    return c;
}

int main(void) {
    FILE *be = fopen("eredeti.txt", "r");
    if (be == NULL) {
        perror("eredeti.txt megnyitása");
        return 1;
    }
    FILE *ki = fopen("kodolt.txt", "w");
    if (ki == NULL) {
        perror("kodolt.txt megnyitása");
        return 2;
    }

    /* egyesevel a karakterek */
    int c;
    while ((c = fgetc(be)) != EOF)
        fputc(kodol(c), ki);

    fclose(be);
    fclose(ki);
    return 0;
}

#include <stdio.h>
#include <stdbool.h>

int main(void) {
    typedef struct Datum {
        int ev, honap, nap;
    } Datum;
    typedef struct Meres {
        int ora, perc;
        double fok;
    } Meres;

    /* fussunk neki */
    FILE *fbe = fopen("eredmenyek.txt", "r");
    if (!fbe) {
        perror("eredmenyek.txt: nem sikerult megnyitni a fajlt");
        return 1;
    }

    Datum d;
    Meres beolv, max;
    fscanf(fbe, "%d %d %d", &d.ev, &d.honap, &d.nap);
    /* a maximumkeresesnel az elso megkulonbozteteset
       itt segedvaltozoval oldottam meg */
    bool elso = true;
    while (fscanf(fbe, "%d:%d %lf", &beolv.ora, &beolv.perc, &beolv.fok) == 3) {
        if (elso || beolv.fok > max.fok)
            max = beolv;
        elso = false;
    }
    /* ennyi */
    fclose(fbe);

    /* eredmeny kiirasa, formatumsztring */
    printf("%d.%02d.%02d. %02d:%02d %+g\n",
           d.ev, d.honap, d.nap,
           max.ora, max.perc, max.fok);

    return 0;
}

Az fread() függvénnyel tudunk a fájlból olvasni, és figyelni kell a "b" betűre a fájl megnyitásánál.

A fájl méretét megadó függvény a C-ben nincs. Helyette azt csinálhatjuk, hogy a végére ugrunk (fseek()), és lekérdezzük a pozíciót (ftell()).

#include <stdio.h>

/* kulturalt fuggveny: a fajlbol elugrik mashova,
   de vissza is ugrik oda, ahol eredetileg volt */
long meret(FILE *fp) {
    long pos, meret;

    pos = ftell(fp);
    /* 0 bajt a vegehez kepest, az pont a vege */
    fseek(fp, 0, SEEK_END);
    meret = ftell(fp);
    fseek(fp, pos, SEEK_SET);
    return meret;
}

int main(int argc, char *argv[]) {
    if (argc != 3) {
        fprintf(stderr, "Ket fajlnevet kerek!\n");
        return -1;
    }

    FILE* f1 = fopen(argv[1], "rb");
    if (f1 == NULL) {
        perror(argv[1]);
        return 1;
    }
    FILE* f2 = fopen(argv[2], "rb");
    if (f2 == NULL) {
        perror(argv[2]);
        fclose(f1);     /* nagyon kis rendesek vagyunk */
        return 2;
    }

    if (meret(f1) != meret(f2)) {
        fprintf(stderr, "Nem egyforma meretuek!\n");
        fclose(f1);
        fclose(f2);
        return 3;
    }

    /* amig sikerul az elso fajlbol olvasni */
    unsigned char buf1[512], buf2[512];
    size_t beolv, pos;
    pos = 0;
    while ((beolv = fread(buf1, 1, sizeof(buf1), f1)) > 0) {
        /* ennek is mennie kell */
        fread(buf2, 1, sizeof(buf2), f2);

        /* csak annyit hasonlitunk, amennyit beolvastunk! */
        for (int i = 0; i < beolv; i++) {
            if (buf1[i] != buf2[i])
                /* pos: eddig feldolgozott bajtok,
                   +i: a most vizsgalt bajt */
                printf("%08x %02x %02x\n", pos + i, buf1[i], buf2[i]);
        }

        pos += beolv;
    }

    fclose(f1);
    fclose(f2);

    return 0;
}