|
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.
|