Vissza

Állománykezelés


1. Bájtonkénti feldolgozás

  • Írjunk függvényt, mely meghatározza egy állomány byte méretét (Forráskód)
  • Írjunk függvényt, mely összehasonlítja bájtonként két állomány tartalmát (Forráskód)
  • Írjunk függvényt, mely átmásolja a paraméterként megadott állomány tartalmát egy másik állományba, a feldolgozást végezzük bájtonként.
  • Írjunk függvényt, mely a paraméterként megadott állományról megvizsgálja, hogy:
    • EXE; tudva, hogy az exe állomány első két bájtja: 0x4D, Ox5A
    • JPG; tudva, hogy a jpg első három bájtja: 0xFF, OxD8, 0xFF, utolsó két bájtja pedig: 0xFF, 0xD9
  • Írjunk függvényt, mely a paraméterként megadott állomány tartalmát titkosítja, majd visszafejti, XOR műveletet végezve az állomány egy megadott bájtja és egy véletlenszerűen előállított bájton.

2. Bájt-tömbönkénti feldolgozás: adottak a következő struktúrájú forráskódok, egészítsük ki a következő függvényekkel:

  • rendezzük a qsort könyvtárfüggvénnyel az adatokat, a nevek szerint növekvő sorrendbe,
  • határozzuk meg az állományban szereplő személyek az átlagéletkorát,
  • változtassuk meg egy adott címmel rendelkező személyek telefonszámát (pl. a vásárhelyiek telefonszáma megváltozik),
  • töröljük ki egy adott személy adatait az állományból,
  • határozzuk meg, hogy melyik városban van a legtöbb személy nyilvántartva,
  • adott név alapján keressük meg a személy telefonszámát.
Fontosabb állománykezelő függvények

Állomány bájtmérete:

long long filesize(char *fname){
    FILE *f1;
    long long size;
    f1 = fopen(fname, "rb");
    if ( f1 == NULL ){
       printf("Error open file1\n");
       return 0;
    }
    fseek(f1, 0, SEEK_END);
    size = ftell(f1);
    return size;
}

Állományok tartalmának bájtonkénti összehasonlítása

int compare(char *fname1, char * fname2){
    FILE *f1, *f2;
    char byte1, byte2;
    f1 = fopen(fname1, "rb");
  
    if(f1 == NULL){
        printf("Error open file1\n");
        return 0;
    }
    f2 = fopen(fname2, "rb");
    if(f2 == NULL){
        printf("Error open file2\n");
        return 0;
    }
    while(1){
        if(feof(f1) != 0 && feof(f2) != 0)
        break;
        if(feof(f1)) {
            fclose(f1);
            fclose(f2);
            return 0;
        }
        if(feof(f2)){
            fclose(f1);
            fclose(f2);
            return 0;
        }
        fread(&byte1, sizeof(char), 1, f1);
        fread(&byte2, sizeof(char), 1, f2);
        if( byte1 != byte2) return 0;
    }
    fclose(f1);
    fclose(f2);
    return 1;
}

2. feladat
fuggvenyek.h
#ifndef FUGGVENYEK_H
#define FUGGVENYEK_H
#include <stdio.h>
#include <stdlib.h>

struct people{
    char name[20];
    char city[20];
    int year;
    char tel[10];
};

typedef struct people PType;
int create_db(char *fname);
void insert_db(char * fname);
void list_db(char *fname);
int open_db(char *fname);

#endif

fo.cpp
#include "fuggvenyek.h"

int main(){
    char op;
    char name[20];
    while(1){
        system("cls");
        printf("0 Quit\n");
        printf("1 Create\n");
        printf("2 Open\n");
        printf("3 Insert\n");
        printf("4 List\n");
        fflush(stdin);
        op = getchar();
        switch (op){
            case '1':
                printf("file name: ");
                scanf("%s", name);
                create_db(name);
                break;
            case '2':
                printf("file name: ");
                scanf("%s", name);
                open_db(name);
                break;
            case '3':
                insert_db(name);
                break;
            case '4':
                list_db(name);
                break;
            case '0':
                return 0;
         }
    }
    return 0;
}

fuggvenyek.cpp
#include "fuggvenyek.h"

int create_db(char *fname){
    FILE *f = fopen(fname, "wb");
    if ( f == NULL ){
        printf("Error open\n");
        system("pause");
        return 0;
    }
    fclose(f);
    return 1;
}

int open_db(char *fname){
    FILE *f = fopen(fname, "rb");
    if ( f == NULL ){
        printf("Error open\n");
        system("pause");
        return 0;
    }
    fclose(f);
    return 1;
}

void insert_db(char * fname){
    PType p;
    FILE *f = fopen(fname, "ab");
    if ( f == NULL ){
        printf("Error open\n");
        system("pause");
        return;
    }
    printf("nev: ");
    scanf("%s", p.name);
    printf("eletkor: ");
    scanf("%i", &p.year);
    printf("varos: ");
    scanf("%s", p.city);
    printf("telefonszam: ");
    scanf("%s", p.tel);
    fwrite(&p, sizeof(PType), 1, f);
    fclose(f);
}

void list_db(char *fname){
    PType p;
    FILE *f = fopen(fname, "rb");
    if ( f == NULL ){
        printf("Error open\n");
        system("pause");
        return;
    }
    while(1){
        fread(&p, sizeof(PType), 1, f);
        if(feof(f)) break;
        printf("%21s%21s%11s%5i\n", p.name, p.city, p.tel, p.year);
    }
    system("pause");
    fclose(f);
}


Fontosabb állománykezelő függvények

  • FILE * fopen ( const char * fname, const char * mode);
    megnyitja az állományt írásra, vagy olvasásra, hiba esetén NULL pointert térít vissza
  • int rename (const char * oldname, const char * newname);
    átnevezi a megadott nevű állományt.
  • int remove (const char * filename);
    törli a megadott nevű állományt, hiba esetén visszatérési érték 0-tól különböző.
  • int fgetc( FILE * fp);
    int fputc(char c, FILE * fp);
    karakter írás/olvasás
  • size_t fread(void * ptr, size_t size, size_t n, FILE *fp);
    size_t fwrite(const void * ptr, size_t size, size_t n, FILE *fp);

    n darab size hosszúságú csomagot olvas/ír, a ptr mutatóval címzett tömbbe/ből, visszatérési értéke: a reálisan átvitt csomagok száma, az feof() és ferror() függvényeket használjuk a hibák tesztelésére
  • char * fgets(char * s, int n, FILE * fp);
    egy szövegsort, maximum n-1 karaktert olvas, végére \0 -t illeszt (de beolvassa a \n -t is a sor végére, ellentétben a gets() függvénnyel), visszatérési érték: s, illetve NULL hiba vagy EOF esetén.
  • char * fputs(const char * s, FILE * fp);
    kiírja a karakterláncot az állományba, visszatérési értéke: pozitív egész, illetve EOF hiba esetén
  • int ungetc ( int c, FILE * fp );
    "visszaküldi" az utolsónak olvasott karaktert az állományba
  • int fscanf ( FILE *fp, char * format, ...);
    int fprintf( FILE *fp, char * format, ...);

    a printf/scanf file szintű megfelelői
  • int fseek(FILE * fp, long offset, int origin);
    más pozícióra lépteti az állománymutatót, az új pozíció helye: az origin + offset számú byte (karakter), visszatérési értéke hiba esetén nem nulla; az origin lehet:
    SEEK_SET (file eleje),
    SEEK_CUR (pillanatnyi hely),
    SEEK_END (file vége).
  • long ftell(FILE * fp);
    visszatéríti az állománymutató pillanatnyi pozícióját az állományban, illetve EOF-t hiba esetén
  • int fgetpos (FILE * fp, fpos_t * ptr);
    int fsetpos (FILE * fp, const fpos_t ptr);

    a két függvény az új pozícióra ugrást oldja meg együtt
  • int fclose(FILE * fp);
    lezárja az állományt, kiírja a buffer adatait, felszabadítja az fp-t, visszatérési érték: 0 illetve EOF hiba esetén
  • int fflush( FILE * fp );
    lemezre írja az fp-hez rendelt buffert. Amennyiben az fp helyett egy NULL mutatót adunk argumentumként, valamennyi írásra nyitott állomány bufferét kiírja. Hiba esetén a visszatérési érték EOF, egyébként 0.
  • void rewind( FILE * fp );
    visszaugratja az állománymutatót az állomány elejére
  • FILE * freopen( const char * path, const char * mode, FILE * fp );
    megnyitja az állományt átirányítás végett, például: freopen ( "out.txt","w", stdout); átirányítja a standard kimenetre (stdout) írt adatokat a out.txt nevű, lemezen található állományba.
Hibakezelés: hibát a stderr-re írunk, utána az exit függvényt használjuk, amennyiben a programból kell kilépni, illetve return-t függvény esetén.
  • int ferror (FILE * fp);
    visszatérési értéke 0, illetve más egész szám hiba esetén
  • int feof(FILE * fp);
    visszatérési értéke 0, illetve más egész szám EOF esetén
  • void perror(const char * s)
    kiírja az s karakterláncot és az errno változóban levő kódnak megfelelő hibát.