cout > P;cout > Q;

Polinom* R = P + Q;cout

/* Clasa Complex implementeaza operatii cu numere complexe. */class Complex{

/* atribut reprezentand partea reala */float re;/* atribut reprezentand partea imaginara */float im;//ambele atribute sunt private, nu sunt accesibile din exterior

public:/** Constructor cu ambii parametri luand valori implicite* @param r - partea reala* @param i - partea imaginara*/Complex(float r = 0.0, float i = 0.0) {

re = r; im = i;};

/** Constructor de copiere.* @param c - referinta catre un alt numar complex*/Complex(Complex& c) {

re = c.re; im = c.im;};

/** Destructor. Este vid deoarece nu am alocat nici* o zona de memorie in constructor.*/~Complex(){ };

/* Metode de tip getter si setter. Permit accesul la membrii privati. */

/** Intoarce valoarea atributului re.* @return - partea reala a numarului complex*/float getReal() { return re; };

/** Schimba valoarea atributului re.* @param - r - partea reala*/void setReal(float r) { re = r; };

/** Intoarce valoarea atributului im.* @return - partea imaginara a numarului complex*/float getImag() { return im; };

69

/** Schimba valoarea atributului im.* @param i - partea imaginara*/void setImag(float i) { im = i;};

/** Intoarce valoarea modulului.* @return - modulul numarului complex.*/float modul() { return sqrt(re * re + im * im);};

void operator= (Complex &c);Complex operator+ (Complex& c);Complex operator- (Complex& c);Complex operator* (Complex& c);Complex operator~ ();

friend ostream& operator> (istream& is,Complex& c);

};

/** Operatorul de copiere.* @param c - referinta catre un numar complex care se va copia*/void Complex::operator= (Complex& c) {re = c.re;im = c.im;

}

/** Operatorul de adunare: calculeaza suma dintre obiectul caruia i se transmite* mesajul (obiectul caruia ii este este invocata metoda operator+) si numarul* complex transmis ca parametru c.* @param c - referinta catre cel de-al doilea operand al adunarii* @return - numarul complex rezultat in urma adunarii*/Complex Complex::operator+ (Complex& c) {return Complex(re + c.re, im + c.im);

}

/** Operatorul de scadere: primul operand este determinat de this iar cel de-al* doilea operand este determinat de c.* @param c - referinta catre cel de-al doilea operand al scaderii* @return - numarul complex rezultat in urma scaderii*/Complex Complex::operator- (Complex& c) {return Complex(re - c.re, im - c.im);

}

70

/** Operatorul de inmultire.* @param c - referinta catre cel de-al doilea operand al inmultirii* @return - numarul complex rezultat in urma inmultirii*/Complex Complex::operator* (Complex& c) {return Complex(re * c.re - im * c.im, re * c.im + im * c.re);

}

/** Operatorul de conjugare: calculeaza inversul numarul complex* referit de catre obiectul curent.* @return - opusul fata de operatia de adunare.*/Complex Complex::operator~() {return Complex(re, -im);

}

/** Operatorul

e = e * ~e; //apel operator~, constructor, operator*, constructor, operator=cout

}/** Operatorul d; //apel operator ">>" supraincarcatcout

~BigDecimal();

void readNumber (istream&);void writeNumber (ostream&);BigDecimal add (BigDecimal&);int compareTo (BigDecimal&);

};

Rezolvare:

2. Sa se implementeze clasa urmatoare ce reprezinta tipul multime si operatii cu acesta:

/* Clasa ce reprezinta multimi de numere intregi. */class Multime {

/* tablou alocat dinamic */int* elem;/* numarul de elemente ale multimii */int number;

public:/** Constructor cu parametri.* @param number - numarul de elemente* @param elem - tablou cu elementele multimii*/Multime(int number, int* elem);

/** Constructor de copiere.* @param m - referinta catre un obiect de tip Multime*/Multime(Multime& m);

/* Destructorul */~Multime();

/** Operatorul de copiere =.* @param m -* @return -*/Multime& operator =(Multime& m);

/** Operatorul de adunare calculeaza reuniunea a doua multimi:* primul operand este determinat de this iar cel de-al doilea operand* este determinat de parametrul m.* @param r - referinta catre cel de-al doilea operand al reuniunii* @return - multimea rezultata in urma operatiei de reuniune multimi*/

76

Multime operator +(Multime& m);

/** Operatorul de scadere calculeaza diferenta dintre doua multimi:* primul operand este determinat de this iar cel de-al doilea operand* este determinat de parametrul m.* @param r - referinta catre cel de-al doilea operand al diferentei* @return - multimea rezultata in urma diferentei multimilor*/Multime operator -(Multime& m);

/** Operatorul de inmultire calculeaza intersectia dintre doua multimi:* primul operand este determinat de this iar cel de-al doilea operand* este determinat de parametrul m.* @param r - referinta catre cel de-al doilea operand al intersectiei* @return - multimea rezultata in urma intersectiei multimilor*/Multime operator *(Multime& m);

/** Operatorul

}public:float& operator[](int i) {return elemente[i];

};

friend class Matrice;};

class Matrice {Linie** plinii;int nlin, ncol;

public:Matrice(int lin, int col);Matrice(Matrice& m);~Matrice();

Matrice& operator=(Matrice& m);Matrice operator+(Matrice& m);Matrice operator-(Matrice& m);Matrice operator*(Matrice& m);

Linie& operator[](int i) {return *plinii[i];

};

friend ostream& operator> (istream& is, Matrice& m);

};

Rezolvare: Continutul fisierului matrice.cpp este:

#include

using namespace std;

class Linie {/* tablou cu elemente numere reale */float *elemente;/* numarul de elemente de pe o linie */int nrElemente;

/** Constructor privat: nu poate fi apelat din afara clasei* decat din functii friend. Aloca spatiu pentru m numere* reale si le initializeaza cu 0.* @param m - numarul de elemente ale unei linii*/Linie(int m) {nrElemente = m;elemente = new float[nrElemente];memset(elemente, 0, sizeof(float) * nrElemente);

78

};

/** Constructor de copiere.* @param linie - referinta catre linia ale carei valori sunt copiate*/Linie(Linie& linie) {nrElemente = linie.nrElemente;elemente = new float[nrElemente];memcpy(elemente, linie.elemente, sizeof(float) * nrElemente);

};

/* Destructorul: elibereaza spatiul de memorie alocat in constructor. */~Linie() {delete[] elemente;

}public:/** Intoarce valoarea elementului de pe pozitia i.* @param i - indicele pozitiei* @return - valoarea elementului de pe pozitia indicata.*/float& operator[](int i) {return elemente[i];

};

/* declaram clasa Matrice, clasa prietena clasei Linie. */friend class Matrice;

};

/* Clasa Matrice modeleaza matrici si operatii cu acestea. */class Matrice {

/* adresa unei zone de memorie ce contine pointeri la linii */Linie **plinii;/* numarul de linii al matricii */int nlin;/* numarul de coloane al matricii */int ncol;

public:/** Constructor cu parametri.* @param lin - numarul de linii* @param col - numarul de coloane*/Matrice(int lin, int col);

/** Constructor de copiere.* @param m - referinta catre un obiect de tip Matrice*/Matrice(Matrice& m);

79

/* Destructorul */~Matrice();

/** Operatorul de copiere =.* @param m - referinta catre un obiect de tip Matrice* @return - referinta catre obiectul curent*/Matrice& operator=(Matrice& m);

/** Operatorul de adunare a doua matrici: primul operand este determinat* de this iar al doilea operand este determinat de parametrul m.* @param m - referinta catre al doilea operand* @return - un obiect de tip Matrice rezultat in urma adunarii*/Matrice operator+(Matrice& m);

/** Operatorul de scadere a doua matrici.* @param m - referinta catre al doilea operand* @return - un obiect de tip Matrice rezultat in urma scaderii*/Matrice operator-(Matrice& m);

/** Operatorul de inmultire a doua matrici: primul operand este determinat* de this iar al doilea operand este determinat de parametrul m.* @param m - referinta catre al doilea operand* @return - un obiect de tip Matrice rezultat in urma inmultirii*/Matrice operator*(Matrice& m);

/** Operatorul [] este folosit pentru a determina o linie a matricii.* @param i - indicele unei linii a matricii* @return - referinta catre linia i a matricii*/Linie& operator[](int i) {return *plinii[i];

};

/** Operatorul

* @param is - referinta catre stream-ul de intrare* @param c - referinta catre o matrice* @return - referinta catre stream-ul de intrare*/friend istream& operator>> (istream& is, Matrice& m);

};

Matrice::Matrice(int lin, int col) {nlin = lin;ncol = col;plinii = (Linie **)new char [sizeof(Linie*) * nlin];

for (int i = 0; i < lin; i++)plinii[i] = new Linie(col);

}

Matrice::Matrice(Matrice& m) {nlin = m.nlin;ncol = m.ncol;plinii = (Linie **)new char [sizeof(Linie*) * nlin];

for (int i = 0; i

Matrice t(nlin, ncol);

if (nlin == m.nlin && ncol == m.ncol)for (int i = 0; i < nlin; i++)for (int j = 0; j

void main() {Matrice a(2,3);

cout > a;

Matrice b = a;Matrice c(3,3);c = a + b;cout > (cin, a); suprancarcatapentru parametri de tip istream& si Matrice&:

83

Fig. 4.2: Mesajele afisate n consola aplicatiei pentru proiectul Matrice

istream& operator>> (istream& is, Matrice& m) {for (int i = 0; i < m.nlin; i++)for (int j = 0; j < m.ncol; j++) {cout

plinii = (Linie **)new char [sizeof(Linie*) * nlin];

for (int i = 0; i

for (i = 0; i < nlin; i++)plinii[i] = new Linie(*a.plinii[i]);

return *this;}

Mai ntai se verifica sa nu avem situatii de forma a = a (if (this == &a)), caz n carenu se realizeaza nici o operatie. Apoi se elibereaza spatiul ocupat de obiectele linii sispatiul ocupat de tabloul de pointeri catre obiectele linie:

for (int i = 0; i < nlin; i++)if (plinii[i])delete plinii[i];

if (plinii)delete[] plinii;

Se aloca spatiul necesar pentru a pastra matricea cu noile dimensiuni, si se copiaza valo-rile fiecarei linii n parte prin intermediul constructorului de copiere, new Linie(*a.plinii[i]):

plinii = (Linie **)new char [sizeof(Linie*) * nlin];for (i = 0; i < nlin; i++)plinii[i] = new Linie(*a.plinii[i]);

cout

return availableAmount;}

/** Intoarce codul de identificare al unui card.*/int getCode(void) {

return code;}

};#endif //__PrepayCard__H_

Continutul fisierului testdist.cpp este:

#include "Coffemachine.h"

void main(void) {CoffeMachine distrib(0x1001);

Display* disp = new Display("Toshiba");

distrib.changeDisplay(*disp);

PrepayCard card1(101, 5);

distrib.insertCard(&card1);distrib.prepareCoffe();distrib.returnCard();

distrib.activate(10);

PrepayCard* card2;

card2 = new PrepayCard(102, 3);

distrib.insertCard(card2);distrib.prepareCoffe();distrib.prepareCoffe();distrib.returnCard();

}

Exercitii:

1. Sa se realizeze un program ce gestioneaza componenta unei echipe de fotbal: o echipaeste compusa din jucatori, un jucator fiind identificat prin numele sau si numarul pecare l poarta pe tricou (acest numar este unic n cadrul unei echipe).

Continutul fisierului jucator.h este:

#ifndef __JUCATOR__H_#define __JUCATOR__H_

#include #include

96

using namespace std;

#define MAX_NUME 15 //numarul de caractere maxim al numelui

class Jucator {/* numele unui jucator */char* nume;/* numarul de pe tricou */int nrTricou;

public:Jucator();Jucator(char* id, int nr);Jucator(Jucator& juc);

~Jucator();

char* getNume();int getNrTricou();

void citire(istream& in);void afisare(ostream& out);

};#endif //__JUCATOR__H_

Continutul fisierului jucator.cpp este:

#include "jucator.h"

/* Constructor fara parametrii pentru clasa Jucator. */Jucator::Jucator() {char tmpNume[] = "Unknown";

nume = new char [strlen(tmpNume) + 1];strcpy(nume, tmpNume);

nrTricou = -1;}

/*** Constructor obisnuit:* @param id - numele studentului* @param nr - numarul aflat pe tricoul cu care joaca*/Jucator::Jucator(char *id, int nr) {nume = new char [strlen(id) + 1];strcpy(nume, id);

nrTricou = nr;}

/**

97

* Constructor de copiere.* @param juc - referinta la un obiect de tip Jucator*/Jucator::Jucator(Jucator& juc) {nume = new char [strlen(juc.nume) + 1];strcpy(nume, juc.nume);

nrTricou = juc.nrTricou;}

/* Destructorul clasei Jucator. */Jucator::~Jucator() {delete[] nume;

}

/* Functie de tip "getter": intoarce valoarea variabilei interne nume.*/char* Jucator::getNume() {return nume;

}

/* Functie de tip "getter": intoarce valoarea variabilei interne nrTricou.*/int Jucator::getNrTricou() {return nrTricou;

}

/*** Realizeaza citirea datelor de identificare ale unui jucator* dintr-un flux de intrare.* @param in - referinta la un obiect de tip istream*/void Jucator::citire(istream& in) {char buffer[80];

in >> buffer;if (nume != NULL)delete nume;

nume = new char [strlen(buffer) + 1];strcpy(nume, buffer);

in >> nrTricou;}

/*** Afiseaza continutul (datele de identificare) ale unui jucator.* @param out - referinta la un obiect de tip ostream ce reprezinta* fluxul de iesire*/void Jucator::afisare(ostream& out) {out

#ifndef __ECHIPA__H_#define __ECHIPA__H_

#include "jucator.h"

class Echipa {/* numele echipeu */char nume[MAX_NUME];/* un tablou de pointeri la jucatori */Jucator** membrii;/* numarul de membri ai echipei */int nrMembri;

public:Echipa(char*, int);Echipa(Echipa& );

~Echipa();

void setJucator(int , Jucator&);Jucator& getJucator(int);Jucator* getTricou(int);

void citire(istream&);void afisare(ostream&);

};

#endif //__ECHIPA__H_

Continutul fisierului echipa.cpp este:

#include "echipa.h"

/*** Constructor obisnuit:* @param id - numele echipei* @param nr - numarul de jucatori din echipa*/Echipa::Echipa(char* id, int nr = 11) {nrMembri = nr;membrii = (Jucator**) new Jucator* [nrMembri];

strcpy(nume, id);}

/*** Constructor de copiere.* @param team - referinta la un obiect de tip Echipa*/Echipa::Echipa(Echipa& team) {int i;

nrMembri = team.nrMembri;

99

membrii = (Jucator**) new Jucator* [nrMembri];

for (i = 0 ; i < nrMembri; i++)membrii[i] = new Jucator(*team.membrii[i]);

strcpy(nume, team.nume);}

/* Destructorul clasei Echipa. */Echipa::~Echipa() {delete[] membrii;

}

/*** Intoarce jucatorul ce se afla pe o anumita pozitie in cadrul* echipei.* @param poz - pozitia in cadrul echipei* @return - referinta catre obiectul de tip Jucator aflat pe pozitia* specificata in cadrul vectorul cu jucatori*/Jucator& Echipa::getJucator(int poz) {return *membrii[poz];

}

/*** Intoarce jucatorul ce joaca purtand un anumit numar pe tricou.* @param nrTricou - numarul* @return - adresa unui obiect de tip Jucator* NULL daca nu exista nici un jucator care* sa poarte numarul specificat*/Jucator* Echipa::getTricou(int nrTricou) {int i;

for (i = 0; i < nrMembri; i++)if (nrTricou == membrii[i]->getNrTricou())return membrii[i];

return NULL;}

/*** Seteaza obiectul de tip Jucator ce se afla in echipa* pe o anumita pozitie.* @param poz - pozitia in cadrul echipei* @param juc - referinta catre un obiect de tip Jucator*/void Echipa::setJucator(int poz, Jucator& juc) {if (0

}/*** Citeste un numar specificat de membrii/jucatori* din care se compune echipa.* @param in - referinta catre un flux de instrare*/void Echipa::citire(istream& in) {int i;

for (i = 0; i < nrMembri; i++) {membrii[i] = new Jucator();membrii[i]->citire(in);

}}

/*** Afiseaza un numar specificat de membrii/jucatori* din care se compune echipa.* @param out - referinta catre un flux de iesire*/void Echipa::afisare(ostream& out) {int i;

for (i = 0; i < nrMembri; i++)membrii[i]->afisare(out);

}

Continutul fisierului testteam.cpp este:

#include "echipa.h"

void main(void) {Echipa team("Avantul", 4);Jucator juc;int p;

team.citire(cin);team.afisare(cout);cout p;juc.citire(cin);

team.setJucator(p, juc);team.afisare(cout);

}

2. Sa se implementeze o ierarhie de clase compusa din clasele Publicatie, Carte.

Informatiile aferente publicatiilor unei biblioteci sunt:

101

titlu publicatie (sir de 20 caractere); nume editor/editura (sir de 20 caractere); anul publicarii; cota publicatiei.

Clasa Carte va fi derivata din clasa Publicatie, si va avea n plus:

nume autor(i); cod ISBN; greutate.

Clasa Revista va fi derivata din clasa Publicatie. Sa se puna n evidenta metodespecifice pentru accesul la membrii acestor clase, constructori, destructori, mostenireametodelor, redefinirea unei metode mostenite.

3. Sa se scrie un program care sa gestioneze publicatiile dintr-o biblioteca, utilizandu-seierarhia de clase implementata n cadrul problemei anterioare.

Operatii:

actualizare publicatie (modificare nume client care a mprumutat-o si/sau numarcod)

adaugare publicatie noua; stergere publicatie din biblioteca; afisarea tuturor cartilor; afisarea cartilor mprumutate de un client; afisarea cartilor apartinand unui anumit domeniu sortate dupa nume autor.

Revista.

102