Merge pull request #16 from tgpetrica/add_2022-05-26

initial commit

POO_22_C_2022-05-26.md

@@ -0,0 +1,294 @@
+## 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:
+```cpp
+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:
+```cpp
+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:
+```cpp
+ostream (streambuf* buf)
+```
+Metode:
+```cpp
+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:
+```cpp
+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`:
+```cpp
+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`:
+```cpp
+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`:
+```cpp
+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`. 
+```cpp
+//ex.
+fstream f("fis.txt", ios::in | ios::out)
+//fisier deschis atat pentru citire cat si pentru scriere
+```
+Metode specifice `fstream`:
+```cpp
+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.
+
+```cpp
+//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;
+}
+```
+
+```cpp
+struct test
+{...};
+
+test t;
+...
+fout.write((char*)&t, sizeof(t));
+```

README.md

@@ -46,3 +46,6 @@
 - clase imbricate
 - clase template
 - ierarhia ```ios```
+#### [Curs 13](https://github.com/tgpetrica/POO-courses/blob/main/POO_22_C_2022-05-26.md)
+- iararhia ```ios```
+- fisiere