PREGATIRE EXAMEN POO

Examen 18 iunie 2020 ora 8.00

Să se scrie o aplicație orientată obiect pentru gestiunea examenelor

unui student; este nevoie de cunoașterea disciplinei de examinare, a
notei și datei examenului. 

Pentru domeniul dat, să se definească clase cu membri de tip public,

private,  protected, const, static, care să conțină:
(1p) definirea corectă a clasei;
(2p) constructor cu parametri, default constructor, constructor de copiere,
destructor și operator<< pentru afișare (0.5 puncte/funcție/operator) ;
(2p) operator=, un operator pentru compararea între obiecte și încă doi
operatori adecvați domeniului (aritmetici sau cast sau indexare sau de alt
tip) (0.5 puncte/funcție/operator) ;
(1p) două funcții de tip accesor și două metode proprii clasei (0.25
puncte/funcție/operator);
 (1p) funcții sau operatori pentru salvarea și restaurarea obiectelor în/din
fișiere binare, permanente.
 (2p) Definiți încă o clasă, capabilă să gestioneze o colecție de obiecte
din prima clasă; operatorii += și -= vor asigura adăugarea / scoaterea
obiectelor din colecție. 
(1p) Transformați una din clase într-o clasă template sau instanțiați o clasă
template STL, pentru domeniul dat. 

Elementele definite vor fi punctate doar dacă sunt complete și au fost testate în main().
Recapitulare, exemplu cu angajat
#include <iostream>
#include <string>
using namespace std;

class Persoana {
protected:
string nume;
int varsta;
float salariu;
public:
Persoana() {
this->nume = "Test1";
this->varsta = 25;
this->salariu = 2500;
}

Persoana(string nume, int varsta,float salariu) {

this->nume = nume;
this->varsta = varsta;
this->salariu = salariu;
}

virtual void afisare() {

cout << " Persoana cu numele " << this->nume << " are
varsta de " << " ani si salariu "<<this->salariu<<" lei.\n";
}

virtual void getInfoPers() = 0;

};

class IMarireSalariu {
public:
virtual void maresteSalariu(int procent) = 0;
virtual float getSalariu()=0;
};

class Angajat:public Persoana,public IMarireSalariu {

private:
int vechime;

public:
Angajat() :Persoana() {
this->vechime = 10;
}

Angajat(int vechime,string nume, int varsta,float

salariu):Persoana(nume, varsta,salariu) {
this->vechime = vechime;
}

//overriding
 void afisare() override {
cout << "Nume " << this->nume << endl;
cout << "Varsta " << this->varsta << endl;
cout << "Salariu " << this->salariu << endl;
cout << "Vechime " << this->vechime << endl;
}

void afisare(string mesaj) {

cout <<endl<< mesaj<<endl;
this->afisare();
}

void getInfoPers() {
this->afisare();
}

float getSalariu() {
return this->salariu;
}

void maresteSalariu(int procent) {

this->salariu = (1 + (float)procent / 100)*this->salariu;
}
};

class Intern:public Persoana, public IMarireSalariu {

private:
int durata;
public:

Intern() {
this->durata = 3;
}
Intern(int durata,string nume, int varsta, float
salariu) :Persoana(nume,varsta, salariu) {
this->durata=durata;
}

void afisare() override {

cout << "Nume " << this->nume << endl;
cout << "Varsta " << this->varsta << endl;
cout << "Salariu " << this->salariu << endl;
cout << "Durata contract " << this->durata << endl;
}

void getInfoPers() {
this->afisare();
}

float getSalariu() {
return this->salariu;
}

void maresteSalariu(int procent) {

 this->salariu = (1 + (float)procent / 100)*this->salariu;
}

};

class Echipa {
private:
int nrPersoane;
Persoana** persoane;

public:
Echipa() {
this->nrPersoane = 0;
this->persoane = NULL;
}

Echipa(int nrPersoane, Persoana** persoane) {

this->nrPersoane = nrPersoane;
this->persoane = new Persoana*[nrPersoane];
for (int i = 0; i < this->nrPersoane; i++) {
this->persoane[i] = persoane[i];
}
}

~Echipa() {
if (this->persoane != NULL) {
delete[] this->persoane;
}
}

void afisare() {
cout << "Numar persoane " << this->nrPersoane << endl;
for (int i = 0; i < this->nrPersoane; i++) {
this->persoane[i]->afisare();
}
}

};

void main() {

Persoana* p;
//p->afisare();

Angajat a1;
a1.afisare();
a1.afisare("Afisez inca o data");
Angajat a2(5,"Test2", 26, 3000.0f);
a2.getInfoPers();

Intern i1;
i1.afisare();
i1.getInfoPers();
 //upcasting
Persoana* persoane[3] = { &a1,&a2,&i1 };

//downcasting
cout << ((Angajat*)persoane[1])->getSalariu();

Echipa e1(3, persoane);

e1.afisare();

IMarireSalariu* lista[3];
lista[0] = &a1;
lista[1] = &a2;
lista[2] = new Intern(1,"Test3",22,456.0f);

cout << "=============" << endl;

for (int i = 0; i < 3; i++) {
cout << "Salariul initial: " << lista[i]->getSalariu() <<
endl;
lista[i]->maresteSalariu(10);
cout << "Salariul marit: " << lista[i]->getSalariu() <<
endl;
}

SUPRAINCARCAREA OPERATORILOR, EXEMPLU MASINA

#include<iostream>
#include<string>
using namespace std;
class Masina {
private:
string marca;
int anFabricatie;
string tipCaroserie;
float pret;
int nrModele;
string* modele;
const int serie;
static unsigned int nrMasini;

public:
Masina() :serie(1) {
this->marca = "Dacia";
this->anFabricatie = 2012;
this->tipCaroserie = "berlina";
this->pret = 1234.5;
this->nrModele = 2;
this->modele = new string[nrModele];
for (int i = 0; i < this->nrModele; i++) {
this->modele[i] = "Model " + to_string(i + 200);
 }
this->nrMasini++;
}

Masina(string marca, int anFabricatie, string tipCaroserie, float

pret, int nrModele, string* modele) :serie(2) {
this->marca = marca;
this->anFabricatie = anFabricatie;
this->tipCaroserie = tipCaroserie;
this->pret = pret;
this->nrModele = nrModele;
this->modele = modele;
this->nrMasini++;
}

Masina(const Masina& masina) :serie(3) {

this->marca = masina.marca;
this->anFabricatie = masina.anFabricatie;
this->tipCaroserie = masina.tipCaroserie;
this->pret = masina.pret;
this->nrModele = masina.nrModele;
this->modele = new string[masina.nrModele];
for (int i = 0; i < masina.nrModele; i++) {
this->modele[i] = masina.modele[i];
}
this->nrMasini++;
}

Masina& operator=(const Masina& masina) {

this->marca = masina.marca;
this->anFabricatie = masina.anFabricatie;
this->tipCaroserie = masina.tipCaroserie;
this->pret = masina.pret;
this->nrModele = masina.nrModele;
this->modele = new string[masina.nrModele];
for (int i = 0; i < masina.nrModele; i++) {
this->modele[i] = masina.modele[i];
}
return *this;
}

string getMarca() {
return this->marca;
}

void setMarca(string marcaNoua) {

this->marca = marcaNoua;
}

int getAnFabricatie() {
return this->anFabricatie;
}
void setAnFabricatie(int anFabricatieNou) {
this->anFabricatie = anFabricatieNou;
}

string* getModele() {
return this->modele;
}

void setModele(string* modeleNoi, int nrModeleNoi) {

if (this->modele != NULL) {
delete[] this->modele;
}
this->nrModele = nrModeleNoi;
this->modele = new string[this->nrModele];
for (int i = 0; i < this->nrModele; i++) {
this->modele[i] = modeleNoi[i];
}
}

float getPret() {
return this->pret;
}

int getSerie() {
return this->serie;
}

static unsigned int getNrMasini() {

return nrMasini;
}

static void setNrMasini(unsigned int nrMasini) {

Masina::nrMasini = nrMasini;
}

~Masina() {
if (this->modele != NULL) {
delete[] this->modele;
}
Masina::nrMasini--;
}

friend ostream& operator<<(ostream& out, Masina& a) {

out << "Marca = " << a.marca << endl;
out << "An fabricatie = " << a.anFabricatie << endl;
out << "Tip caroserie = " << a.tipCaroserie << endl;
out << "Pret = " << a.pret << endl;
out << "Numar modele = " << a.nrModele << endl;
for (int i = 0; i < a.nrModele; i++) {
out << "\t " << a.modele[i] << endl;
}
out << "Serie = " << a.serie << endl;
out << "Numar masini = " << a.nrMasini << endl;
 return out;
}

friend istream& operator>>(istream& in, Masina& a) {

cout << "Dati marca: ";
in >> a.marca;
cout << "Dati anul fabricatiei: ";
in >> a.anFabricatie;
cout << "Dati tip caroserie: ";
in >> a.tipCaroserie;
cout << "Dati pret: ";
in >> a.pret;
cout << "Dati nr modele: ";
in >> a.nrModele;

if (a.modele != NULL) {
delete[] a.modele;
}
a.modele = new string[a.nrModele];
for (int i = 0; i < a.nrModele; i++) {
cout << "Dati modelul " << i + 1 << ": ";
in >> a.modele[i];
}

return in;
}

//supraincarcare operator +
//este folosit pentru a aduna o variabila de tip float cu un obiect
Masina
//folosit pentru a face operatii de forma: m1+250.0f
Masina operator+(float nr) {
Masina copie = *this;
copie.pret += nr;
return copie;
}

//folosit pentru a face operatii de forma: 250.0f + m1

friend Masina operator+(float valoare, Masina m) {
Masina copie = m;
copie.pret = valoare - copie.pret;
return copie;
}

//scade valoarea atributului anFabricatie cu valoarea lui nr

//folosit pentru a face operatii de forma: m1 - 2
Masina operator-(int nr) {
Masina copie = *this;
copie.anFabricatie -= nr;
return copie;
}

//scade din valoarea lui nr valoarea atributului anFabricatie

//folosit pentru a face operatii de forma: 2000 - m1
 friend Masina operator-(float nr, Masina m) {
Masina copie = m;
copie.anFabricatie = nr - copie.anFabricatie;
return copie;
}

friend float operator-=(float nr, Masina m) {

return nr - m.anFabricatie;

Masina operator+=(int nr) {

this->anFabricatie += nr;
return *this;
}

//supraincarcare == pentru a verifica daca 2 obiecte sunt egale

//folosit pentru a face operatii de forma: m1 == m2
bool operator==(Masina m) {
if (m.anFabricatie == this->anFabricatie &&
m.marca == this->marca) {
return true;
}
else {
return false;
}
}

//supraincarcare ! pentru a nega un obiect

//folosit pentru a face operatii de forma: !m1
bool operator!() {
if (this->modele != NULL) {
return false;
}
else {
return true;
}
}

//supraincarcare operator cast la float care face cast de la o

masina la pretul sau
//folosit pentru a face operatii de forma: (float)m1
explicit operator float() {
return this->pret;
}

//supraincarcarea operatorului de indexare care sa permita accesul

la unul din modele
//folosit pentru a face operatii de forma: m1[0]
string& operator[](int index)
{
if (index < 0 || index >= this->nrModele)
{
cout << "Index in afara limitelor!" << endl;
 throw new exception("Index in afara limitelor!");
}
else
{
return this->modele[index];
}
}

//supraincarcarea operatorului ++ (forma prefixata)

//Acesta va creste numarul de modele cu 1
//folosit pentru a face operatii de forma: ++m1
Masina& operator++()
{
//creez un vector nou de modele care sa includa si noul
model
string* modeleNoi = new string[this->nrModele + 1];
//copiez modelele existente
for (int i = 0; i < this->nrModele; i++)
{
modeleNoi[i] = this->modele[i];
}
//adaug noul model
modeleNoi[this->nrModele] = "Model nou adaugat";
//actualizez numarul de modele
this->nrModele++;
if (this->modele != NULL)
{
delete[] this->modele;
}
this->modele = modeleNoi;

return *this;
}

//supraincarcarea oepratorului ++ (forma postfixata)

//Acesta va creste numarul de modele cu 1
//folosit pentru a face operatii de forma: m1++
Masina operator++(int)
{
Masina copie = *this;
//creez un vector nou de modele care sa includa si noul
model
string* modeleNoi = new string[this->nrModele + 1];
//copiez modelele existente
for (int i = 0; i < this->nrModele; i++)
{
modeleNoi[i] = this->modele[i];
}
//adaug noul model
modeleNoi[this->nrModele] = "Model nou adaugat";
//actualizez numarul de modele
this->nrModele++;
if (this->modele != NULL)
 {
delete[] this->modele;
}
this->modele = modeleNoi;

return copie;
}

void afisare() {
cout << "Serie = " << this->serie << endl;
cout << "Nr masini = " << this->nrMasini << endl;
cout << "Marca = " << this->marca << endl;
cout << "An fabricatie = " << this->anFabricatie << endl;
cout << "Tip caroserie = " << this->tipCaroserie << endl;
cout << "Pret = " << this->pret << endl;
cout << "Nr modele = " << this->nrModele << endl;
for (int i = 0; i < this->nrModele; i++) {
cout << this->modele[i] << endl;
}
}
};

unsigned int Masina::nrMasini = 0;

int main() {

Masina m1;
Masina m2;
m1.afisare();
cout << "\n=============================\n";

cout << "Apel operator + de forma m1 + 20.0f\n";

m2 = m1 + 20.0f;
cout << "Pretul nou este = " << m2.getPret() << endl;
cout << "Apel operator + de forma 20.0f + m1\n";
m2 = 20.0f + m1;
cout << "Pretul nou este = " << m2.getPret() << endl;
cout << "\n=============================\n";

cout << "Apel operator - de forma m1 - 20\n";

m2 = m1 - 20;
cout << "An fabricatie nou este = " << m2.getAnFabricatie() <<
endl;
cout << "Apel operator - de forma 20 + m1\n";
m2 = 20 - m1;
cout << "An fabricatie nou este = " << m2.getAnFabricatie() <<
endl;
cout << "\n=============================\n";

string marca = "Dacia";

int anFabricatie = 2013;
int nrModele = 2;
float pret = 5236.2;
string tipCaroserie = "caroserie";
 string *modele = new string[nrModele];
for (int i = 0; i < nrModele; i++) {
modele[i] = "Model " + to_string(i + 300);
}
Masina m3(marca, anFabricatie, tipCaroserie, pret, nrModele,
modele);
cout << "Apel operator ==\n";
cout << "m1 este egal cu m3?\n";
Masina m4;
if (m1 == m3) {
cout << "m1 = m3\n";
}
else {
cout << "m1 != m3\n";
}
cout << "m1 este egal cu m4?\n";
if (m1 == m4) {
cout << "m1 = m4";
}
else {
cout << "m1 != m4";
}

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

cout << "Apel operator ! (not)\n";
if (!m2) {
cout << "m2 are atributul modele NULL\n";
}
else {
cout << "m2 are atributul modele diferit de NULL\n";
}
cout << "\n=============================\n";

cout << "Apel operator cast\n";

cout << (float)m1 << endl;
cout << "\n=============================\n";

cout << "Operator index\n";

cout<<"Apel m1 cu index = 0 " << m1[0]<<endl;
//Apelul de mai jos va arunca o exceptie
try {
cout << "Apel m1 cu index = 3 " << m1[3] << endl;
}
catch (exception* e) {
cout<< e->what() << " Exceptie prinsa\n";
}
catch (string& e) {
cout << e << " Exceptie prinsa\n";
}
catch (...) {
cout << "Exceptie prinsa\n";
}
cout << "\n=============================\n";
 cout << "Apel operator ++ (m1++)\n";
m1++;
cout << m1;
cout << "\n=============================\n";

cout << "Apel operator ++ (++m1)\n";

++m1;
cout << m1;

float a = 500.0f;
a -= m1;
cout << "Operator -= " << a;
m1 += 200;
return 0;
}

TEMA: INCEARCA SA REZOLVI SUBIECTUL DE PE PRIMA PAGINA

REZOLVARE:

#include<iostream>
#include<string>
#include<fstream>
#include<vector>
using namespace std;
class Examen
{
private:
const int idExamen;
protected:
string denumire;
int nota;
string data;
int subiecte;
float* punctajPeSubiect;
public:
static int contor;
Examen() :idExamen(contor++)
{
this->denumire = "";
this->nota = 1;
this->data = "01/06/2020";
this->subiecte = 0;
this->punctajPeSubiect = NULL;
}
Examen(string denumire, int nota, string data, int subiecte, float*
punctajPeSubiect) :idExamen(contor++)
{
if (denumire.size() > 2)
 {
this->denumire = denumire;
}
if (nota < 1)
this->nota = 1;
if (nota > 10)
this->nota = 10;
else
this->nota = nota;
if (data.size() == 8)
this->data = data;
this->subiecte = subiecte;
this->punctajPeSubiect = new float[this->subiecte];
for (int i = 0; i < this->subiecte; i++)
{
this->punctajPeSubiect[i] = punctajPeSubiect[i];
}

}
Examen(const Examen& e) :idExamen(e.idExamen)
{
if (e.denumire.size() > 2)
{
this->denumire = e.denumire;
}
if (e.nota < 1)
this->nota = 1;
if (e.nota > 10)
this->nota = 10;
else
this->nota = e.nota;
if (e.data.size() == 8)
this->data = e.data;
this->subiecte = e.subiecte;
this->punctajPeSubiect = new float[this->subiecte];
for (int i = 0; i < this->subiecte; i++)
{
this->punctajPeSubiect[i] = e.punctajPeSubiect[i];
}
}
Examen& operator =(const Examen& e)
{
if (this != &e)//evitarea auto-asignarii
{
if (this->punctajPeSubiect != NULL)
delete[]this->punctajPeSubiect;
if (e.denumire.size() > 2)
{
this->denumire = e.denumire;
}
if (e.nota < 1)
this->nota = 1;
if (e.nota > 10)
this->nota = 10;
 else
this->nota = e.nota;
if (e.data.size() == 8)
this->data = e.data;
this->subiecte = e.subiecte;
this->punctajPeSubiect = new float[this->subiecte];
for (int i = 0; i < this->subiecte; i++)
{
this->punctajPeSubiect[i] =
e.punctajPeSubiect[i];
}
return *this;
}
}
~Examen()
{
if (this->punctajPeSubiect != NULL)
delete[]this->punctajPeSubiect;
cout << "S-a apelat destructorul" << endl;
}
friend ostream& operator<<(ostream& out, const Examen& e)
{
out << "Examenul "<<e.idExamen << " la disciplina " <<
e.denumire << " a avut nota " << e.nota << ", in data de " << e.data << "
Punctajele sunt: ";
for (int i = 0; i < e.subiecte; i++)
{
out << e.punctajPeSubiect[i] << " ";
}
out << endl;
return out;
}
explicit operator string()
{
return this->denumire;
}
bool operator >(int prag)
{
return this->nota > prag;
}
string getDenumire()
{
return this->denumire;
}
int getNrSubiecte()
{
return this->subiecte;
}
float totalPunctaj()
{
float total = 0;
for (int i = 0; i < this->subiecte; i++)
{
total = total + punctajPeSubiect[i];
 }
return total;
}
float SubiectCuPunctajulCelMaiMare()
{
float maxim = this->punctajPeSubiect[0];
for (int i = 0; i < this->subiecte; i++)
{
if (maxim < this->punctajPeSubiect[i])
maxim = this->punctajPeSubiect[i];
}
return maxim;
}
void salveaza_in_fisier(ofstream& out)
{

int dimensiuneDenumire = denumire.size();

out.write((char*)&dimensiuneDenumire, sizeof(int));
out.write(denumire.c_str(), dimensiuneDenumire + 1);
out.write((char*)&nota, sizeof(int));
int dimensiuneData = data.size();
out.write((char*)&dimensiuneData, sizeof(int));
out.write(data.c_str(), dimensiuneData + 1);
out.write((char*)&subiecte, sizeof(int));
for (int i = 0; i < this->subiecte; i++)
out.write((char*)&punctajPeSubiect[i], sizeof(int));

}
void restaureaza_din_fisier(ifstream& in)
{

if (punctajPeSubiect != NULL)
delete[]punctajPeSubiect;

int dimensiuneDenumire = 0;
in.read((char*)&dimensiuneDenumire, sizeof(int));

char* aux = new char[dimensiuneDenumire + 1];

in.read(aux, dimensiuneDenumire + 1);
denumire = aux;

in.read((char*)&nota, sizeof(int));

int dimData = 0;
in.read((char*)&dimData, sizeof(int));
char* aux_data = new char[dimData + 1];
in.read(aux_data, dimData + 1);
data = aux_data;

in.read((char*)&subiecte, sizeof(int));
this->punctajPeSubiect = new float[this->subiecte];
for (int i = 0; i < subiecte; i++)
 {
in.read((char*)&punctajPeSubiect[i], sizeof(int));
}

}
};

int Examen::contor = 1;
class Student
{
string nume;
Examen** vectorExamene;
int nrExamene;

public:
Student()
{
this->nume = "";
this->vectorExamene = NULL;// Examen* joaca rolul lui int
=> Examen** ar fi un int*
this->nrExamene = 0;
}
Student(string nume, int nrExamene, Examen** vectorExamene)
{
this->nume = nume;
this->nrExamene = nrExamene;
this->vectorExamene = new Examen * [this->nrExamene];
for (int i = 0; i < this->nrExamene; i++)
{
this->vectorExamene[i] = vectorExamene[i];
}
}
Student(const Student& s)
{
this->nume = s.nume;
this->nrExamene = s.nrExamene;
this->vectorExamene = new Examen * [this->nrExamene];
for (int i = 0; i < this->nrExamene; i++)
{
this->vectorExamene[i] = s.vectorExamene[i];
}
}
Student& operator =(const Student& s)
{

if (this->vectorExamene != NULL)
delete[] this->vectorExamene;
this->nume = s.nume;
this->nrExamene = s.nrExamene;
this->vectorExamene = new Examen * [this->nrExamene];
for (int i = 0; i < this->nrExamene; i++)
{
this->vectorExamene[i] = s.vectorExamene[i];
}
 return *this;
}
friend ostream& operator<<(ostream& out, Student& s)
{
out << s.nume << endl;
out << s.nrExamene << endl;
for (int i = 0; i < s.nrExamene; i++)
{
out << *s.vectorExamene[i] << endl;
}
return out;
}
int getnrExamene()
{
return this->nrExamene;
}

Examen** getvectorExamene()
{
return this->vectorExamene;
}
~Student()
{
if (this->vectorExamene != NULL)
delete[] this->vectorExamene;
}
Student& operator +=(Examen& e)
{
Student temp = *this;
this->vectorExamene = new Examen * [this->nrExamene + 1];
for (int i = 0; i < this->nrExamene; i++)
{
this->vectorExamene[i] = temp.vectorExamene[i];
}
this->vectorExamene[this->nrExamene] = &e;
this->nrExamene++;
return *this;
}
Student& operator -=(Examen& e)
{
Student temp = *this;
this->vectorExamene = new Examen * [this->nrExamene];
int i = 0;
int j = 0;
while ((i < this->nrExamene) && (j < this->nrExamene))
{
if (temp.vectorExamene[i]->getDenumire() !=
e.getDenumire())
{
this->vectorExamene[j] =
temp.vectorExamene[i];
j++;
}
i++;
 }
this->nrExamene = j;
return *this;

}
};
void main()
{
float punctaj[] = { 1.5,3,3.5,2 };
Examen e1;
cout << e1 << endl;
Examen e2("POO", 9, "18/06/2020", 4, punctaj);
Examen e12("SDD", 9, "18/06/2020", 4, punctaj);
Examen e13("PAW", 9, "18/06/2020", 4, punctaj);
Examen e14("PEAG", 9, "18/06/2020", 4, punctaj);
cout << e2 << endl;
Examen e3 = e2;
cout << e3 << endl;
e1 = e2;
cout << e1 << endl;
string numeExamen = (string)e2;
cout << numeExamen << endl;
if (e2 > 5)
{
cout << "Studentul a promovat examenul!" << endl;
}
else
{
cout << "Studentul nu a promovat examenul!" << endl;
}
cout << e2.getDenumire() << endl;
cout << e2.getNrSubiecte() << endl;
cout << e2.totalPunctaj() << endl;
cout << e2.SubiectCuPunctajulCelMaiMare() << endl;
string fisierBinar;
cout << "Introduceti nuemele fisierului binar: ";
cin >> fisierBinar;
fisierBinar = fisierBinar + ".bin";
ofstream outBinaryProiect(fisierBinar, ios::out | ios::binary);
if (outBinaryProiect.is_open()) {
e2.salveaza_in_fisier(outBinaryProiect);
cout << "e2 a fost scris in fisierul binar.\n";
outBinaryProiect.close();
}
cout << "\n\nCitire si afisare din fisier binar: \n";
Examen e6;
cout << e6 << endl;
ifstream inBinaryProiect(fisierBinar, ios::in | ios::binary);
if (inBinaryProiect.is_open()) {
e6.restaureaza_din_fisier(inBinaryProiect);
cout << "\n\ne6 citit din fisierul binar: \n" << e6 <<
endl;
inBinaryProiect.close();
}
 cout << "\n\n Student\n\n";
Examen e7;
Examen** lista = new Examen * [3];
lista[0] = &e14;
lista[1] = &e12;
lista[2] = &e13;
Student s1;
Student s2("Andrei", 3, lista);
Student s3 = s2;
cout << "Constructor de copiere: " << s3 << endl;
s1 = s2;
cout << "Op= : " << s1 << endl;
cout << s2 << endl;
s2 += e6;
cout << s2 << endl;
s2 -= e7;
cout << s2 << endl;
s2 -= e14;
cout << s2 << endl;

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

vector<Examen*> vectExamen;
vectExamen.push_back(&e12);
vectExamen.push_back(&e13);
vectExamen.push_back(&e14);
vector<Examen*>::iterator it;
for (it = vectExamen.begin(); it != vectExamen.end(); it++)
{
cout << **it << endl;
}
}

BAFTA!