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
~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