diff --git a/POO_22_C_2022-03-03.md b/POO_22_C_2022-03-03.md
new file mode 100644
index 0000000..cf8508e
--- /dev/null
+++ b/POO_22_C_2022-03-03.md
@@ -0,0 +1,121 @@
+## ALOCAREA DINAMICA A MEMORIEI IN C++
+In C++ au fost introdusi 4 operatori noi folositi pentru alocare, respectiv pentru eliberarea dinamica de memorie.
+Pentru alocarea unei casute de memorie se foloseste operatorul ```new```.
+```cpp
+tip_date *p = new tip_date;
+```
+Eliberarea se face cu ajutorul operatorului ```delete```.
+```cpp
+delete p;
+```
+Pentru alocarea unui vector de casute se foloseste operatorul ```new[]```.
+```cpp
+p = new tip_date[n];
+```
+Eliberarea se face cu operatorul ```delete[]```.
+```cpp
+delete[] p;
+```
+Introducerea operatorilor ```new``` si ```delete``` fac posibila alocarea dinamica a memoriei intr-o maniera moderna, simplifica scrierea codului fata de folosirea functiilor din C, castigul, insa nu este consistent deoarece pentru alocari complexe (matrici), alocarile ramand a se face in mai multi pasi, ca in C.
+Gestionarea memoriei alocate dinamic stil C difera fata de stilul C++, de aceea nu trebuie combinate alocarii C cu eliberarea C++ sau invers. Daca se face acest lucru este posibil sa avem erori la executie.
+Combinarea unui apel ```new[]``` cu un ```delete```, de regula nu afecteaza executia programului (depinde de compilator). Este bine sa folosim ```delete[]``` cand avem ```new[]```.
+
+## REDACTAREA FUNCTIILOR IN C++
+### Supraincarcarea functiilor
+In C++ au fost introduse o multime de elemente noi atunci cand se scriu functii. Acestea ajuta la o redactare mai eleganta a codului.
+In C, semnatura functieie este data de numele ei, ceea ce inseamna ca la compilare, cand se intalneste un apel de functie, este identificata pe baza numelui, in consecinta, nu pot exista mai multe functii cu acelasi nume si care sa difere prim parametri in acelasi proiect.
+In C++, semnatura este data de: nume, numar de parametri, tipurile de date ale parametrilor, consecinta imediata este ca in C++ putem avea functii cu acelasi nume, dar care sa difere prim parametri. Aceasta proprietate poarta denumirea de **supraincarcarea (overloading) functiilor**.
+
+```cpp
+int maxim(int x, int y);
+float maxim(float x, float y);
+int maxim(int x, int y, int z);
+```
+Tipul de date returnat nu poate face parte din semnatura.
+
+### Tipul referinta
+In anumite situatii poate fi o alternativa mai moderna si mai simpla la pointeri.
+O variabila ```v1``` de tip referinta se declara ```tip_date& v1=v2```. Declaratia variabile e tip referinta se termina intotdeauna cu ```=``` dupa care urmeaza o variabila de acelasi tip referit de ```v1```. ```v1``` este un alias al lui ```v2```, ambele variabile referind aceeasi casuta de memorie.
+Variabila referinta poate ajuta la simplificarea scrierii codului atunci cand ne referim la un camp al unui structuri
+
+```cpp
+struct pereche
+{
+	float x,y;
+};
+
+struct cerc
+{
+	pereche centru;
+	float raza;
+};
+
+cerc c;
+float& x = c.centru.x;
+float& y = c.centru.y;
+float& r = c.raza
+
+x = 7;
+y = 1.4;
+r = 10;
+```
+Scrierea de mai sus, in care coordonata si raza sunt referinte, prin cele trei variabile este simplificata si optimizata ca viteza de executare.
+
+### Transmiterea parametrilor prin referinta
+O data cu introducerea tipului referinta, s-a simplificat si folosirea parametrilor de iesire a functiilor.
+```cpp
+//f1
+void inc(int* x)
+{
+	(*x)++;
+}
+inc(&a);
+```
+vs
+```cpp
+//f2
+void inc(int &x)
+{
+	x++;
+}
+inc(a);
+```
+La apelul ```f2```, ```inc``` apare o noua variabila ```x``` care refera variabila transmisa (```a``` si ```x``` referind aceeasi casuta de memorie); ```x++``` modifica casuta, deci efectul se va vedea si in variabila ```a```. Dupa cum se poate observa, apelul celei de-a doua functie ```inc``` este simplificat, la fel si implementarea.
+
+### Valori implicite pentru parametri functiilor
+Unul sau mai multi parametri pot capata valori implicite la implementarea unei functii.
+```cpp
+int inc(int&x, int v=1)
+{
+	x+=v;
+}
+```
+In antetul functiei, valoarea implicita este data pentru un parametru  dupa ```=```. La apelul unei functii care are parametri cu valori implicite este posibil sa nu transmitem valori pentru o parte dintre acestia. Pentru cei care lipsesc din apel se vor considera valorii implicite ```1```.
+```cpp
+void main()
+{
+	int a = 7;
+	inc(a); //a = 8
+	inc(a, -2); //a = 5
+}
+```
+La compilare, al intalnirea unui astfel de functie, se creeaza mai multe functii cu acelasi nume, diferind pin numarul de parametri, lucru posibil dat mecanismului de supraincarcarea a functiilor.
+In cazul implementarii cu un parametru, variabila ```v``` devine variabila locala initializata cu ```1```.
+
+Reguli ce trebuie respectate:
+- parametrul care capata valoarea implicita trebuie sa fie obligatoriu ultimul
+- la apelul unei astfel de functii, valoarile transmise initializeaza parametri de la stanga la dreapta, iar pentru valorile lipsa (ultimele) se considera valori implicite.
+```cpp
+void f(int x, int y = 1, float z = 2);
+//--
+f(1,4.7);
+/*  x ia valoarea 1, 
+	4.7 initializeaza pe y (y devie 4), 
+	z se ia valoarea implicita 2.
+*/
+```
+De regula, valorile implicite pentru parametri se specifica in antetul functiei si nu se dau din nou cand functia este implementata.
+```cpp
+void f(int x=1); //antet
+void f(int x){...} //cpp
+```