5.1 datoteke

DATOTEKE

Dosadašnji programi, sve su svoje podatke držali u varijablama. Varijable su smještene u radnoj memoriji. Program dakle za vrijeme izvršavanja zauzima određeni dio radne memorije, koji se nakon završetka rada programa oslobađa. Drugim riječima, nakon što program završi s radom on "zaboravi" sve podatke sa kojima je raspolagao. Ovo je osnovni problem rada sa varijablama. Također, pri radu sa varijablama može se dogoditi da program ne raspolaže sa dovoljno radne memorije. U tom slučaju program se ne može niti izvršavati (ili će se tijekom rada srušiti). Prostor radne memorije je relativno mali (u usporedbi sa npr. tipičnim veličinama tvrdih diskova), te je nedostatak radne memorije moguće očekivati u programima koji barataju sa većim brojem podataka. Ova dva problema, mogu se riješiti upotrebom datoteka. Glavna svrha datoteka je trajno "pamćenje" podataka. Program sprema podatke koji se moraju trajno pamtiti u datoteku, te ih može pri ponovnom pokretanju učitati.

OSNOVE RADA S DATOTEKAMA

Svaki korisnik računala već se susreo sa datotekama. Datoteke su organizirane po mapama (folderi, direktoriji), na različitim diskovima. Datoteku jedinstveno određuje njen naziv. U jednom folderu se ne mogu nalaziti dvije datoteke sa istim nazivom.

Kao što je već spomenuto, datoteke se primarno koriste za trajno pamćenje podataka. Osnovne operacije koje se obavljaju pomoću datoteka su spremanje i učitavanje podataka. Spremanje podataka je postupak pri kojem program podatke iz svojih varijabli (tj. iz radne memorije) zapisuje u datoteku. Stoga se spremanje podataka još zove i zapisivanje podataka. Pri učitavanju (tj. čitanju) podataka, program podatke prebacuje iz datoteke u svoje varijable. Kaže se da program učitava (ili čita) iz datoteke.

Važno je napomenuti da se načelni princip rada ostatka programa ne mijenja. Osnovne operacije (kao što su aritmetičke operacije, operacije usporedbe, ispis na zaslon i sl.) program može obavljati samo pomoću varijabli.

Sada se mogu navesti osnovni koraci pri upotrebi datoteka:

1. Pri radu sa datotekom, datoteku je potrebno otvoriti. Otvaranje datoteke, znači pridruživanje neke konkretne datoteke (koja je određena svojim imenom i mapom u kojoj se nalazi), sa odgovarajućim objektom. Sve ostale operacije se obavljaju preko tog objekta.

2. Nakon uspješnog otvaranja datoteke, slijedi obavljanje operacija nad njom. Program zapisuje podatke iz memorije u datoteku ili učitava podatke iz datoteke u memoriju. Pri zapisivanju i učitavanju, ostavljena je velika sloboda na koji način se to izvodi. Drugim riječima, programer sam odlučuje koje će podatke program zapisivati (ili učitavati). Posebno, pri učitavanju, nije nužno učitati cjelokupni sadržaj datoteke u radnu memoriju (tj. u varijable programa).

3. Nakon što su svi podaci zapisani ili učitani potrebno je datoteku zatvoriti.

Ovo su bili osnovni koraci pri upotrebi datoteka. Datoteke se mogu upotrebljavati na razne načine, ali osnovni princip rada ostaje isti: otvaranje datoteke, zapisivanje ili učitavanje podataka, zatvaranje datoteke. Datoteka služi samo kao trajno "skladište" podataka. Da bi program izveo bilo koje operacije nad podacima koji se nalaze u datoteci, on mora prethodno te podatke učitati u varijable u radnu memoriju.

OTVARANJE DATOTEKE

Kao što je već spomenuto, otvaranje datoteke je pridruživanje konkretne datoteke objektu određene klase. Sve ostale operacije nad datotekom se obavljaju preko te datoteke. Klasa čiji se objekt pridružuje datoteci ovisi o tome za što će se datoteka upotrebljavati. Razlikujemo dva slučaja: otvaranje datoteke za pisanje (tzv. izlazne datoteke) te otvaranje datoteke za čitanje (tzv. ulazne datoteke). Datoteku otvaramo za pisanje kada želimo u nju nešto zapisati. Slično, datoteka se otvara za čitanje ako želimo iz nje nešto pročitati. Bez obzira na način upotrebe, ukoliko želimo koristiti datoteke u programu, potrebno je navesti slijedeću liniju na početak programa:

#include <fstream.h>

DATOTEKE ZA PISANJE (IZLAZNE DATOTEKE)

Objekt koji se povezuje sa datotekama za pisanje je klase ofstream. Konstruktor klase ofstream prima jedan argument - naziv datoteke koja se otvara za pisanje. Slijedeća naredba:

ofstream fout("IZLAZ.TXT");

povezuje datoteku IZLAZ.TXT sa objektom fout. Ovime je zapravo datoteka IZLAZ.TXT otvorena za pisanje. Nakon ovoga je moguće u tu datoteku zapisati podatke iz varijabli programa koristeći se objektom fout. Pri otvaranju datoteke za zapisivanje događa se slijedeće:

1. Datoteka se stvara u mapi u kojoj se nalazi i program. Ukoliko datoteka sa takvim imenom ne postoji, stvoriti će se nova datoteka. Ukoliko već postoji datoteka sa takvim imenom, njen sadržaj će se izbrisati. Nakon otvaranja za pisanje, datoteka je prazna.

2. Upotrebom pripadnog objekta, moguće je pisati u datoteku, ali ne i čitati podatke iz nje.

DATOTEKE ZA ČITANJE (ULAZNE DATOTEKE)

Način otvaranja datoteke za čitanje je sličan prethodnom načinu. Osnovna razlika je u tome što se upotrebljava klasa ifstream:

ifstream fin("ULAZ.TXT")

Ovom naredbom je datoteka IZLAZ.TXT otvorena za čitanje i povezana sa objektom fin. Pri otvaranju datoteke za čitanje, vrijede malo drugačija pravila:

1. Otvara se datoteka koja ima zadani naziv i nalazi se u mapi u kojoj se nalazi i program. Ukoliko datoteka sa zadanim nazivom ne postoji, datoteka se neće otvoriti.

2. Upotrebom pripadnog objekta moguće je čitati podatke iz datoteke, ali ne i zapisivati podatke u nju.

ZATVARANJE DATOTEKE

Datoteka se zatvara pozivom metode close objekta koji je povezan sa datotekom. Metoda ne prima argumente. Npr. prethodno otvorene datoteke moguće je zatvoriti na slijedeći način:

fin.close();fout.close();

Nakon obavljanja potrebnih operacija nad datotekama (čitanje ili pisanje), datoteke je uvijek potrebno zatvoriti.

PROVJERA JE LI DATOTEKA USPJEŠNO OTVORENA

Moguće su situacije kada nakon gornjih naredbi datoteka neće biti uspješno otvorena. Pri otvaranju datoteke za čitanje, to se može dogoditi ukoliko datoteka sa takvim nazivom ne postoji. Pri otvaranju datoteke za pisanje mogući razlozi su pokušaj stvaranja datoteke na zaštićenom disku (ili u zaštićenoj mapi), pokušaj stvaranja datoteke na disku na kojem nema slobodnog prostora itd. Vrlo je važno provjeriti prije same upotrebe datoteke je li ona uspješno otvorena. To se može napraviti na slijedeći način:

ifstream fin("ULAZ.TXT");

if (!fin) // greška pri otvaranju?cout << "Datoteka nije otvorena!!\n";

else{

// ovdje se obavljaju operacije nad datotekom// upotrebom objekta fin

// datoteka se zatvara samo ako je uspješno otvorenafin.close();

}

Važno je uočiti da se unutar uvjeta if naredbe nalazi samo !fin, pri čemu je fin naziv objekta koji je pridružen datoteci ULAZ.TXT. Ovo je moguće zato što klasa ifstream (isto vrijedi i za klasu ofstream) ima ugrađen operator konverzije u cijeli broj. Taj operator se brine da vrati vrijednost takvu da ovako napisan if uvjet bude ispunjen samo ako datoteka nije uspješno otvorena. Provjera se obavlja na isti način za izlazne datoteke.

OBAVLJANJE OSNOVNIH OPERACIJA NAD DATOTEKAMA

Kao što je već ranije spomenuto, osnovne operacije (praktički i jedine) koje se mogu izvoditi nad datotekama su čitanje i pisanje. U nastavku će biti opisano izvođenje tih operacija.

JEDNOSTAVNO PISANJE U DATOTEKU

Kada program zapisuje u datoteku, on u stvari zapisuje podatke iz svoje memorije. Zapisivanje podataka u datoteku je vrlo slično zapisivanju podataka na zaslon. Jedina razlika je što se umjesto cout objekta upotrebljava objekt tipa ofstream koji je pridružen izlaznoj datoteci. Slijedeći primjer zapisuje sadržaj cjelobrojne varijable u datoteku BROJ.TXT


main(){ cout << "Unesite broj: ";

int x; cin >> x;

ofstream fout("BROJ.TXT");

if (!fout) cout << "Datoteka nije uspjesno otvorena!\n";

else {

fout << x << endl; // pisanje u datoteku

fout.close(); }

return 0;}

Sadržaj datoteke je moguće provjeriti pomoću bilo kojeg tekstualnog editora (npr. Notepad).

Upotrebom operatora << nad objektom koji je pridružen datoteci, moguće je pisati u datoteku na identičan način kao što se zapisuje na zaslon. Čak će i sam sadržaj "izgledati" kao što bi izgledao da se na isti način zapisivao na zaslon.

Važno je napomenuti da se ovakvo zapisivanje može obaviti samo pomoću objekta tipa ofstream (tip za izlazne datoteke). Sam objekt može imati bilo koji naziv (naravno, potrebno je poštivati pravila o nazivu varijabli u jeziku C++). Posebno je zgodno nazvati objekt fout zbog očite sličnosti sa objektom cout.

JEDNOSTAVNO ČITANJE IZ DATOTEKE

Da bi program mogao manipulirati sa podacima u datoteci, on ih mora prethodno pročitati iz datoteke u svoje varijable. Kao i kod pisanja, čitanje iz datoteke je slično učitavanju podataka sa tipkovnice. Jedina razlika je što se upotrebljava objekt tipa ifstream. Slijedeći program čita broj koji je prethodni program zapisao u datoteku BROJ.TXT.


main(){ ifstream fin("BROJ.TXT"); int x;

if (!fin)cout << "Datoteka ne postoji!\n";

else {

fin >> x; // učitavanje iz datoteke u varijablu

fin.close(); // datoteka se može zatvoriti jer smo // pročitali sve što smo htjeli

cout << "Pročitan je broj: " << x << endl; }

return 0;}

Ovakvo učitavanje moguće je jedino sa objektima tipa ifstream. Kod ovakvih datoteka je zbog sličnosti sa cin objektom zgodno odgovarajući objekt nazvati fin. Važno je uočiti da u ovom programu korisnik ništa ne unosi: podatak se čita iz datoteke!

Rad prethodna dva programa možete provjeriti tako da prvo pokrenete program koji zapisuje u datoteku, a zatim program koji učitava iz (te iste) datoteke.

UPOTREBA DATOTEKA U KONKRETNIM PROGRAMIMA

Prethodna dva programa ilustriraju najjednostavniju moguću upotrebu datoteka. Međutim, podrška datotekama u složenijim programima ne zahtijeva puno više posla. Osnovna ideja je sažeta u ova dva programa. Već je ranije spomenuto da se datoteke koriste kada program mora trajno "zapamtiti" podatke koje drži u svojim varijablama. Tipično se u programima ova mogućnost podržava kroz opciju Save (tj. pohranjivanje, spremanje podataka na disk) te opciju Load (tj. učitavanje podataka sa diska). Tipični postupak koji je potrebno napraviti pri izvođenju Save operacije je spremiti sve bitne podatke (recimo sve elemente jednog polja) u datoteku. Pri izvođenju operacije Load potrebno je sve podatke iz datoteke prebaciti u odgovarajuće polje. Pri tome je važno obratiti pažnju na način na koji se podaci pohranjuju. Naime, podaci se moraju učitati na isti onaj način na koji su i pohranjeni. U nastavku će biti prikazani najjednostavniji načini pohranjivanja elemenata jednog polja:

POSEBNO ZAPISIVANJE BROJA ELEMENATA POLJA

Ranije je spomenute da je pri izvođenju operacije učitavanja potrebno pročitati cjelokupni sadržaj datoteke u odgovarajuće polje. Postavlja se pitanje kako će program znati koliko točno podataka ima u datoteci. Ovaj problem se može jednostavno riješiti tako da se prije zapisivanja samih elemenata polja zapiše broj elemenata. Slijedeći primjer prikazuje kako se može na taj način zapisati polje. Pretpostavimo da postoje slijedeće globalne varijable:

float ocjene[MAX];int nocjena;

Također se pretpostavlja da je u main funkciji već napisan dio koda koji popunjava to polje (ugrađene su opcije dodaj, promijeni i sl.). Slijedi funkcija koja sprema sadržaj u datoteku OCJENE.TXT:

void spremi(){ ofstream fout("OCJENE.TXT");

if (!fout)cout << "Ne mogu otvoriti datoteku!\n";

else {

fout << nocjena << endl; // zapisivanje broja elemenata

// zapisivanje svakog elementafor (int i = 0;i < nocjena;i++) fout << ocjene[i] << endl;

fout.close(); }}

Pretpostavimo da je funkcija spremi pozvana u trenutku kada se u polju nalaze tri ocjene: 1,2 i 3. Izgled datoteke OCJENE.TXT bi bio slijedeći:

3123

Prvo se nalazi broj 3 (čime se označava da slijede tri broja). Nakon toga slijede sami elementi polja (tj. ocjene 1, 2 i 3).

Uočite da nije slučajno pređeno u novi red svaki put nakon što se zapiše neki podatak. Kada ne bi bilo tako izgled datoteke za prethodni primjer bi bio:

3123

Program bi pri učitavanju pogrešno pročitao ovakav podatak kao 3123 (umjesto 3, 1, 2, 3).

Učitavanje ovakve datoteke je sada lagano obaviti. Prvo je potrebno učitati broj ocjena n, te zatim n ocjena:

void ucitaj(){ ifstream fin("OCJENE.TXT");

if (!fin)cout << "Ne mogu otvoriti datoteku!\n";

else {

fin >> nocjena;

// ucitavanje n elemenatafor (int i = 0;i < nocjena;i++) fin >> ocjene[i];

fin.close(); }}

Prilikom rada sa datotekama (posebno prilikom čitanja), potrebno je znati da postoji nešto što se zove trenutna pozicija. Prilikom čitanja, trenutna pozicija (u datoteci) je zapravo mjesto otkuda će slijedeća naredba čitanja krenuti sa čitanjem podatka. Podatak se čita sve dok se ne dođe do znaka razmaka, tabulatora ili prelaska u novi red. Pri otvaranju datoteke, trenutna pozicija je na samom početku datoteke. Nakon svakog čitanja, ona se pomiče prema kraju datoteke. Zahvaljujući tome, funkcija spremi radi točno onako kako bi i trebala. Nakon što se pročita broj nocjena, trenutna pozicija u datoteci se pomiče na slijedeći podatak (tj. prvu ocjenu), nakon toga na drugi podatak itd.

Nakon ovakvog učitavanja, prethodni sadržaj polja je izgubljen tj. podaci iz radne memorije su zamijenjeni podacima iz datoteke. Naravno, da bi ovakvo učitavanje radilo datoteka OCJENE.TXT mora postojati, a njen sadržaj mora biti zapisan na način na koji radi funkcija spremi. Još jednom je važno istaknuti da programer sam određuje na koji način će podaci biti zapisani pri čemu mora voditi računa o tome da na taj način i učitava podatke iz datoteke. Posebno je važno pri spremanju podataka paziti da se iza svakog podatka zapiše jedan od znakova koji označavaju kraj podatka (novi red, razmak ili tabulator tj. "\n", " " ili "\t").

ZAPISIVANJE POLJA BEZ ZAPISIVANJA BROJA ELEMENATA

Pokušaj učitavanja iza kraja datoteke (tj. nakon što su pročitani svi podaci) je moguć. Takav pokušaj će učitati podata ("učitani" podatak će naravno biti neispravan jer se ne nalazi u datoteci) i program "neće shvatiti" da nešto nije u redu. Za provjeru je li učitani podatak zaista u datoteci, može se upotrijebiti metoda eof koja se nalazi u klasi ifstream. Metoda eof vraća vrijednost različitu od nule (tj. logička istina u jezicima C i C++) ukoliko je pokušano čitanje iza kraja datoteke. Inače je povratna vrijednost jednaka nuli. Upotrebom te metode, moguće je prepraviti način zapisivanja podataka u datoteku. Sada više nije potrebno zapisivati broj elemenata polja, već je dovoljno zapisati samo elemente. Funkcija koja učitava će čitati jedan po jedan podatak sve dok ne dođe do kraja datoteke (provjeru će obaviti pozivom metode eof). Slijede funkcije koje na ovaj način zapisuju i učitavaju polje ocjena:

void spremi(){ ofstream fout("OCJENE.TXT");


else {

// zapisivanje svakog elementafor (int i = 0;i < nocjena;i++) fout << ocjene[i] << endl;

fout.close(); }}

void ucitaj(){ ifstream fin("OCJENE.TXT");


else {

nocjena = 0; // početni broj ocjena

// ucitavanje svih elemenata u datoteciwhile(1){ fin >> ocjene[nocjena];

// je li pokušano čitanje iza kraja datoteke? if (fin.eof()!= 0) break; // ako je prekini učitavanje else nocjena++;}

fin.close(); }}

Funkcija spremi je doživjela minimalne promjene - izbačeno je zapisivanje broja elemenata (ocjena). Nova verzija funkcije ucitaj je gotovo u cijelosti prepravljena. Prvo, više se ne može učitati broj koji označava koliko podataka slijedi iza njega (jer taj broj jednostavno više nije zapisan). Stoga funkcija ucitaj početno postavlja varijablu nocjena na nula. Za svaki uspješno učitani podatak, ona će povećati iznos u toj varijabli za jedan. Učitavanje se vrši u beskonačnoj petlji. Nakon svakog učitanog podatka se provjerava je li učitani podatak ispravan. Ukoliko nije (tj. ukoliko je pokušano čitanje iza kraja datoteke), slijedi izlazak iz petlje. Ovo možda na prvi pogled izgleda neispravno, ali zaista radi. Naime, kada se prvi put obavlja učitavanje iza kraja datoteke, neispravan podatak će biti spremljen u polje. Međutim, taj podatak postaje "stvarni" element polja tek u onom trenutku kada se izvede naredba nocjena++. Ako nije učitan ispravan podatak, tada se ta naredba neće izvesti i podatak kao da nije element polja (jer ga niti jedna petlja koja prolazi po svim elementima polja neće uzeti u obzir).

Nova verzija učitavanja će ispravno učitati podatke iz datoteke samo onda kada su oni zapisani na način kako je to napravljeno u novoj verziji funkcije spremi.

SPREMANJE I UČITAVANJE OBJEKATA

Spremanje i učitavanje upotrebom operatora << i >> radi za jednostavne tipove podataka (int, float, stringovi, ...). Ukoliko želimo spremiti ili učitati cijeli objekt tada je potrebno svaki član objekta zapisati ili učitati posebno. Slijedeći primjer ilustrira spremanje i učitavanje jednog objekta. Pretpostavimo da je deklariran slijedeći objekt:

class Radnik{ private:

float placa;char ime[20], prezime[20];

public:float get_placa() const;void set_placa(float n_placa);

const char *get_ime() const;void set_ime(const char *n_ime);

const char *get_prezime() const;void set_prezime(const char *n_prezime);

};

Također se pretpostavlja da su deklarirane metode i napisane. Slijede funkcije koje zapisuju i učitavaju objekt klase Radnik:

void spremi(Radnik rad){ ofstream fout("RADNIK.TXT");


else {

fout << rad.get_placa() << " ";fout << rad.get_ime() << " ";fout << rad.get_prezime() << endl;

fout.close(); }}

void ucitaj(Radnik &rad){ ifstream fin("RADNIK.TXT");


else {

char ime[20],prezime[20];float placa;

fin >> placa;fin >> ime;fin >> prezime;

fin.close();

rad.set_placa(placa);rad.set_ime(ime);rad.set_prezime(prezime);

}}

Funkcija spremi zapisuje podatke u datoteku član po član. Pri tome se iza prva dva člana zapisuje znak razmaka, a iza trećeg znak za prelazak u novi red. Ovo je napravljeno iz čisto "estetskih" razloga (radi lakšeg čitanja datoteke u tekstualnom editoru). Ne bi bilo razlike (za funkciju ucitaj) kada bi se iza svakog podatka (tj. člana) zapisao prelazak u novi red.

Funkcija ucitaj mora imati tri privremene lokalne varijable u koje će učitati podatke iz datoteke. Nakon toga se pozivom pripadnih set metoda, podaci premještaju u objekt. Ovdje je argument funkcije deklariran kao referenca, kako bi se promjena u objektu (tj. smještanje učitanih podataka u objekt) "vidjele" i u pozivnoj funkciji.

SPREMANJE I UČITAVANJE POLJA OBJEKATA

Sada je vrlo jednostavno napraviti i spremanje čitavog polja objekata. Funkcije će raditi sa poljem objekata ranije deklarirane klase Radnik. Pretpostavlja se da su deklarirane globalne varijable:

Radnik radnici[MAX];int nradnik;

Također se pretpostavlja da su već ugrađene standardne opcije za rad sa poljima (dodaj, briši, izmjeni, ... ). Slijede funkcije za spremanje i učitavanje polja radnika:

void spremi(){ ofstream fout("RADNICI.TXT");


else {

// zapisivanje svakog objektafor (int i = 0;i < nradnik;i++){ fout << radnici[i].get_placa() << " "; fout << radnici[i].get_ime() << " "; fout << radnici[i].get_prezime() << endl;}

fout.close(); }}

void ucitaj(){ ifstream fin("RADNICI.TXT");


else {

nradnik = 0; // početni broj radnika

// učitavanje svih elemenata iz datotekewhile(1){ char ime[20],prezime[20]; float placa;

fin >> placa; fin >> ime; fin >> prezime;

// je li pokušano čitanje iza kraja datoteke? if (fin.eof()!= 0)

break; // ako je prekini učitavanje else // inače popuni objekt i ažuriraj broj radnika {

radnici[nocjena].set_placa(placa);radnici[nocjena]set_ime(ime);radnici[nocjena]set_prezime(prezime);

nradnik++; }}

fin.close(); }}

DODAVANJE NA KRAJ DATOTEKE

Dosadašnji programi koji su zapisivali podatke u datoteku su prilikom pisanja uvijek prebrisali prethodni sadržaj datoteke. Podsjetimo se, prilikom otvaranja datoteke za pisanje, prethodni sadržaj datoteke se automatski prebriše. Prilikom otvaranja datoteke za pisanje, moguće je posebno navesti da se prethodni sadržaj datoteke ne prebriše. Ovo se radi na slijedeći način:

ofstream fout("IZLAZ.TXT",ios::app);

Konstruktoru objekta se šalje još jedan argument (ios::app), čime se određuje da prethodni sadržaj datoteke neće biti obrisan. Kaže se da se datoteka otvara u tzv. append (dodaj) modu. Pri tome vrijede slijedeća pravila:

1. Ukoliko datoteka sa navedenim imenom ne postoji, stvoriti će se nova datoteka.

2. Ukoliko datoteka sa navedenim imenom postoji, otvoriti će se postojeća datoteka.

3. Moguće je obavljati samo pisanje u datoteku. Svako zapisivanje će se obaviti na kraju datoteke (iza svih podataka koji su do tog trenutka zapisani).

BINARNE DATOTEKE

Dosada opisane datoteke su tzv. tekstualne datoteke. Najčešće se koriste kada je u njih potrebno zapisati podatke na način razumljiv čovjeku. Nedostatak je u tome što veličina zapisanog podatka ovisi o samom podatku koji se zapisuje. Pretpostavimo da se u neku tekstualnu datoteku zapisuju samo cijeli brojevi. Recimo da su zapisana 3 broja: 5, 10 i 123. Izgled datoteke je slijedeći:

510123

Očito je da veličina jednog zapisa (broja) ovisi o samom podatku. Ovo se može pokazati kao veliki nedostatak. Recimo da se u datoteci nalazi puno brojeva i mi prilikom čitanja želimo pročitati samo jedan, točno određen broj (npr. 100. po redu u datoteci). Nas dakle zanima samo 100. broj u datoteci. Da bi smo pročitali taj podatak, moramo prvo pročitati prethodnih 99 brojeva, što je ilustrirano u slijedećoj funkciji:

int procitaj_100() // funkcija koja čita 100. broj iz datoteke{ ifstream fin("BROJ.TXT");

if (!fin) // ako je pogreškareturn -1;

else {

int x;

for (int i = 0;i < 100;i++) fin >> x;

return x; }}

Ovo često može predstavljati problem. Ukoliko program u datoteci čuva veću količinu podataka, ovo rješenje se pokazuje sporim. Zbog ovakvog načina pristupa, tekstualne datoteke se često nazivaju slijedne ili sekvencijalne datoteke.

Ovaj nedostatak je moguće riješiti upotrebom tzv. binarnih datoteka. U binarnu datoteku, podatak se doslovno zapisuje onako kako ga računalo "vidi" u radnoj memoriji. Npr. tip unsigned short int zauzima u memoriji dva byte-a. Prilikom zapisivanja jednog broja tipa unsigned short int, zapisati će se uvijek točno dva byte-a. Drugim riječima, veličina podatka u datoteci ovisi o tipu tog podatka, a ne o njegovom sadržaju. Sadržaj binarne datoteke više nije razumljiv čovjeku (tj. ne može se provjeriti pomoću tekstualnog editora), a podaci su unutra zapisani točno onako kako "izgledaju" u radnoj memoriji.

JEDNOSTAVNO ZAPISIVANJE U BINARNU DATOTEKU

Slijedeći program ilustrira osnovni način kako se može zapisati jedan podatak u binarnu datoteku:

main(){ ofstream fout("BROJ.DAT",ios::binary + ios::out);


else {

int x = 256;

// zapiši podatak koji je u varijabli xfout.write((const char *) &x,sizeof(int));

fout.close(); }

return 0;}

Načelni princip rada ostaje isti: otvaranje, operacije nad datotekom, zatvaranje. Prva razlika je pri samom otvaranju. Potrebno je poslati dodatni argument konstruktoru čime se navodi da se datoteka otvara kao binarna i to za pisanje (ios::binary + ios::out). Uočite da se zastavica ios::out može proslijediti kao argument samo ako je riječ o ofstream klasi.

Osnovna razlika je ipak u samom zapisivanju. Naime, kod binarnih datoteka zapisivanje se obavlja pomoću metode write. Prvi argument je adresa podatka (tj. varijable) koja se zapisuje. U našem primjeru adresa podatka je naravno &x. Prije same adrese se uvijek navodi operator konverzije (const char *). Drugi argument je veličina podatka u byte-ovima. Taj podatak se može dobiti pomoću operatora sizeof. Naime, sizeof prima kao argument tip podatka, a vraća veličinu tog tipa u byte-ovima tj. koliko varijabla tog tipa zauzima byte-ova u memoriji.

Ovdje je važno primjetiti da prvi argument uvijek mora biti adresa varijable. Ukoliko želimo zapisati neki točno određen broj, moramo ga prvo zapisati u privremenu varijablu, a zatim tu varijablu zapisati u datoteku (gornji program radi točno tako).

Osnovna pravila ostaju ista: ukoliko datoteka s tim nazivom ne postoji, stvoriti će se nova datoteka, u suprotnom, sadržaj postojoće datoteke će biti prebrisan.

JEDNOSTAVNO ČITANJE IZ BINARNE DATOTEKE

Čitanje iz binarne datoteke je slično pisanju u binarnu datoteku:

main(){ ifstream fin("BROJ.DAT",ios::binary + ios::in);

if (!fin) cout << "Ne mogu otvoriti datoteku!"; else { int x;

fin.read((char *) &x,sizeof(int)); fin.close();

cout << x << endl; }

return 0;}

Prva razlika (u odnosu na pisanje u binarnu datoteku) je što se konstruktoru proslijeđuje ios::binary + ios::in (umjesto ios::binary + ios::out). Naravno, zato što je riječ o čitanju, ovdje se koristi klasa ifstream (umjesto klase ofstream). Samo čitanje je vrlo slično pisanju, uz tu razliku što se koristi metoda read. Sintaksa je ista. Prvi argument je adresa varijable u koju će se pročitani podatak smjestiti. Prije same adrese također slijedi operator konverzije. Drugi argument je veličina podatka u byte-ovima.

Rad prethodna dva programa možete provjeriti tako da prvo pokrenete program koji piše u datoteku, a zatim program koji čita iz datoteke.

ZAPISIVANJE POLJA U BINARNU DATOTEKU

Način zapisivanja polja se jednostavno dobije iz prethodnih programa. Potrebno je u petlji zapisivati jedan po jedan element polja. Slijedeći primjer pretpostavlja da su deklarirane globalne varijable:

float ocjene[MAX];int nocjena;

Također se pretpostavlja da je u main funkciji već napisan dio koda koji popunjava to polje (ugrađene su opcije dodaj, promijeni i sl.). Funkcija koja obavlja zapisivanje ima slijedeći oblik:

void pisi(){ ofstream fout("OCJENE.DAT",ios::binary + ios::out);

if (!fout) cout << "Ne mogu otvoriti datoteku!\n"; else { for (int i = 0;i < nocjena;i++) fout.write((const char *) &ocjene[i], sizeof(float));

fout.close(); }}

Važno je uočiti prilikom pisanja, da se šalje adresa i-tog elementa polja (&ocjene[i]). Drugi argument je sizeof(float) jer su elementi polja tipa float.

ČITANJE POLJA IZ BINARNE DATOTEKE

Na sličan način se može napraviti i čitanje polja iz binarne datoteke. Potrebno je u petlji čitati podatak po podatak sve dok se ne dođe do kraja datoteke. Metoda eof radi isto kao i kod tekstualnih datoteka:

void citaj(){ ifstream fin("OCJENE.DAT",ios::binary + ios::in);

if (!fin) cout << "Ne mogu otvoriti datoteku!"; else { nocjena = 0;

while(1) { fin.read((char *) &ocjene[nocjena],sizeof(float));

if (fin.eof() != 0) break; else nocjena++;

} fin.close();

}}

Princip je očito isti kao i kod čitanja polja iz tekstualne datoteke. Čita se jedan po jedan podatak, pri čemu se nakon svakog podatka provjerava je li ispravno pročitan (tj. jesmo li došli do kraja datoteke).

PISANJE I ČITANJE OBJEKATA U BINARNE DATOTEKE

Pisanje i čitanje objekata u binarne datoteke je puno jednostavnije u odnosu na tekstualne datoteke. Budući da metode za pisanje i čitanje traže adresu elementa i njegovu veličinu u byte-ovima, objekt se doslovno može zapisati (ili pročitati) jednim pozivom metode write (ili read). U prethodnoj funkciji za pisanje, dovoljno je napraviti slijedeću promjenu da bi se mogao zapisati objekt klase Radnik:

for (int i = 0;i < nradnik;i++) fout.write((const char *) &radnici[i], sizeof(Radnik));

Uočite da je prvi argument adresa objekta klase Radnik, dok je drugi argument veličina jednog objekta te klase.

Slično se može obaviti i čitanje polja objekata klase Radnik iz ovako zapisane datoteke:

nradnik = 0;

while(1){ fin.read((char *) &radnici[nracnik],sizeof(Radnik));

if (fin.eof() != 0) break; else nradnik++;

}

Važno je napomenuti da je ovakvo pisanje i čitanje objekta moguće samo ako objekti ne sadrže pokazivačke članove ili reference.

DIREKTAN PRISTUP PODACIMA

Sada se možemo pozabaviti ključnom prednosti binarnih datoteka. Već je ranije spomenuto da je nedostatak tekstualnih datoteka u tome što ne omogućava direktan pristup podatku. U binarnim datotekama je to moguće jer su svi podaci jednake veličine. Npr. ukoliko u datoteku upisujemo objekte klase Radnik, tada je svaki podataka veličine sizeof(Radnik). Drugim riječima moguće je odrediti za određeni podatak koliko byte-ova je u datoteci zapisano prije njega. Npr. prije 100. objekta klase Radnik je u datoteku zapisano 99 objekata što je zapravo 99 * sizeof(Radnik) byteova. Općenito se može reći da je prije i-tog podatka zapisano (i - 1) * sizeof(tip) byteova. Pri tome tip označava tip podatka koji se zapisuje u datoteku. Ovdje je pretpostavljeno brojanje od jedan (podatak na početku datoteke je 1. element a ne 0.). Zahvaljujući tom strogo matematičkom odnosu, moguće je lako direktno pristupiti točno određenom podatku.

SEEKG METODA

Ovom metodom moguće je promijeniti trenutnu poziciju datoteke. Podsjetimo se, trenutna pozicija je ona pozicija otkuda će krenuti slijedeća naredba čitanja. Metoda prima jedan argument - novu poziciju (broj byte-ova od početka datoteke). Slijedeća funkcija učitava 100. objekt iz datoteke RADNICI.DAT u koju su zapisani objekti klase Radnik:

void citaj_100(){ ifstream fin("RADNICI.DAT",ios::binary + ios::in);

if (!fin) cout << "Ne mogu otvoriti datoteku!"; else { Radnik x;

// pozicioniraj se na 99. objekt fin.seekg(99 * sizeof(Radnik));

fin.read((char *) &x,sizeof(Radnik)); fin.close(); // sada je moguće ispisati članove objekta }}

Uočite kako se do 100. objekta dolazi u dvije naredbe. Prva naredba je "skok" na 100. poziciju, nakon čega slijedi učitavanje samo jednog (100.) objekta.

ODREĐIVANJE VELIČINE DATOTEKE

Što se događa ukoliko pokušamo postaviti trenutnu poziciju iza kraja datoteke? Pozicija se neće promijeniti, ali nećemo dobiti dojavu o pogrešci. Ovo je moguće zaobići ako se uvede kontrola pozicije. Prije same promjene pozicije, potrebno je vidjeti je li nova pozicija ispravna (tj. nalazi li se nova pozicija u datoteci). Npr. za datoteku RADNICI.DAT možemo odrediti koliko objekata je zapisano u njoj, te paziti da nikad ne mijenjamo poziciju iza zadnjeg objekta. Da bi odredili broj objekata u datoteci, moramo odrediti veličinu datoteke te taj broj podijeliti sa veličinom jednog podatka (tj. sa veličinom jednog objekta).

Veličina datoteke se određuje u dva koraka. Prvo, potrebno je postaviti trenutnu poziciju na sam kraj datoteke, što se radi posebnim pozivom metode seekg:

fin.seekg(0,ios::end);

Nakon ove naredbe, trenutna pozicija je na samom kraju datoteke. Sada se može pozvati tellg metoda. Ta metoda vraća trenutnu poziciju (broj byte-ova od početka datoteke):

long velicina = fin.tellg();

Ovime smo dobili veličinu datoteke u byte-ovima. Još je jedino potrebno izračunati koliko je objekata zapisano u datoteci:

long nradnik = velicina / sizeof(Radnik);

Naravno, ovaj primjer radi za datoteku u kojoj su smješteni objekti klase Radnik. Slijedi cjelovita funkcija koja računa koliko je objekata klase Radnik smješteno u datoteku:

long br_radnika(){ ifstream fin("RADNICI.DAT",ios::binary + ios::in);

if (!fin) // ako je pogreška return -1; else { fin.seekg(0,ios::end); long rez = fin.tellg() / sizeof(Radnik); fin.close();

return rez; }}

ČUVANJE PODATAKA UZ MINIMALNI UTROŠAK RADNE MEMORIJE

Upotrebom binarnih datoteka, posebno tehnike direktnog pristupa, moguće je smanjiti utrošak radne memorije. Pretpostavimo da radimo program za evidenciju zaposlenih u nekoj firmi. Ukoliko je riječ o velikoj firmi, broj radnika može biti prilično velik te je moguće da jednostavno nemamo dovoljno prostora u radnoj memoriji za tako veliko polje (podsjetimo se da je prostor radne memorije relativno mali). Moguće rješenje je upotreba datoteke za čuvanje svih podataka. Svi objekti (u ovom slučaju radnici) se nalaze u datoteci, a u radnoj memoriji čuvamo samo podatke o radniku čije podatke trenutno obrađujemo (npr. pri ispisu, promjeni ili sl.). U slijedećim koracima će biti objašnjeno kako se može realizirati ovakav program.

ORGANIZACIJA PODATAKA

Podaci će biti organizirani u objektima klase Radnik. Svi podaci će biti pohranjeni u datoteci RADNICI.DAT, a u radnoj memoriji će se uvijek nalaziti najviše jedan objekt (onaj koji se trenutno obrađuje). Slijedi deklaracija klase radnik:

class Radnik{ private: float placa; char ime[20], prezime[20]; public: float get_placa() const {return placa;}; void set_placa(float n_pl) {placa = n_pl;};

const char *get_ime() const {return ime;}; void set_ime(const char *n_ime) {strcpy(ime,n_ime);}; const char *get_prezime() const {return prezime;}; void set_prezime(const char *n_prez)

{strcpy(prezime,n_prez);};

void Ispisi() // metoda koja ispisuje podatke na zaslon { cout << ime << " " << prezime << " " << placa << endl;

};};

Ovo je pojednostavljeni oblik klase radnik. Pri tome je u klasu radi jednostavnosti ugrađena metoda ispisi koja na zaslon ispisuje sve podatkovne članove.

DODAVANJE NOVOG ELEMENTA

Dodavanje novog člana je vrlo jednostavno za realizirati. Potrebno je prvo učitati podatke sa tipkovnice te popuniti jedan objekt klase Radnik. Nakon toga taj objekt je potrebno dodati na kraj datoteke. Zadnji korak se vrlo jednostavno može napraviti ukoliko se datoteka otvori za dodavanje. Sjetimo se, pri otvaranju datoteke za dodavanje, ukoliko ta datoteka ne postoji, stvoriti će se nova datoteka. Ukoliko ta datoteka već postoji, njen sadržaj će ostati očuvan, a svaki novi upis u datoteku će biti dodan na kraj datoteke:

void dodaj_novi(){ char ime[20],prezime[20]; float pl;

cout << "\n\n\n";

cout << "Ime: "; cin >> ime; cout << "Prezime: "; cin >> prezime; cout << "Placa: "; cin >> pl;

Radnik pom;

pom.set_placa(pl); pom.set_ime(ime); pom.set_prezime(prezime);

// otvori datoteku za dodavanje ofstream fout("RADNICI.DAT",ios::binary + ios::out + ios::app);

if (!fout) cout << "Greska! Ne mogu otvoriti datoteku!\n"; else { // zapisi novi objekt na kraj datoteke fout.write((const char *) &pom, sizeof(Radnik));

fout.close();

cout << "Radnik je uspjesno dodan!\n"; }}

Prilikom otvaranja, drugi argument je ios::binary + ios::out + ios::app. Ovo se čita na slijedeći način: otvori datoteku za pisanje kao binarnu, novi podaci će se dodati na kraj datoteke (klasa naravno mora biti ofstream).

ISPIS SVIH ELEMENATA U DATOTECI

Ovo je već ranije obrađeno. Dovoljno je čitati jedan po jedan objekt iz datoteke sve dok se ne dođe do samog kraja:

void ispisi_sve(){ cout << "\n\n\n"; ifstream fin("RADNICI.DAT", ios::binary + ios::in);

if (!fin) cout << "Greska! Ne mogu otvoriti datoteku!\n"; else { while(1) { Radnik pom;

fin.read((char *) &pom, sizeof(Radnik));

if (fin.eof() != 0) break; else pom.Ispisi(); } fin.close(); }}

RAČUNANJE BROJA OBJEKATA U DATOTECI

Broj objekata u datoteci se računa prema ranije objašnjenom principu. Prvo je potrebno "skočiti" na kraj datoteke, pročitati trenutnu poziciju (tj. veličinu datoteke u byte-ovima) te podijeliti sa veličinom jednog zapisa (objekta klase Radnik):

unsigned long br_obj(){ ifstream fin("RADNICI.DAT", ios::binary + ios::in);

if (!fin) return 0; else { // skoci na kraj fin.seekg(0,ios::end); // racunanje broja objekata unsigned long rez = fin.tellg() / sizeof(Radnik);

fin.close();

return rez; }}

ISPIS ODREĐENOG ELEMENTA

Ovime se omogućuje korisniku da unese redni broj radnika te da se na zaslonu pojave njegovi podaci. Nakon što korisnik unese redni broj, potrebno je provjeriti je li uneseni broj ispravan. Broj ne smije biti manji od 1 niti veći od broja upisanih radnika u datoteci. Ukoliko je broj ispravan, potrebno je na ranije objašnjeni način "skočiti" na traženi zapis, pročitati dotični objekt te ispisati podatke na zaslon:

void ispisi_jednog(){ unsigned long n;

n = br_obj(); // broj objekata u datoteci

unsigned long x;

cout << "\n\n\n";

cout << "Unesite redni broj radnika: "; cin >> x;

if (x > n) cout << "Nema toliko radnika u bazi!\n"; else if (x < 1) cout << "Pogresan unos!\n"; else { ifstream fin("RADNICI.DAT", ios::binary + ios::in);

if (!fin) cout << "Greska! Ne mogu otvoriti datoteku!\n"; else { Radnik pom; // "skoci" na trazenu poziciju fin.seekg((x - 1) * sizeof(Radnik));

// procitaj podatak fin.read((char *) &pom,sizeof(Radnik));

cout << "\n"; pom.Ispisi();

fin.close(); } }}

PROMJENA PODATAKA ZA JEDAN ELEMENT

Prije obavljanja promjene, potrebno je usvojiti još par novih tehnika rada sa datotekama. Ideja same promjene je da se prvo pročita podatak koji se mijenja, nakon toga se ispišu trenutne vrijednosti za taj podatak (u ovom primjeru se ispisuju trenutni podaci radnika), korisnik unosi

nove podatke te se novi podaci prepisuju preko starih. Datoteku je potrebno istovremeno otvoriti za čitanje i za pisanje. U tu svrhu se koristi klasa fstream:

fstream f("RADNICI.DAT", ios::binary + ios::in + ios::out + ios::nocreate);

Drugi argument se čita na slijedeći način: datoteka se otvara kao binarna, za čitanje i pisanje, ukoliko datoteka ne postoji neće se stvoriti nova datoteka, a ukoliko datoteka postoji njen sadržaj neće biti prebrisan. Sada je moguće obavljati i operacije čitanja i operacije pisanja nad datotekom. Načelno se postupak promjene podataka svodi na slijedeće korake:

1. Učitaj redni broj traženog radnika.2. "Skoči" na traženu poziciju, pročitaj podatke u radnu memoriju, ispiši podatke na

zaslon.3. Učitaj nove podatke te popuni objekt sa njima.4. Skoči na traženu poziciju i zapiši nove podatke preko starih.

U koraku 4. potrebno je promijeniti trenutnu poziciju na koju se zapisuje podatak. To se postiže pozivom metode seekp koja radi na isti način kao i metoda seekg. Konkretno se ovaj postupak može napraviti na slijedeći način:

void promjena_radnika(){ unsigned long n;

n = br_obj();

unsigned long x;

cout << "\n\n\n"; cout << "Unesite redni broj radnika: ";

cin >> x;

if (x > n) cout << "Nema toliko radnika u bazi!\n"; else if (x < 1) cout << "Pogresan unos!\n"; else { fstream f("RADNICI.DAT", ios::binary + ios::in +

ios::out + ios::nocreate);

if (!f) cout << "Greska! Ne mogu otvoriti datoteku!\n"; else { // citanje podataka Radnik pom; f.seekg((x - 1) * sizeof(Radnik)); f.read((char *) &pom,sizeof(Radnik));

cout << "\nPodaci o radniku:\n\n"; pom.Ispisi();

// unos novih podataka char ime[20],prezime[20]; float pl;

cout << "Unesite ime: "; cin >> ime;

cout << "Unesite prezime: "; cin >> prezime;

cout << "Unesite placu: "; cin >> pl;

pom.set_placa(pl); pom.set_ime(ime); pom.set_prezime(prezime);

// na mjesto starih podataka dolaze novi podaci f.seekp((x - 1) * sizeof(Radnik)); f.write((const char *) &pom,sizeof(Radnik));

f.close(); } }}

GLAVNI PROGRAM

Sada je moguće napraviti jednostavni glavni program koji povezuje ove funkcije u cjelinu:

void nacrtaj_izbornik(){ cout << "\n\n\n"; cout << "1. Dodavanje novog elementa\n"; cout << "2. Ispis svih elemenata\n"; cout << "3. Ispis tocno jednog radnika\n"; cout << "4. Promjena podataka radnika\n"; cout << "X. Kraj rada\n\n"; cout << "Odabir: ";}

main(){ while(1) { nacrtaj_izbornik();

char ch; cin >> ch; if (ch == 'X' || ch == 'x') break;

switch(ch) { case '1': dodaj_novi(); break;

case '2':

ispisi_sve(); break;

case '3': ispisi_jednog(); break;

case '4': promjena_radnika(); break; } } return 0;}

DATOTEKE.............................................................................................................................................1

OSNOVE RADA S DATOTEKAMA...........................................................................................1OTVARANJE DATOTEKE..................................................................................................2

DATOTEKE ZA PISANJE (IZLAZNE DATOTEKE)..........................................2DATOTEKE ZA ČITANJE (ULAZNE DATOTEKE)...........................................2ZATVARANJE DATOTEKE.................................................................................2PROVJERA JE LI DATOTEKA USPJEŠNO OTVORENA.................................3

OBAVLJANJE OSNOVNIH OPERACIJA NAD DATOTEKAMA............................................3JEDNOSTAVNO PISANJE U DATOTEKU........................................................................3JEDNOSTAVNO ČITANJE IZ DATOTEKE.......................................................................4

UPOTREBA DATOTEKA U KONKRETNIM PROGRAMIMA................................................5POSEBNO ZAPISIVANJE BROJA ELEMENATA POLJA.................................................5ZAPISIVANJE POLJA BEZ ZAPISIVANJA BROJA ELEMENATA...................................6

SPREMANJE I UČITAVANJE OBJEKATA...............................................................................8SPREMANJE I UČITAVANJE POLJA OBJEKATA...........................................................9

DODAVANJE NA KRAJ DATOTEKE......................................................................................10BINARNE DATOTEKE..............................................................................................................10

JEDNOSTAVNO ZAPISIVANJE U BINARNU DATOTEKU...........................................11JEDNOSTAVNO ČITANJE IZ BINARNE DATOTEKE....................................................12ZAPISIVANJE POLJA U BINARNU DATOTEKU...........................................................13ČITANJE POLJA IZ BINARNE DATOTEKE...................................................................13PISANJE I ČITANJE OBJEKATA U BINARNE DATOTEKE..........................................14

DIREKTAN PRISTUP PODACIMA..........................................................................................14SEEKG METODA.............................................................................................................15ODREĐIVANJE VELIČINE DATOTEKE........................................................................15

ČUVANJE PODATAKA UZ MINIMALNI UTROŠAK RADNE MEMORIJE.......................16ORGANIZACIJA PODATAKA..........................................................................................16DODAVANJE NOVOG ELEMENTA................................................................................17ISPIS SVIH ELEMENATA U DATOTECI........................................................................17RAČUNANJE BROJA OBJEKATA U DATOTECI...........................................................18ISPIS ODREĐENOG ELEMENTA...................................................................................19PROMJENA PODATAKA ZA JEDAN ELEMENT...........................................................19GLAVNI PROGRAM.......................................................................................................21

5.1 datoteke

Documents