Programare orientată pe obiecte Laborator 3

Laborator 3

1. Să se implementeze clasa următoare:

class Multime {
int* date;
int dim;//dimensiunea
int n;//numarul curent de elemente
public:
Multime();
Multime(int);
Multime(const Multime&);
~Multime();
void adauga(int);
void extrage(int);
Multime& operator+=(const int&);
Multime& operator+=(const Multime&);
Multime& operator-=(const int&);
Multime& operator=(const Multime&);
friend ostream& operator<<(ostream&, const Multime&);
friend istream& operator>>(istream&, Multime&);
};

Multime::Multime() {
dim = 10;
date = new int[dim];
n = 0;
}

Multime::Multime(int d) {
dim = d;
date = new int[dim];
n = 0;
}

Multime::Multime(const Multime& M) {
dim = [Link];
n = M.n;
date = new int[dim];
for (int i = 0; i < n; i++) {
date[i] = [Link][i];
}
}

Multime::~Multime() {
if (date)delete[] date;
}

void Multime::adauga(int v) {
if (n == dim) {

1
Programare orientată pe obiecte Laborator 3

cout << "Multimea este plina!" << endl;

return;
}
for (int i = 0; i < n; i++)
if (date[i] == v) return;
date[n++] = v;
}

void Multime::extrage(int v) {
for (int i = 0; i < n; i++)
if (date[i] == v) {
for (int j = i; j < n - 1; j++)
date[j] = date[j + 1];
n--;
}
}

Multime& Multime::operator+=(const int& i) {

adauga(i);
return *this;
}
Multime& Multime::operator+=(const Multime& M) {
for(int i=0;i<M.n;i++)
adauga([Link][i]);
return *this;
}
Multime& Multime::operator-=(const int& i) {
extrage(i);
return *this;
}
Multime& Multime::operator=(const Multime& M) {
if (this != &M) {
if (date)delete[] date;
dim = [Link];
n = M.n;
date = new int[dim];
for (int i = 0; i < n; i++) {
date[i] = [Link][i];
}
}
return *this;
}
ostream& operator<<(ostream& out, const Multime& M) {
cout << "{";
for (int i = 0; i < M.n; i++)
cout << " " << [Link][i];
cout << " }" << endl;
return out;
}
istream& operator>>(istream& in, Multime& M){
M.n = 0;
char linie[100], * temp;
[Link](linie, 100);
temp = strtok(linie, " ");
while (temp != NULL) {
[Link](atoi(temp));
temp = strtok(NULL, " ");
}

2
Programare orientată pe obiecte Laborator 3

return in;
}
int main() {
Multime M,N;
M += 13;//in loc de adauga sa avem +=
M -= 2;//in loc de extrage sa avem -=
M += 1;
M += 2;
M += 3;
N += 33;
N += M;
cout << N << endl;
Multime P = N;
cout << P << endl;
M = P;
cout << P << endl;
cin >> P;
cout << P << endl;
}

Să se implementeze și alți operatori.

Analog pentru:
class Vector {
void **a;
int capacity;
int count;
public:
Vector(Vector&);
Vector(int _capacity);
~Vector();
void addElement(void *);
void insertElement(void *, int poz);
void removeElement(void *);
void removeAllElements();
void* operator[] (int index);
friend ostream& operator<< (ostream&, Vector&);
};

2. Să se implementeze clasa următoare:

#define SIZE 10
class STACK
{
private:
int num[SIZE];
int top;
public:
STACK();
int push(int);
int pop();
int isEmpty();
int isFull();
void displayItems();
};

3
Programare orientată pe obiecte Laborator 3

STACK::STACK() {
top = -1;
}

int STACK::isEmpty() {
if (top == -1)
return 1;
else
return 0;
}

int STACK::isFull() {
if (top == (SIZE - 1))
return 1;
else
return 0;
}

int STACK::push(int n) {
if (isFull()) {
return 0;
}
num[++top] = n;
return n;
}

int STACK::pop() {
int temp;
if (isEmpty()) return 0;
temp = num[top--];
return temp;

void STACK::displayItems() {
int i;
cout << "STACK is: ";
for (i = (top); i >= 0; i--)
cout << num[i] << " ";
cout << endl;
}

3. Să se implementeze clasa urmatoare care va permite efectuarea operațiilor cu numere mari:

class BigDecimal {
char *cifre;
int len;
public:
BigDecimal(char* a, int lungime);
BigDecimal(BigDecimal&);
BigDecimal(long number);
~BigDecimal();
friend istream& operator >> (istream&, BigDecimal&);
friend ostream& operator<< (ostream&, BigDecimal&);
BigDecimal operator+ (BigDecimal&);
int operator < (BigDecimal&);
};

4
Programare orientată pe obiecte Laborator 3

Să se implementeze și numerele mari cu semn și să se supraîncarce în plus operatorii -, *, /.

4. Să se implementeze clasa urmatoare ce reprezinta siruri de caractere si operatii cu acestea:

class String {
char *p;
int len;
public:
String(char* mp);
String(String& s);
~String();
String& operator= (String& s);
String operator+ (String& s);
friend ostream& operator << (ostream& o, String& s);
String operator- (String& s); //elimina toate aparitiile sirului s.
};

5. Să se implementeze o structura de tip stiva:

class Stiva {
void** tab;
int head;
int capacity;
public:
Stiva();
Stiva(int);
Stiva(Stiva&);
~Stiva();
void* pop();
void* peek();
void push(void*);
int isEmpty();
int isFull();
Stiva& operator=(const Stiva&);
};

Soluție:
Știm că un pointer de un anumit tip poate reține adresa unei variabile de acel tip iar declarația este de tipul:
tip* p = new tip;

Putem avea spre exemplu:

int i = 5;
double d = 3;
char c = 'a';

int* pi = new int;//pi - retine adrese de variabile de tip int

char* pc = new char;//pc - retine adrese de variabile de tip char
double* pd = new double;//pd - retine adrese de variabile de tip double
pi = &i;
pc = &c;
pd = &d;
//pd = &i;// Eroare !!! pd - nu poate retine adrese de variabile de tip int

5
Programare orientată pe obiecte Laborator 3

Prin deferențiere obținem valorile memorate la adresele respective.

cout << *pi << endl;
cout << *pc << endl;
cout << *pd << endl;

Există și pointeri care pot reține adrese ale variabilelor de orice tip. Aceștia sunt cei de tip void*.
void* p;
p = &i;//corect
p = &c;//corect
p = &d;//corect

Pentru aceștia, dereferențierea nu se poate face direct ci trebuie facută în prealabil o conversie explicită.
cout << *p << endl;// Eroare !!! Nu se poate face dereferentierea
cout << *(double*)(p) << endl;//Corect - trebuie facuta o conversie explicita in
prealabil

Folosind operatorul new sau funcțiile malloc, calloc putem aloca memorie pentru acesti pointeri.

p = new void*;
p = malloc(sizeof(int));
p = calloc(1,sizeof(int));//face si initializarea. Este mai lenta fata de malloc

Pentru eliberarea memoriei se poate folosi operatorul delete sau funcția free.

delete p;
free(p);

Analizînd structura clasei observăm că elementul tab este de tip void**. Asta trebuie interpretat în sensul că în
stiva noastră vom avea memorate adrese ale elementelor de orice tip

#include"Header.h"
Stiva::Stiva() {
capacity = 0;
head = -1;
tab = 0;
}

Stiva::Stiva(int _capacity) {
capacity = _capacity;
head = -1;
tab = new void* [_capacity];
}

Stiva::Stiva(Stiva& s) {
capacity = [Link];
head = [Link];
tab = new void* [[Link]];
for (int i = 0; i < [Link]; i++) {
tab[i] = [Link][i];
}
}

Stiva::~Stiva() {

6
Programare orientată pe obiecte Laborator 3

if (tab)delete[] tab;
}

void* Stiva::pop() {
if (isEmpty()) return 0;
head--;
return tab[head + 1];
}

void* Stiva::peek() {
if (isEmpty()) return 0;
return tab[head];
}

void Stiva::push(void* el) {

if (!isFull()) {
tab[++head] = el;
}
}
int Stiva::isEmpty() {
return head == -1;
}

int Stiva::isFull() {
return head == capacity - 1;
}

Stiva& Stiva::operator=(const Stiva& s) {

if (this == &s)return *this;
if (tab)delete[] tab;
capacity = [Link];
head = [Link];
tab = new void* [[Link]];
for (int i = 0; i < [Link]; i++) {
tab[i] = [Link][i];
}
}

int main() {
Stiva s(5), t(10);
int a = 5;
double b = 3;
char c = 'a';
[Link](&a);
[Link](&b);
[Link](&c);

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

cout << *(char*)([Link]()) << endl;
cout << *(double*)([Link]()) << endl;
cout << *(int*)([Link]()) << endl;

t = s;//daca nu ar fi supraîncărcat operatorul = ar fi apărut o eroare

}

7
Programare orientată pe obiecte Laborator 3

6. Să se implementeze o structura de tip coada circulara.

class Queue {
void** tab;
int first, last;
int capacity;
public:
Queue();
Queue(int _capacity);
Queue(Queue&);
~Queue();
void* deQueue();
void enQueue(void*);
int isEmpty();
int isFull();
};

7. Folosind eventual fișierele Complex.h (click aici pentru download) și [Link] (click aici pentru
download) să se implementeze clasa Polinom

#pragma once
#include"Complex.h"
class Polinom {
private:
int grad;
Complex* coef;
public:
//constructori
Polinom();
Polinom(int, Complex[]);
Polinom(int, Complex);//monom Ex.: (1+i)X^5
Polinom(Polinom &);
//destructor
~Polinom();
///metode
int daGrad() { return grad; }//metoda inline
//supraincarcare operatori
Polinom& operator=(const Polinom&);
Polinom operator+(const Polinom&);
Polinom operator-(const Polinom&);
Polinom operator*(const Polinom&);
Polinom operator/(const Polinom&);
int operator==(const Polinom&);
int operator!=(const Polinom&);
Polinom operator-();
Polinom& operator+=(const Polinom&);
Polinom& operator-=(const Polinom&);
Polinom& operator*=(const Polinom&);
Polinom& operator/=(const Polinom&);
Complex& operator[](int);//operatorul de indexare
Complex operator()(Complex &);//operatorul apel de functie
friend ostream& operator<<(ostream&, const Polinom&);
friend istream& operator>>(istream&, Polinom&);

};

8
Programare orientată pe obiecte Laborator 3

[Link]

#include"Polinom.h"
Polinom::Polinom()
{
grad = 0;
coef = new Complex[grad + 1];
coef[0] = (Complex)0;
}
Polinom::Polinom(int grad, Complex coef[])
{
this->grad = grad;
this->coef = new Complex[this->grad + 1];
for (int i = 0; i <= this->grad; i++)
this->coef[i] = coef[i];
}
Polinom::Polinom(int grad, Complex c)
{
this->grad = grad;
coef = new Complex[this->grad + 1];
for (int i = 0; i < this->grad; i++)
this->coef[i] = (Complex)0;
this->coef[this->grad] = c;
}
Polinom::Polinom(Polinom& P)
{
this->grad = [Link];
this->coef = new Complex[this->grad + 1];
for (int i = 0; i <= this->grad; i++)
this->coef[i] = [Link][i];
}
Polinom::~Polinom(){
if (coef) delete[] coef;
}
Polinom& Polinom::operator=(const Polinom& P)
{
if (this != &P)
{
if (coef) delete[] coef;
grad = [Link];
coef = new Complex[grad + 1];
for (int i = 0; i <= [Link]; i++)
coef[i] = [Link][i];
}
return *this;
}
Polinom Polinom::operator+(const Polinom& P)
{
int gr = grad > [Link] ? grad : [Link];
Complex* cf = new Complex[gr + 1];
for (int i = 0; i <= gr; i++)
cf[i] = (Complex)0;
for (int i = 0; i <= grad; i++)
cf[i] = cf[i] + coef[i];

9
Programare orientată pe obiecte Laborator 3

for (int i = 0; i <= [Link]; i++)

cf[i] = cf[i] + [Link][i];
while (gr> 0 && cf[gr] == (Complex)0)gr--;
Polinom p = Polinom(gr, cf);
delete[] cf;
return p;
}
Polinom Polinom::operator-(const Polinom& P)
{
int gr = grad > [Link] ? grad : [Link];
Complex* cf = new Complex[gr + 1];
for (int i = 0; i <= gr; i++)
cf[i] = (Complex)0;
for (int i = 0; i <= grad; i++)
cf[i] = cf[i] + coef[i];
for (int i = 0; i <= [Link]; i++)
cf[i] = cf[i] - [Link][i];
while (gr> 0 && cf[gr] == (Complex)0)gr--;
Polinom p = Polinom(gr, cf);
delete[] cf;
return p;
}
Polinom Polinom::operator*(const Polinom& P)
{
int gr = grad + [Link];
Complex* cf = new Complex[gr + 1];
for (int i = 0; i <= gr; i++)
cf[i] = (Complex)0;
for (int i = 0; i <= grad; i++)
for (int j = 0; j <= [Link]; j++)
cf[i+j] += coef[i] * [Link][j];
while (gr> 0 && cf[gr] == (Complex)0)gr--;
Polinom p = Polinom(gr, cf);
delete[] cf;
return p;
}

Polinom Polinom::operator/(const Polinom& P)

{
if (grad - [Link] < 0)return Polinom();
int gr = -1;
Complex* cf = new Complex[[Link]+1];
Polinom Q(*this);
while ([Link] >= [Link]) {
cf[grad - [Link]-++gr] = [Link][[Link]] / [Link][[Link]];
Q -= Polinom([Link] - [Link], cf[grad - [Link] - gr])*P;
}
Polinom p = Polinom(gr, cf);
delete[] cf;
return p;
}
int Polinom::operator==(const Polinom& P) {
if (grad != [Link])return 0;
for (int i = 0; i <= grad; i++) {
if (coef[i] != [Link][i])return 0;
}
return 1;

1
Programare orientată pe obiecte Laborator 3

}
int Polinom::operator!=(const Polinom& P)
{
return !(*this == P);
}
Polinom Polinom::operator-()
{
Polinom P = *this;
for (int i = 0; i <= [Link]; i++)[Link][i] = -[Link][i];
return P;
}
Polinom& Polinom::operator+=(const Polinom& P)
{
*this = *this + P;
return *this;
}
Polinom& Polinom::operator-=(const Polinom& P)
{
*this = *this - P;
return *this;
}
Polinom& Polinom::operator*=(const Polinom& P)
{
*this = *this * P;
return *this;
}
Polinom& Polinom::operator/=(const Polinom& P)
{
*this = *this / P;
return *this;
}
Complex& Polinom::operator[](int i)
{
return coef[i];
}
Complex Polinom::operator()(Complex & c)
{
Complex rez = (Complex)0;
for (int i = grad; i >= 0; i--)
rez = rez*c + coef[i];
return rez;
}
ostream& operator<<(ostream& out, const Polinom& P)
{
if ([Link] == 0) out << [Link][0];
else if ([Link] == 1) {
out << "("<<[Link][1]<<")X";
if ([Link][0] != (Complex)0)out << " + " << [Link][0];
}
else{
out << "(" << [Link][[Link]] << ")X^" << [Link];
for (int i = [Link] - 1; i >= 2; i--) {
if([Link][i]!=(Complex)0)out << " + (" << [Link][i] << ")X^" << i;
}
if ([Link][1] != (Complex)0)out << " + ("<<[Link][1] << ")X";
if ([Link][0] != (Complex)0)out << " + " << [Link][0];
}
return out;

1
Programare orientată pe obiecte Laborator 3

istream& operator>>(istream& in, Polinom& P)

{
char linie[1000];
[Link](linie, 1000);
int gr=-1;
Complex cf[100];
char* pt;
pt = strtok(linie, " ");
while (pt) {
cf[++gr] = Complex(pt);
pt = strtok(NULL, " ");
}
P = Polinom(gr, cf);
return in;