Ministerul Educaţiei al Republicii Moldova

Universitatea Tehnică a Moldovei

Catedra FCIM

Raport
Lucrarea de laborator Nr.2
Programarea orientată pe obiecte

Varianta 7

A efectuat: Grosu Maxim

A verificat: Pasat Natalia

Chișinău 2021
 Sarcina
a) Să se creeze clasa Queue–coadă. Cîmpurile –numărul de elemente şi un
pointer pentru alocarea dinamică a memoriei. Să se definească constructorii:
implicit, de copiere şi cu un parametru –numărul necesar de elemente;
funcţiile addşiget pentru punerea unui element în coadă şi pentru scoaterea
unui element din coadă respectiv; funcţiile: isEmpty,care returnează valoarea
1 dacă coada este vidă şi zero în caz contrar, şi isFull care returnează
valoarea 1 dacă coada este plină şi zero în caz contrar.

b) Să se creeze clasa Matrix–matrice. Clasa conţine pointer spre int, numărul de

rînduri şi de coloane şi o variabilă –codul erorii. Să se definească
constructorul fără parametri (constructorul implicit), constructorul cu un
parametru –matrice pătrată şi constructorul cu doi parametri –matrice
dreptunghiulară ş. a. Să se definească funcţiilemembru de acces:
returnarea şi setarea valorii elementului (i,j). Să se definească funcţiile de
adunare şi scădere a două matrice; înmulţirea unei matrice cu alta; înmulţirea
unei matrice cu un număr. Să se testeze funcţionarea clasei. În caz de
insuficienţă de memorie, necorespondenţă a dimensiunilor matricelor,
depăşire a limitei memoriei utilizate să se stabilească codul erorii

Rezolvare
a)

#include <iostream>
#include <string>
using namespace std;

class Queue {
private:
int capacity; // maximum capacity of the queue
int *arr;
int count;

public:
// Constructori implicit
Queue(int size){
arr = new int[size];
 capacity = size;
count = 0;

};
// Constructori de copiere - paramentru - numarul necesar de
elemente
Queue(const Queue &obj){
this->capacity = obj.capacity;
this->arr = obj.arr;
this->count = obj.count;
};
~Queue(){
delete[] arr;
}
bool isEmpty(){
return (this->count == 0);
}
bool isFull(){
return (this->count == this->capacity);
}

void addQueue(int item){

if (this->isFull()){
cout << "Lista este incarcata\nProgram terminat\n";

else {
cout << "Insertarea itemului "<< item << endl;
arr[this->count] = item;
count++;

}
}
void printQueue(){
if (this->isEmpty()){
cout << "Aceasta lista este goala\n";

}
else {
 for (int i =0; i<this->count; i++){
cout << "["<<i+1<<"] = "<<this->arr[i]<< endl;
}
}
}

// addQueue - punerea unui element in coada

// getQueue - scoaterea unui element din coada
// isEmpty()
// isFull()
};

int main (){

Queue q(4);

cout << q.isEmpty() << endl;

q.addQueue(2);
q.addQueue(5);
q.addQueue(3);
q.addQueue(7);

q.printQueue();
cout << q.isEmpty() << endl;
cout << q.isFull() << endl;

cout << "Lista noua"<< endl;

Queue w(q);
w.printQueue();

return 0;
}
Output:

b) Să se creeze clasa Matrix – matrice. Clasa conţine pointer spre int, numărul de
rînduri şi de coloane şi o variabilă – codul erorii. Să se definească constructorul
fără parametri (constructorul implicit), constructorul cu un parametru – matrice
pătrată şi constructorul cu doi parametri – matrice dreptunghiulară ş. a. Să se
definească funcţiile membru de acces: returnarea şi setarea valorii elementului (i,j).
Să se definească funcţiile de adunare şi scădere a două matrice; înmulţirea unei
matrice cu alta; înmulţirea unei matrice cu un număr. Să se testeze funcţionarea
clasei. În caz de insuficienţă de memorie, necorespondenţă a dimensiunilor
matricelor, depăşire a limitei memoriei utilizate să se stabilească codul erorii.
#include <iostream>
#include <string>

using namespace std;

class Matrix
{
private:
int **p;
int rows_, cols_;
 void allocSpace();

public:
Matrix(int, int);
Matrix(int);
Matrix(int**, int, int);
Matrix();
~Matrix();
Matrix(const Matrix&);
Matrix& operator=(const Matrix&);

void setMatrix();
void showMatrix();

};

void Matrix::allocSpace()
{
p = new int*[rows_];
for (int i = 0; i < rows_; ++i) {
p[i] = new int[cols_];
}
}

void Matrix::setMatrix(){

cout << "Introduceti numarul de randuri"<< endl;

cin >> this->rows_;
cout << "Introduceti numarul de coloane"<< endl;
cin >> this->cols_;

this->p = new int*[this->rows_];

for (int i = 0; i< this->rows_; i++){
this->p[i] = new int[this->cols_];
for (int j=0; j<this->cols_; j++){
cout << "p["<<i+1<<"]["<<j+1<<"] = ";
 cin >> p[i][j];
cout << endl;
}
}

void Matrix::showMatrix(){
if (this != 0){

for (int i=0; i < this-> rows_; i++){

for (int j=0; j<this->cols_; j++ ){
cout << p[i][j]<< "\t";
}
cout << endl;
}
}

Matrix::Matrix(int rows, int cols) : rows_(rows), cols_(cols)

{
allocSpace();
for (int i = 0; i< rows_; i++){
for (int j = 0; j< cols_; j++){
p[i][j] = 0;
}
}
}

Matrix::Matrix(int rows) : rows_(rows)

{

for (int i = 0; i< rows_; i++){

for (int j = 0; j< rows_; j++){
p[i][j] = 0;
 }
}
}

Matrix::Matrix(int** a, int rows, int cols) : rows_(rows), cols_(cols)

{
allocSpace();
for (int i = 0; i < rows_; ++i) {
for (int j = 0; j < cols_; ++j) {
p[i][j] = a[i][j];
}
}
}

Matrix::Matrix() : rows_(1), cols_(1)

{
allocSpace();
p[0][0] = 0;
}

Matrix::~Matrix()
{
for (int i =0; i < rows_; i++ ){
delete[] p[i];
}
delete [] p;
}

Matrix::Matrix(const Matrix& m) : rows_(m.rows_), cols_(m.cols_)

{
allocSpace();
for (int i = 0; i < rows_; i++){
for (int j =0; j < cols_; j++){
p[i][j] = m.p[i][j];
}
}
}

Matrix& Matrix::operator=(const Matrix& m)

{
if (this == &m){
return *this;
}

if (rows_ != m.rows_ || cols_ != m.cols_){

for (int i =0; i < rows_; i++){
delete[] this->p[i];
}
delete[] p;

rows_ = m.cols_;
cols_ = m.cols_;
allocSpace();
}

for (int i=0; i < rows_; i++){

for (int j = 0; j < cols_; j++){
p[i][j] = m.p[i][j];
}
}
return *this;
}

int main()
{

Matrix A;
A.setMatrix();
A.showMatrix();

Matrix B = Matrix(A);
cout << "\n";
B.showMatrix();

return 0;
}

Output:
Introduceti numarul de randuri
2
Introduceti numarul de coloane
4
p[1][1] = 2

p[1][2] = 4

p[1][3] = 1

p[1][4] = 4

p[2][1] = 4

p[2][2] = 3

p[2][3] = 2

p[2][4] = 4

2 4 1 4
4 3 2 4

2 4 1 4
4 3 2 4