Міністерство освіти і науки України Національний університет «Львівська

політехніка» Інститут комп’ютерних наук та інформаційних технологій

Кафедра автоматизованих систем управління

Звіт
до лабораторної роботи № 2
з дисципліни
Об’єктно-орієнтоване програмування
на тему:
“Робота з динамічною пам’яттю. Перевантаження операцій
С++ ”

Виконав: студент ОІ-16

Боднар Данило

Прийняла:

доцент каф. АСУ

Ткачук К. I.
Львів – 2023
 Лабораторна робота №2

Тема роботи: Робота з динамічною пам’яттю. Перевантаження операцій

С++

Мета роботи: ознайомитись із можливостями мови C++ для роботи з

динамічною пам’яттю та способами перевантаження операцій, навчитись
використовувати їх при роботі з класами та об’єктами.

Завдання лабораторної роботи IIв.

Послідовність роботи:

1. Ознайомитись з особливостями виділення та звільнення динамічної пам’яті на

С++, операціями new та delete .

2. Модифікувати текст програми з ЛР № 1, описати поля даних класу – масиви, як

змінні в динамічній пам’яті.

3. Внести відповідні зміни у конструктори, деструктор, методи доступу та інші

функції класу.

4. Реалізувати конструктор копіювання – для створення глибокої копії об’єкта,

розглянути на прикладі конструктора копіювання застосування параметрів-посилань та
константних параметрів.

5. Продемонструвати використання вказівника this для доступу до полів та

методів класу.

6. Створити об’єкти розробленого класу в динамічній пам’яті.

7. Вивести на екран повідомлення про виконання конструкторів та деструкторів.

8. Визначити, які можливості виділення пам’яті для великих об’ємів даних у

масивах-полях класу надає використання динамічної пам’яті.

9. Ознайомитись зі способами перевантаження функцій та операцій у С++.

10. У розробленому класі перевантажити як дружні операції зсувів ( >> та << )

для організації введення-виведення даних про об’єкти класу (для всіх варіантів
індивідуальних завдань).

11. Доповнити клас перевантаженими операціями для спрощення роботи з

об’єктами відповідно до індивідуального завдання.
 12. У головній програмі продемонструвати введення-виведення та сортування
масиву екземплярів класу (за заданим алгоритмом) із використанням перевантажених
операцій порівняння (більше, менше, тощо). Для коректної роботи з полями-змнними у
динамічній пам'яті і зміни об'єктів при сортуванні реалізувати перевантажену
операцію присвоєння ( = ) (за аналогією з конструктором копіювання).

13. У головній програмі проілюструвати роботу інших перевантажених операцій

для виконання індивідуального завдання.

Індивідуальне завдання:

Перевантажити операції <= (порівняння матриць за кількістю елементів),

*(множення матриць), відсортувати масив екземплярів класу матриць за

зростанням кількості елементів з використанням алгоритму сортування

вставками, обчислити добуток двох заданих матриць з масиву (якщо це можливо).
Текст програми:
#include <iostream>

using namespace std;

class Matrix
{
private:
int rows;
int columns;
int **twoDimensionalArray;

public:
Matrix()
{
}
Matrix(int r, int c)
{
rows = r;
columns = c;
twoDimensionalArray = new int *[rows];

for (int i = 0; i < rows; i++)

{
twoDimensionalArray[i] = new int[columns];

for (int j = 0; j < columns; j++)

{
twoDimensionalArray[i][j] = rand() % 15;
}
}
 }
void printMatrix()
{
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < columns; j++)
{
cout << twoDimensionalArray[i][j] << " ";
}
cout << endl;
}
}
int getElementByIndexes(int row, int column)
{
return twoDimensionalArray[row][column];
}
void multiplyBy(int number)
{
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < columns; j++)
{
twoDimensionalArray[i][j] *= number;
}
}
}
Matrix operator+(const Matrix &secondMatrix)
{
if (rows != secondMatrix.rows || columns != secondMatrix.columns)
{
throw invalid_argument("Matrices must be of the same size.");
}

Matrix resultMatrix(rows, columns);

for (int i = 0; i < rows; i++)

{
for (int j = 0; j < columns; j++)
{
resultMatrix.twoDimensionalArray[i][j] = twoDimensionalArray[i][j] +
secondMatrix.twoDimensionalArray[i][j];
}
}

return resultMatrix;
}
Matrix operator-(const Matrix &secondMatrix)
{
if (rows != secondMatrix.rows || columns != secondMatrix.columns)
{
 throw invalid_argument("Matrices must be of the same size.");
}

Matrix resultMatrix(rows, columns);

for (int i = 0; i < rows; i++)

{
for (int j = 0; j < columns; j++)
{
resultMatrix.twoDimensionalArray[i][j] = twoDimensionalArray[i][j] -
secondMatrix.twoDimensionalArray[i][j];
}
}

return resultMatrix;
}
Matrix operator*(const Matrix &secondMatrix)
{
if (columns != secondMatrix.rows)
{
throw invalid_argument("Matrices must be columns != secondMatrix.rows.");
}

Matrix resultMatrix(rows, secondMatrix.columns);

for (int i = 0; i < rows; i++)

{
for (int j = 0; j < secondMatrix.columns; j++)
{
for (int k = 0; k < columns; k++)
{
resultMatrix.twoDimensionalArray[i][j] += twoDimensionalArray[i][k] *
secondMatrix.twoDimensionalArray[k][j];
}
}
}

return resultMatrix;
}
Matrix &operator=(const Matrix &otherMatrix)
{
this->rows = otherMatrix.rows;
this->columns = otherMatrix.columns;
this->twoDimensionalArray = new int *[rows];

for (int i = 0; i < otherMatrix.rows; i++)

{
this->twoDimensionalArray[i] = new int[columns];

for (int j = 0; j < columns; j++)

 {
this->twoDimensionalArray[i][j] = otherMatrix.twoDimensionalArray[i][j];
}
}
return *this;
}
bool operator<=(const Matrix &otherMatrix)
{
return this->rows * this->columns <= otherMatrix.rows * otherMatrix.columns;
}
bool operator>=(const Matrix &otherMatrix)
{
return this->rows * this->columns >= otherMa-
trix.rows * otherMatrix.columns;
}
bool operator>(const Matrix &otherMatrix)
{
return this->rows * this->columns > otherMa-
trix.rows * otherMatrix.columns;
}
bool operator<(const Matrix &otherMatrix)
{

return this->rows * this->columns < otherMatrix.rows * otherMatrix.columns;

}
bool operator==(const Matrix &otherMatrix)
{

bool isEqual = true;

if (this->rows != otherMatrix.rows || this->columns != otherMatrix.columns)

{
isEqual = false;
}
for (int i = 0; i < this->rows; i++)
{
for (int j = 0; j < this->columns; j++)
{
if (this->twoDimensionalArray[i][j] != otherMatrix.twoDimensionalArray[i][j])
{
isEqual = false;
}
 }
}
return isEqual;
}
~Matrix()
{
for (int i = 0; i < rows; i++)
{
delete[] twoDimensionalArray[i];
}

delete[] twoDimensionalArray;
}
};

void insertionSort(Matrix *arr[], int size);

void printMatrices(Matrix *matrices[], int amountOfMatrices);

int main()
{
int amountOfMatrices = 6;

Matrix *matrices[amountOfMatrices];

for (int i = 0; i < amountOfMatrices; i++)

{
int numRows = rand() % 5 + 1;
int numCols = rand() % 5 + 1;

matrices[i] = new Matrix(numRows, numCols);

}

printMatrices(matrices, amountOfMatrices);
insertionSort(matrices, amountOfMatrices);

for (int i = 0; i < amountOfMatrices; i++)

{
delete matrices[i];
}

return 0;
}

void insertionSort(Matrix *arr[], int size)

{
cout << "Sorted:"
<< "\n"
<< endl;

for (int i = 1; i < size; i++)

 {
Matrix key = *arr[i];
int j = i - 1;

while (j >= 0 && *arr[j] <= key)

{
*arr[j + 1] = *arr[j];
j--;
}

*arr[j + 1] = key;
}
printMatrices(arr, size);
}

void printMatrices(Matrix *matrices[], int amountOfMatrices)

{
for (int i = 0; i < amountOfMatrices; i++)
{
cout << "Matrix " << i + 1 << ":" << endl;
matrices[i]->printMatrix();
}
cout << "\n"
<< endl;
}

Результат роботи:
 Висновок

Ознайомився із можливостями мови C++ для роботи з динамічною

пам’яттю та способами перевантаження операцій, навчитись
використовувати їх при роботі з класами та об’єктами.