#define _CRT_SECURE_NO_WARNINGS

#include<iostream>
#include<string>
using namespace std;

//ce este o clasa? --- este o structura de date ce incorporeaza date si functii(metode)

//modificatori de acces- public, private, protected

//ce inseamna const? --- un atribut de tip constant(Const) nu-si modifica valoarea pe parcursul
rularii programului
//ce inseamna static? --- un atribut de tip static apartine intregii clasei(adica va avea aceeasi
valoare pentru orice obiect creat)
//exemplu pentru static --- TVA

//cat ocupa aceste tipuri de data?

//1) bool = 1 byte
//2) int = 4 bytes
//3) float = 4 bytes
//4) double = 8 bytes
//5) char = 1 byte
//6) char*= 4 bytes
//7) bool* = 4 bytes
//8) double* = 4 bytes
class Examen
{

const int idExamen;

static int contor;
protected:
char* materie;
string profesor;
int nota;
//vector alocat static pentru ca ii cunoastem deja dimensiunea
int data[3];
int nrSubiecte;
float* punctajeSubiecte;

public:

//constructor default/implicit/fara parametrii

//constructorii -- sunt functii membre speciale, care au acelasi nume ca si clasa si se
ocupa de initializarea atributelor din clasa
//sunt utilizati la crearea obiectelor
Examen(/*aici se trec parametrii*/):idExamen(contor++)
{
//pentru char* si string dam un mesaj
this->materie = new char[strlen("Necunoscut") + 1];//+1 vine de la terminatorul '\0'
strcpy(this->materie, "Necunoscut");
this->profesor = "Xulescu";
//pentru atributele numerice dam valoarea 0
this->nota = 0;
this->data[0] = 1;
this->data[1] = 1;
this->data[2] = 2021;
this->nrSubiecte = 0;
//pentru atributele alocate dinamic(in afara de char*) dam valoarea NULL;
this->punctajeSubiecte = NULL;

//constructorul cu toti parametrii

Examen(const char* materie,string profesor, int nota, int data[3], int nrSubiecte, float*
punctajeSubiecte) :idExamen(contor++)
{
//pentru char* si string dam un mesaj
this->materie = new char[strlen(materie) + 1];//+1 vine de la terminatorul '\0'
strcpy(this->materie, materie);
this->profesor = profesor;
this->nota = nota;
this->data[0] = data[0];
this->data[1] = data[1];
this->data[2] = data[2];
this->nrSubiecte = nrSubiecte;
this->punctajeSubiecte = new float[this->nrSubiecte];
for(int i=0;i<this->nrSubiecte;i++)
{
this->punctajeSubiecte[i] = punctajeSubiecte[i];
}
}

//metode de acces(metode accesor)

//metodele de acces sunt getteri si setteri

//getteri --- functii accesor care permit citirea unei valori dintr-un atribut
//cum se construieste un getter:
//sablon getter
/*
tipVariabila getNumeVariabila()
{
return this->variabila;
}
*/
const int getIdExamen()
{
return this->idExamen;
}
char* getMaterie()
{
return this->materie;
}

string getProfesor()
{
return this->profesor;

int* getData()
{
return this->data;
}

int getNota()
{
return this->nota;
}

int getNrSubiecte()
{
return this->nrSubiecte;
}

float* getPunctajeSubiecte()
{
return this->punctajeSubiecte;
}

//setteri -- sunt metode accesor care permit modificare valorii atributelor

 //setterul este mereu si mereu VOID(pentru ca doar modifica)
//NICIODATA NU FACEM SETTERI PENTRU CONSTANT(CONST) SI STATIC
//in setteri, in op = , in op >>, la pointeri intai dezalocam folosind delete si apoi alocam
iar folosind new
//sablon setter
/*
void setVariabila(tipVariabila numeVariabila)
{
this->tipVariabila= numeVariabila;
}
*/

void setMaterie(const char* materie)

{
if (strlen(materie) > 2)
{
if (this->materie != NULL)
{
delete[]this->materie;
}
this->materie = new char[strlen(materie) + 1];//+1 vine de la terminatorul '\
0'
strcpy(this->materie, materie);
}

}
void setProfesor(string profesor)
{
if ([Link]() > 2)
{
this->profesor = profesor;
}
else throw exception();
}
void setNota(int nota)
{
if (nota > 0 && nota <= 10)
{
this->nota = nota;

}
 void setData(int data[3])
{
if (data[0] >= 1 && data[0] <= 31 && data[1]>=1 && data[1]<=12 &&
data[2]>=2010&&data[2]<=2021)
{
this->data[0] = data[0];
this->data[1] = data[1];
this->data[2] = data[2];
}

}
//ASA NU!
//void setNrSubiecte(int nrSubiecte)

//ASA DA!
void setPunctajeSubiecte(int nrSubiecte, float*punctajeSubiecte)
{
if (nrSubiecte > 0 && punctajeSubiecte != NULL)
{
if (this->punctajeSubiecte != NULL)
{
delete[]this->punctajeSubiecte;
}
this->nrSubiecte = nrSubiecte;
this->punctajeSubiecte = new float[this->nrSubiecte];
for (int i = 0; i < this->nrSubiecte; i++)
{
if (punctajeSubiecte[i] > 0)
{
this->punctajeSubiecte[i] = punctajeSubiecte[i];
}
else
{
this->punctajeSubiecte[i] = 0;
}
}
}

//constructor de copiere --- se apeleaza atunci cand dorim/vrem sa cream un obiect nou
pe baza altuia deja existent
 //constructorul de copiere seamana cu constructorul cu toti parametrii
Examen(const Examen& e):idExamen([Link])
{
//pentru char* si string dam un mesaj
this->materie = new char[strlen([Link]) + 1];//+1 vine de la terminatorul '\0'
strcpy(this->materie, [Link]);
this->profesor = [Link];
this->nota = [Link];
this->data[0] = [Link][0];
this->data[1] = [Link][1];
this->data[2] = [Link][2];
this->nrSubiecte = [Link];
this->punctajeSubiecte = new float[this->nrSubiecte];
for (int i = 0; i < this->nrSubiecte; i++)
{
this->punctajeSubiecte[i] = [Link][i];
}
}
//destructorul -- rolul lui este sa dezaloce memoria din zona HEAP(zona de memorie
artibuita programatorului)
~Examen()
{
if (this->materie != NULL)
{
delete[]this->materie;
}
if (this->punctajeSubiecte != NULL)
{
delete[]this->punctajeSubiecte;
}
}

//operator = ---- se apeleaza atunci cand avem doua obiecte deja existente si vrem sa ii
atribuim unui obiect valorile celuilalt
Examen& operator=(const Examen& e)
// op = se compune din destructor(ce scrie in el) + constructor de copiere + return *this;
{
//evitarea auto-asignarii(nu putem sa facem un obiect egal cu el insusi ---
ex:e1=e1)
if (this != &e)
{
if (this->materie != NULL)
{
 delete[]this->materie;
}
if (this->punctajeSubiecte != NULL)
{
delete[]this->punctajeSubiecte;
}
this->materie = new char[strlen([Link]) + 1];//+1 vine de la terminatorul
'\0'
strcpy(this->materie, [Link]);
this->profesor = [Link];
this->nota = [Link];
this->data[0] = [Link][0];
this->data[1] = [Link][1];
this->data[2] = [Link][2];
this->nrSubiecte = [Link];
this->punctajeSubiecte = new float[this->nrSubiecte];
for (int i = 0; i < this->nrSubiecte; i++)
{
this->punctajeSubiecte[i] = [Link][i];
}
return *this;
}

//metode --- sunt functii din interiorul clasei care primesc implicit pointerul this(*this)
//cateva metode mai uzuale si simple (min,max,suma,medie)-- de obicei cand avem
vector numeric

//suma
float totalPunctajeSubiect()
{
float total = 0;
for (int i = 0; i < this->nrSubiecte; i++)
{
total = total + this->punctajeSubiecte[i];
}
return total;
}

float mediePunctaje()
{
float total = 0;
for (int i = 0; i < this->nrSubiecte; i++)
 {
total = total + this->punctajeSubiecte[i];
}
return total/this->nrSubiecte;
}
//minim si maxim se initializeaza cu prima valoare din vector
float minPunctaje()
{
float min = this->punctajeSubiecte[0];
for (int i = 0; i < this->nrSubiecte; i++)
{
if (min > this->punctajeSubiecte[i])
{
min = this->punctajeSubiecte[i];
}
}
return min;
}
float maxPunctaje()
{
float max = this->punctajeSubiecte[0];
for (int i = 0; i < this->nrSubiecte; i++)
{
if (max < this->punctajeSubiecte[i])
{
max = this->punctajeSubiecte[i];
}
}
return max;
}

bool areRestanta()
{
return this->nota < 5;
}

bool examenulEsteRestanta()
{
return data[1] == 7;
}

void adaugaSubiect(float punctaj)

{
Examen copie = *this;
 delete[]this->punctajeSubiecte;
this->nrSubiecte++;
this->punctajeSubiecte = new float[this->nrSubiecte];
for (int i = 0; i < [Link]; i++)
{
this->punctajeSubiecte[i] = [Link][i];
}
this->punctajeSubiecte[this->nrSubiecte - 1] = punctaj;
}

void EliminaSubiect(float punctaj)

{
Examen copie = *this;
int nr = 0;//vom stoca aici de cate ori se gaseste numarul cautat in vector
for (int i = 0; i < this->nrSubiecte; i++)
{
if (punctaj == this->punctajeSubiecte[i])
{
nr++;
}
}
delete[]this->punctajeSubiecte;
this->nrSubiecte = this->nrSubiecte - nr;
this->punctajeSubiecte = new float[this->nrSubiecte];
int pozitie = 0;
for (int i = 0; i < [Link]; i++)
{
if (punctaj != [Link][i])
{
this->punctajeSubiecte[pozitie] = [Link][i];
pozitie++;
}
}
}

//operatori

//op <<
//friend --- ofera accesul la atributele din zona privata a unei clase fara sa aiba pointerul
this;
//friend se foloseste neaparat(ca nu se poate fara) atunci cand avem nevoie de un
operator ce implica(are nevoie) de 2 termeni, unul in stanga altul in dreapta
//iar cel din stanga nu este de tipul clasei --- ex(cout<<e1, cin>>e2; e1= 44+e2;)
friend ostream& operator<<(ostream& out, const Examen e)
{
out << "ID:" << [Link] << endl;
out << "Materie:" << [Link] << endl;
out << "Profesor:" << [Link] << endl;
out << "Nota:" << [Link] << endl;
out << "Data:";
for (int i = 0; i < 3; i++)
{
out << [Link][i] << "/";

}
out << endl;
out << "Numar Subiecte:" << [Link] << endl;
out << "Punctaj subiecte: ";
for (int i = 0; i < [Link]; i++)
{
out << [Link][i] << " | ";

}
out << endl;
return out;
}

//operator >>
//in op >> intai trebuie sa dezalocam pointerii si apoi alocam iar
friend istream& operator>>(istream& in, Examen& e)
{
if ([Link] != NULL)
{
delete[][Link];
}
if ([Link] != NULL)
{
delete[][Link];
}
//op>> pentru char*
cout << "Materie:";
in >> ws;
char aux[250];
[Link](aux,249);
[Link] = new char[strlen(aux) + 1];
strcpy([Link], aux);
//op>> pentru string
 cout << "Profesor:";
getline(in, [Link]);
//op>> pentru int
cout << "Nota:";
in >> [Link];
//op>> pentru int static sau int*
cout << "Data(zi/ luna/ an):";
for (int i = 0; i < 3; i++)
{
in >> [Link][i];
}
//op>> pentru int
cout << "Numar Subiecte:";
in >> [Link];
//op>> pentru int static sau int*
cout << "Punctaj Subiecte:";
[Link] = new float[[Link]];
for (int i = 0; i < [Link]; i++)
{
in >> [Link][i];
}
return in;
}

//operator functie -- op()

bool operator ()(int valoare)
{
return this->nrSubiecte > valoare;
}

//operatorul cast -- conversie cu pierdere de informatii

//implicit
/*operator string()
{
return this->profesor;
}*/
//explicit
explicit operator string()
{
return this->profesor;
}

//operator de indexare -- operator [] -- primeste un parametru

float &operator[](int pozitie)
{
if (pozitie >= 0 && pozitie < this->nrSubiecte)
{
return this->punctajeSubiecte[pozitie];
}
else throw exception();
}

//operatori relationali -->,<,>=,==,!

bool operator<(int nr)

{
return this->nrSubiecte < nr;
}
bool operator>(Examen e)
{
return this->nota > [Link];
}
bool operator==(Examen e)
{
return this->profesor == [Link];
}
bool operator!()
{
bool restanta = 0;
if (this->nota > 4)
{
restanta = 0;
this->nota = 2;
}
else
{
restanta = 1;
this->nota = 7;
}
return restanta;
}
bool operator~()
{
return this->nota > 4;
}

//operator ++ pre incrementat --- a= ++b; ==>1) b++; 2)a=b

Examen& operator ++()
{
if (this->nota <= 9)
{
this->nota++;
}
return *this;
}
//operator += post incrementat --- a=b++; ==> 1)a=b; 2)b++
Examen operator ++(int)
{
Examen copie = *this;
if (this->nota <= 9)
{
this->nota++;
}
return copie;
}

//operator +=
Examen& operator +=(float punctaj)
{
Examen copie = *this;
delete[]this->punctajeSubiecte;
this->nrSubiecte++;
this->punctajeSubiecte = new float[this->nrSubiecte];
for (int i = 0; i < [Link]; i++)
{
this->punctajeSubiecte[i] = [Link][i];
}
this->punctajeSubiecte[this->nrSubiecte - 1] = punctaj;
return *this;
}

//operator -=
Examen& operator -=(float punctaj)
{
Examen copie = *this;
int nr = 0;//vom stoca aici de cate ori se gaseste numarul cautat in vector
for (int i = 0; i < this->nrSubiecte; i++)
{
if (punctaj == this->punctajeSubiecte[i])
{
nr++;
 }
}
delete[]this->punctajeSubiecte;
this->nrSubiecte = this->nrSubiecte - nr;
this->punctajeSubiecte = new float[this->nrSubiecte];
int pozitie = 0;
for (int i = 0; i < [Link]; i++)
{
if (punctaj != [Link][i])
{
this->punctajeSubiecte[pozitie] = [Link][i];
pozitie++;
}
}
return *this;
}

static float medieNoteExamene(int nrEx, Examen* vect)

{
float total = 0;
for (int i = 0; i < nrEx; i++)
{
total += vect[i].getNota();
}
return total / nrEx;
}
};

//initializarea atributului static

int Examen::contor = 1;
// ostream& operator<<(ostream& out, Examen e)
//{
// out << "ID:" << [Link]() << endl;
// out << "Materie:" << [Link]() << endl;
// out << "Profesor:" << [Link]() << endl;
// out << "Nota:" << [Link]() << endl;
// out << "Data:";
// for (int i = 0; i < 3; i++)
// {
// out << [Link]()[i] << "/";
//
// }
// out << endl;
// out << "Numar Subiecte:" << [Link]() << endl;
// out << "Punctaj subiecte: ";
// for (int i = 0; i < [Link](); i++)
// {
// out << [Link]()[i] << " | ";
//
// }
// out << endl;
// return out;
//}
// istream& operator>>(istream& in, Examen& e)
// {
//
// //op>> pentru char*
// cout << "Materie:";
// in >> ws;
// char aux[250];
// [Link](aux, 249);
// [Link](aux);
// //op>> pentru string
// cout << "Profesor:";
// string prof;
// in >> prof;
// [Link](prof);
// //op>> pentru int
// cout << "Nota:";
// int nota;
// in >> nota;
// [Link](nota);
// //op>> pentru int static sau int*
// int data[3];
// cout << "Data:";
// for (int i = 0; i < 3; i++)
// {
// in >> data[i];
// }
//
// [Link](data);
// //op>> pentru int
// cout << "Numar Subiecte:";
// int nrSub;
// in >> nrSub;
// //op>> pentru int static sau int*
// cout << "Punctaj Subiecte:";
// float* pctSub = new float[nrSub];
// for (int i = 0; i < nrSub; i++)
// {
// in >> pctSub[i];
// }
// [Link](nrSub, pctSub);
// return in;
// }
int main()
{
Examen e;
cout << "-------------------Getteri---------------------------" << endl;
cout << [Link]() << endl;
cout << [Link]() << endl;
cout << [Link]() << endl;
//cout << [Link]() << endl;//asa afisam adresa vectorului
for (int i = 0; i < 3; i++)
{
cout << [Link]()[i] << "/";

}
cout << endl;
cout << [Link]() << endl;
cout << [Link]() << endl;
//cout << [Link]() << endl;//asa afisam adresa vectorului
for (int i = 0; i < [Link](); i++)
{
cout << [Link]()[i] << " | ";

}
cout << endl;
cout << "-------------------Sfarsit Getteri---------------------------" << endl;
cout << "------------------- Setteri---------------------------" << endl;
[Link]("Biogeologie");
/*string numeSetter;
do
{
cout << "Introduceti numele dorit: ";
cin >> numeSetter;
try {
[Link](numeSetter);
}
catch (exception ex)
{
cout << "Numele introdus este incorect!" << endl;
 }
} while ([Link]()<3);
*/
[Link](28);
int dataNoua[3] = { 32,05,2021 };
[Link](dataNoua);
float punctajeSubiecte[] = { -30,30,40 };
[Link](3, punctajeSubiecte);

cout << [Link]() << endl;

cout << [Link]() << endl;
cout << [Link]() << endl;
//cout << [Link]() << endl;//asa afisam adresa vectorului
for (int i = 0; i < 3; i++)
{
cout << [Link]()[i] << "/";

}
cout << endl;
cout << [Link]() << endl;
cout << [Link]() << endl;
//cout << [Link]() << endl;//asa afisam adresa vectorului
for (int i = 0; i < [Link](); i++)
{
cout << [Link]()[i] << " | ";

}
cout << endl;
cout << "-------------------Sfarsit Setteri---------------------------" << endl;
int data[3] = { 22,01,2021 };
float punctaje[] = { 31.5,11.5,40,50.5 };
Examen e1("Economie", "Doctorescu", 6, data, 3, punctaje);
cout << "-------------------Getteri---------------------------" << endl;
cout << [Link]() << endl;
cout << [Link]() << endl;
cout << [Link]() << endl;
//cout << [Link]() << endl;//asa afisam adresa vectorului
for (int i = 0; i < 3; i++)
{
cout << [Link]()[i] << "/";

}
cout << endl;
cout << [Link]() << endl;
cout << [Link]() << endl;
//cout << [Link]() << endl;//asa afisam adresa vectorului
for (int i = 0; i < [Link](); i++)
{
cout << [Link]()[i] << " | ";

}
cout << endl;
cout << "-------------------Sfarsit Getteri---------------------------" << endl;
cout << "------------------- Constructor de copiere---------------------------" << endl;
Examen e2 = e1;
//Examen e2(e1); -- ambele forme sunt corecte
cout << [Link]() << endl;
cout << [Link]() << endl;
cout << [Link]() << endl;
//cout << [Link]() << endl;//asa afisam adresa vectorului
for (int i = 0; i < 3; i++)
{
cout << [Link]()[i] << "/";

}
cout << endl;
cout << [Link]() << endl;
cout << [Link]() << endl;
//cout << [Link]() << endl;//asa afisam adresa vectorului
for (int i = 0; i < [Link](); i++)
{
cout << [Link]()[i] << " | ";

}
cout << endl;
cout << "-------------------Sfarsit Constructor de copiere---------------------------" << endl;
cout << "------------------- Operator = ---------------------------" << endl;
e1 = e1;
cout << [Link]() << endl;
cout << [Link]() << endl;
cout << [Link]() << endl;
//cout << [Link]() << endl;//asa afisam adresa vectorului
for (int i = 0; i < 3; i++)
{
cout << [Link]()[i] << "/";

}
cout << endl;
cout << [Link]() << endl;
cout << [Link]() << endl;
//cout << [Link]() << endl;//asa afisam adresa vectorului
for (int i = 0; i < [Link](); i++)
{
cout << [Link]()[i] << " | ";

}
cout << endl;
cout << "-------------------Sfarsit Operator = ---------------------------" << endl;
cout << "-------------------Metode ---------------------------" << endl;
cout << [Link]() << endl;
cout << [Link]() << endl;
cout << [Link]() << endl;
cout << [Link]() << endl;
cout << [Link]() << endl;
if ([Link]())
{
cout << "Examenul a fost picat!" << endl;
}
else
{
cout << "Examenul a fost promovat!" << endl;
}
if ([Link]())
{
cout << "Examenul a fost restanta!" << endl;
}
else
{
cout << "Examenul nu a fost restanta!" << endl;
}

[Link](99);
cout << [Link]() << endl;
cout << [Link]() << endl;
cout << [Link]() << endl;
//cout << [Link]() << endl;//asa afisam adresa vectorului
for (int i = 0; i < 3; i++)
{
cout << [Link]()[i] << "/";

}
 cout << endl;
cout << [Link]() << endl;
cout << [Link]() << endl;
//cout << [Link]() << endl;//asa afisam adresa vectorului
for (int i = 0; i < [Link](); i++)
{
cout << [Link]()[i] << " | ";

}
cout << endl;

cout << "----------------------------------------------------" << endl;

[Link](11.5);
cout << [Link]() << endl;
//cout << [Link]() << endl;//asa afisam adresa vectorului
for (int i = 0; i < [Link](); i++)
{
cout << [Link]()[i] << " | ";

}
cout << endl;
cout << "-------------------Sfarsit Metode ---------------------------" << endl;
cout << "-------------------Operatori ---------------------------" << endl;
cout << "-------------------Operator << ---------------------------" << endl;
cout << e1 << endl;
cout << "-------------------Operator >> ---------------------------" << endl;

/*cin >> e1;

cout << endl << endl;
cout << e1 << endl;*/
cout << "-------------------Operator () - operator functie ---------------------------" << endl;
cout << e1(4) << endl;
if (e1(4))
{
cout << "Examenul la " << [Link]() << " are mai mult de 4 subiecte!" <<
endl;
}
else
{
cout << "Examenul la " << [Link]() << " are mai putin de 4 subiecte!" <<
endl;

}
 cout << "-------------------Operator cast ---------------------------" << endl;
cout << string(e1) << endl;
cout << "-------------------Operator index -- op [] ---------------------------" << endl;
cout << e1[2] << endl;
e1[2] = 55.55;
cout << e1 << endl;

/*int poz;
do
{
cout << "Introduceti pozitia dorita: ";
cin >> poz;
try {
cout << e1[poz]<<endl;
}
catch (exception ex)
{
cout << "Pozitia introdusa este incorecta!" << endl;
}
} while (poz<0|| poz>= [Link]());*/

cout << "-------------------Operator relationali ---------------------------" << endl;

if (e1<3)
{
cout << "Examenul la " << [Link]() << " are mai putin de 3 subiecte!" <<
endl;
}
else
{
cout << "Examenul la " << [Link]() << " nu are mai putin de 3 subiecte!"
<< endl;

}
if (e1 > e2)
{
cout << "Nota la examenul e1 mai mare decat cea la examenul e2!" << endl;
}
else
{
cout << "Nota la examenul e1 mai mica decat cea la examenul e2!" << endl;
}

if (e1 == e2)
{
 cout << "Ambele examene sunt la acelasi profesor!" << endl;
}
else
{
cout << "Examenele nu sunt la acelasi profesor!" << endl;

}
if (~e1)
{
cout << "Nu are restanta!" << endl;
}
else
{
cout << "Are restanta!" << endl;

}
if (!e1)
{
cout << "Nu are restanta!" << endl;
}
else
{
cout << "Are restanta!" << endl;

}
if (!e1)
{
cout << "Nu are restanta!" << endl;
}
else
{
cout << "Are restanta!" << endl;

}
if (!e1)
{
cout << "Nu are restanta!" << endl;
}
else
{
cout << "Are restanta!" << endl;

}
cout << "-------------------Operator ++ post si pre ---------------------------" << endl;
 Examen e3 = e1++;
cout << e3 << endl << endl;
cout << e1 << endl << endl;

Examen e4 = ++e1;
cout << e4 << endl << endl;
cout << e1 << endl << endl;
cout << "-------------------Operator += si -= ---------------------------" << endl;
e1 += 40;
cout << e1 << endl;
e1 -= 40;
cout << e1 << endl;
cout << "-------------------Sfarsit Operatori ---------------------------" << endl;
cout << "-------------------Functie statica ---------------------------" << endl;
Examen vectExam[4];
vectExam[0] = e;
vectExam[1] = e1;
vectExam[2] = e2;
vectExam[3] = e3;
cout << Examen::medieNoteExamene(4, vectExam);