//Sa se construiasca clasa Medici cu urmatoarele grupuri private:nume(char),spec

ializare(char),comision(int).Sa se defineasca urmatoarele:clasa simpla cu atribu

te private / protected si metode de acces,
//lucrul cu memorie alocata dinamic(alocare memorie in constructor, constructor
de copiere, operator de atribuire si destructor pentru dealocarea memoriei) si s
a se implementeze o clasa colectie redimensionabila
//cu iterator capabila sa gestioneze obiectele definite anterior.Sa se implement
eze un operator "++" care sa mareasca comisionul cu valoarea numerica primita, u
n operator ">>" pentru consola.Sa se utilizeze mostenira
//pentru crearea de clase aditionale si sa se utilizeze in cadrul colectiei, sa
se implementeze lucrul cu fisiere binare(citire / scriere) in cadrul colectiei
si sa se implementeze o clasa template. //Sa se scrie programul principal care sa construiasca un vector retete cu datel
e citite de la tastatura si sa afiseze costul total.
#include<iostream>
using namespace std;
class Medici {
private:
char* nume;
char* specializare;
int comision;
public:
//constructor cu parametrii
Medici(char*n, char*s, int c)
{
this->nume = new char[strlen(n) + 1];
strcpy(nume, n);
this->specializare = new char[strlen(s) + 1];
strcpy(specializare, s);
this->comision = c;
}
//constructor de copiere
Medici(Medici &p)
{
this->nume = new char[strlen(p.nume) + 1];
strcpy(nume, p.nume);
this->specializare = new char[strlen(p.specializare) + 1];
strcpy(specializare, p.specializare);
this->comision = p.comision;
}
//operator de atribuire
Medici operator=(Medici s)
{
delete[] this->nume;
delete[] this->specializare;
this->nume = new char[strlen(s.nume) + 1];
strcpy(nume, s.nume);
this->specializare = new char[strlen(s.specializare) + 1];
strcpy(specializare, s.specializare);
this->comision = s.comision;
}
//destructor
~Medici()
{
delete[] this->nume;
delete[] this->specializare;
}
//metode de acces
char* getnume()
{
return this->nume;
}
void setnume(char* v)
{
delete[] this->nume;
this->nume = new char[strlen(v) + 1];
strcpy(nume, v);
}
char* getspecializare()
{
return this->specializare;
}
void setspecializare(char* t)
{
delete[] this->specializare;
this->specializare = new char[strlen(t) + 1];
strcpy(specializare, t);
}
int getcomision()
{
return this->comision;
}
void setcomision(int c)
{
this->comision = c;
}
//supraincarcarea operatorului ++
Medici &operator ++ (int comision)
{
Medici temp = *this;
comision = comision + 1;
return temp;
}

class reteta
{
char boala[100];
public:
reteta (char * boala)
{
strcpy(this->boala, boala);
}
char* getboala()
{
return boala;
}
virtual double getcost() = 0;
}
void afisare (reteta*r)
{
cout << r->getboala() << " ";
cout << r->getcost() << endl;
}
class retetacompensata : public reteta
{
int valoare;
double discount;
public:
retetacompensata(char*boala, int v, double d) :reteta(boala)
{
valoare = v;
discount = d;
}
double getcost()
{
return valoare*discount;
}
template<class T>
class vector
{
private: T*v;
int n;
public: vector(int nr)
{
this->n = nr;
this->v = new T[nr];
}
Vector()
{
this->n = -1;
this->v = NULL;
}
vector(vector&p)
{
this->n = p.n;
this->v = new T[p.n];
for (int i = 0; i < p.n; i++)
v[i] = p.v[i];
}
vector operator=(vector s)
{
delete[] this->v;
this->n = s.n;
this->v = new T[s.n];
for (int i = 0; i < s.n; i++)
v[i] = s.v[i];
return*this;
}
~vector()
{
delete[]this->v;
}
int get_nr_elem()
{
return n;
}
int get_elem(int i)
{
return this->v[i];
}
void set_el(int i, int val)
{
this->v[i] = val;
}
T&operator[] (int i)
{
{ if ((i>0) && (i<n)) return v[i];
}
Vector operator +=(T val)
{
this->n++; this->v[n - 1]val;
return *this;
}



class Iterator
{
private:Vector<Medici> *m;
int poz;
friend Vector;
Iterator(int n, Vector<Medici> *o)
{
this->m = o;
this->poz = n;
}
public:
Medici get_val()
{
return (*m)[poz];
}
void next()
{
poz++;
}
bool operator !=(Medici s)
{
return ((m != s.m) || (poz != s.poz));
}
Iterator begin()
{
return Iterator(0, this);
}
Iterator end()
{
return Iterator(n, this);
}