POO_22_C_2022-05-26.md

Ierarhia ios

Din clasa ios sunt derivate 4 clase:

• istream: specializata pe fluxuri de intrare (cin este obiect istream)
• ostream: specializata pe fluxuri de iesire (cout este un obiect istream)
• fstreambase: este clasa de baza pentru fluxuri de tip fisiere
• strstreambase: specializata si de baza pentru fluxuri de tip string Cele 4 clase contin o serie de metode conform specificului fiecareia, insa aceste clase, in general, nu se instantiaza direct, facilitatiile lor fiind utilizate in obiecte instanta unor clase derivate din cele 4. Clasa istream are un singur constructor:

istream (streambuf* buf)
//primeste pointerul catre buffer

int gcount()
/*
* returneaza numarul de octeti ultima oara preluati 
* din fluxul de intrare
* Sufixurile si prefixele g sunt specifice metodelor
* scrise pentru fluxuri de intrare ( g = get )
*/

int get()
/*
* returneaza si scoate din fluxul de intrare urmatorul
* caracter
*/

istream& get(signed char* s, int e, char end = '\n')
/*
* se incearca extragerea a 'e' caractere din fluxul,
* informatie depusa la 's'. Se extrag mai putin de 'e'
* caractere, daca pana la sfarsitul fisierului nu mai
* exista 'e' caractere. 'end' este folosit pentru a defini
* delimitatorul de linii
*/

istream& get(unsigned char* s, int e, char end = '\n')

istream& get(signed char& c)
istream& get(unsigned char& c)
/*
* se citeste urmatorul caracter si se depune in variabila
* data ca parametru
*/

istream& getline(signed char* s, int e, char end = '\n')
istream& getline(unsigned char* s, int e, char end = '\n')
/*
* 'getline' citeste 'e' caractere sau pana la intalnirea
* 'end', spre deosebire de 'get', la adresa 's' nu se
* depunde si caracterul de sfarsit de linie.
*/

int peek()
/*
* returneaza urmatorul caracter din fluxul de intrare,
* dar nu il extrage
*/

istream& ignore(int n = 1, int end = '\n')
/*
* sunt extrase din flux urmatoarele 'n' caractere fara
* a fi returnate. Citirea se poate termina mai rapid
* daca se intalneste 'end'.
*/

istream& putback(char c)
/*
* introduce la loc in fluxul de intrare caracterul 'c'
*/

Functii pentru citire in modul binar:

istream& read(signed char* s, int n)
istream& read(unsigned char* s, int n)
/*
* se citesc in mod binar urmatorii 'n' octeti din fluxul
* de intrare, informatia citita depunandu-se in 's'
*/

istream& seekg(long poz)
/*
* se face o pozitionare in fluxul de intrare pe pozitia
* octetului 'poz' relativ la inceputul fluxului
*/

istream& seekg(long poz, int rel)
/*
* se face o pozitionare cu 'rel' octeti relativ la inceputul
* fluxului
* 'rel' poate avea valorile:
*  - ios::beg ('poz' >= 0)
*  - ios::cur (oricare 'poz')
*  - ios::end ('poz' <= 0)
*/

int tellg()
/*
* returneaza pozitia curenta de citire a fluxului
*/

Clasa ostream are acelasi contructor ca sttructura:

ostream (streambuf* buf)

Metode:

ostream& slush()

ostream& put(char c)
/*
* se introduce un caracter in fluxul de iesire
*/

ostream& seekp(long poz)
/*
* prefixul sau sufixul 'p' insoteste functii membre pentru
* fluxuri de iesire ( 'p' = put )
*/

ostream& seekp(long poz)
ostream& seekp(long poz, int rel)
/*
* pentru pozitionare in fluxul de iesire la inceput,
* pozitia curenta sau sfarsit
*/

long tellp()
/*
* se returneaza pozitia curenta pentru scriere
*/

ostream& write(const signed char* s, int n)
ostream& write(const unsigned char* s, int n)
/*
* de la adresa lui se iau n octeti si se scriu in mod binar
* in flux
*/

Din clasele istream si ostream este derivata clasa iostream specializa pentru fluxuri care suporta atat flucuri de citire cat si de scriere. iostream nu se instantiaza direct.

Fisiere

fstreambase este clasa specializa pentru lucrul cu fisiere, dar fstreambase nu se instantiaza direct, fiind clasa de baza pentru clasele folosite efectiv in prelucrarea fisierelor. Toate clasele derivate din fstreambase au fiecare cate 4 constructori:

fstreambase()
/*
* obiectul rezultat nu are atasat fisier, urmand ca acestuia
* sa i se ataseze ulterior un fisier.
*/

fstreambase(int d)
/*
* obiectului nou creat i se ataseaza fisierul avand
* descriptorul 'd'. Fiecarui fisier deschis i se ataseaza
* un ID de tip 'int' unic denumit **descriptor**.
*/

fstreambase(int d, char* s, int n)
/*
* obiectului nou creat i se ataseaza fisierul cu ID-ul 'd', 
* iar pentru buffer se foloseste zona de memorie de la 
* adresa 's', zona avand lungimea 'n' caractere.
*/

fstreambase(const char* numef, int mod, int prot = filebuf::openprot)
/*
* primul parametru specifica calea catre fisierul ce se
* deschide o data cu creearea obiectului. 
* al doilea parametru specifica modul in care se deschide
* fisierul:
*  - pentru operatii de citire
*  - pentru operatii de scriere
*  - pentru operatii de citire / scriere
*  - modul binar
*  - modul text
* ultimul parametru indica faptul ca fisierul se deschide
* in modul protejat sau nu , implicit protected
* int mod:
*  - ios::in
*  - ios::out
*  - ios::app       (scriere cu pozitionare la sfarsit)
*  - ios::nocreate  (daca fisierul nu exista pe disk,
*                    deschiderea esueaza)
*  - ios::noreplace (daca fisierul exista pe disk,
*                    el nu este sters)
*  - ios::binary    (fisierul este deschis in modul
*                    binar, in lipsa lui, fisierul este
*                    deschis in modul text)
*/

Functii membre clasei fstreambase:

void attach(int d)
/*
* ataseaza obiectului curent fisierul cu descriptorul 'd'
*/

void close()
/*
* inchide fisierul deschis si atasat fluxului
* un obiect cand este distrus eventualul fisier atasat
* este inchis. 
*/

void open(const char* numef, int mod, int prot = filebuf::openprot)
/*
* se incearca deschiderea unui fisier avand calea in 
* primul parametru si modurile date de urmatorii doi
* parametri.
*/

/*
* Functiile good, bad, fail pot fi interogate pentru a vedea
* daca fisirul a fost deschis.
*/

filebuf* rdbuf()
/*
* returneaza pointerul catre bufferul atasat fisierului
*/

void setbuf(char* s, int n)
/*
* se ataseaza o zona de memorie tampon ce va fi atatasata
* fisierului
*/

ifstream este specializata pentru fisiere de intrare si este derivata din fstreambase si din istream. Are 4 constructori cu acceasi structura de parametri ca fstreambase, cu deosebirea ca la al patrulea constructor, in al doilea parametru avem valoarea implicita ios::in.

Metode specifice ifstream:

open(...)
rdbuf()

ofstream este specializata pentru operatii de scriere si este derivata din fstreambase si din ostream. Are 4 constructori cu acceasi structura de parametri ca fstreambase, cu deosebirea ca la al patrulea constructor, in al doilea parametru avem valoarea implicita ios::out.

Metode specifice ofstream:

open(...)
rdbuf()

fstream specializata pe fluxuri pentru operatii de citire si scriere, fiind derivata din ifstream, ofstream si iostream. Are 4 constructori cu acceasi structura de parametri ca fstreambase.

//ex.
fstream f("fis.txt", ios::in | ios::out)
//fisier deschis atat pentru citire cat si pentru scriere

Metode specifice fstream:

open
rdbuf()

Similar subierarhiei fstreambase exista o subierarhie strstreambase pentru prelucrare de stringuri. strstreambase :

• istrstream
• ostrstream
• strstream (derivata si din iostream)

Obictele strstream sunt de fapt niste wrapper-e pentru strigurile standard C.

//copierea unui fisier dintr-o locatie in alta locatie
int main(int n, char* p[])
{
	if(n != 3) { cerr << "Nr. param. invalid"; return 1; }
	ifstream fin(p[1], ios::binary);
	if(fin.bad()) return 1;
	ofstream fout(p[2], ios::binary);
	if(fout.bad()) return 1;
	const int N = 1000000; // ~ 1 MB
	char* buf[N];
	while(!fin.feof())
	{
		read(buf, N);
		fout.write(buf, fin.gcount());
	}
	fin.close();
	fout.close();
	return 0;
}

struct test
{...};

test t;
...
fout.write((char*)&t, sizeof(t));