Мета: Навчитися складати програми з використанням композицій дружніх

функцій та дружніх класів

Обладнання: ОС Windows, компілятор (середовище програмування) мови
С++ - IDE MS Visual Studio

Хід роботи

Завдання №1.
Додати до класу з попередньої лабораторної роботи №2 пошукову дружню
функцію.
Визначити декілька перевантажених дружніх функцій ( з одим іменем та з
різними списками параметрів) – для одного екземпляра класа і для масива
екземплярів класу (дві дружні функції) .
Для тестування дружніх функцій в головній функції оголосити масив
об’єктів та виконати явну ініціалізацію масиву за допомогою вже визначеного
конструктору з параметрами.
Лістинг програми:
#include <iostream>
#include <string>
#include <iomanip>

using namespace std;

class Lake {
private:
string lake_name;
string lake_country;
float lake_deep;
float lake_salt_perc;

public:
Lake();
Lake(const Lake& cop);
Lake(string, string, float, float);

Змн. Арк. № докум. Підпис Дат

ФКЗЕ.121ООП00. 03ЛР
Розроб. а Літ. Арк. Аркушів
Логвіненко В.В.
Складання програм з
Перевір. Кудринских 1 10
Реценз. Э.Р використанням
Н. Контр. Логвіненко В.В. композицій дружніх Група ПЗ-21-1/9
Затверд. Саприкіна І.Г. функцій та дружніх
 Lake& operator=(const Lake& other);

~Lake() { }

void set_lake_name(const string& lake_name) { this->lake_name = lake_name; }

void set_lake_country(const string& lake_country) { this->lake_country = lake_country; }
void set_lake_deep(float lake_deep) { this->lake_deep = lake_deep; }
void set_lake_salt_perc(float lake_salt_perc) { this->lake_salt_perc = lake_salt_perc; }

string get_lake_name() const { return lake_name; }

string get_lake_country() const { return lake_country; }
float get_lake_deep() const { return lake_deep; }
float get_lake_salt_perc() const { return lake_salt_perc; }

void print() const;

void scan();

friend void displayLakeInfo(const Lake& lake);

friend void displayLakeInfo(const Lake* lakes, int count);

friend void searchLake(const Lake* lakes, int count, const string& name, const string&
country);
};

Lake::Lake() : lake_name(""), lake_country(""), lake_deep(0.0), lake_salt_perc(0.0) {}

Lake::Lake(const Lake& cop) {

lake_name = cop.lake_name;
lake_country = cop.lake_country;
lake_deep = cop.lake_deep;
lake_salt_perc = cop.lake_salt_perc;
}

Lake& Lake::operator=(const Lake& other) {

if (this == &other) {
return *this;
}
lake_name = other.lake_name;
lake_country = other.lake_country;
lake_deep = other.lake_deep;
lake_salt_perc = other.lake_salt_perc;
return *this;
}

Lake::Lake(string name, string country, float depth, float salt_perc)

: lake_name(name), lake_country(country), lake_deep(depth), lake_salt_perc(salt_perc) {}

void Lake::print() const {

cout << "Lake Name: " << lake_name << endl;
cout << "Lake Country: " << lake_country << endl;
cout << "Lake Depth: " << lake_deep << " meters" << endl;
cout << "Salt Percentage: " << fixed << setprecision(2) << lake_salt_perc * 100 << "%" <<
endl;
}

void Lake::scan() {
cout << "Enter Lake Name: ";
cin >> lake_name;

Арк.

Змін. Арк. № докум. Підпис Дата

ФКЗЕ.121ООП00. 0ЛР 2
 cout << "Enter Lake Country: ";
cin >> lake_country;
cout << "Enter Lake Depth (in meters): ";
cin >> lake_deep;
cout << "Enter Salt Percentage: ";
cin >> lake_salt_perc;
lake_salt_perc /= 100;
}

void displayLakeInfo(const Lake& lake) {

lake.print();
}

void displayLakeInfo(const Lake* lakes, int count) {

for (int i = 0; i < count; ++i) {
cout << "Lake " << (i + 1) << ":\n";
lakes[i].print();
cout << endl;
}
}

void searchLake(const Lake* lakes, int count, const string& name, const string& country) {
bool found = false;
for (int i = 0; i < count; ++i) {
if (lakes[i].lake_name == name && lakes[i].lake_country == country) {
found = true;
cout << "Lake found:\n";
lakes[i].print();
cout << endl;
}
}
if (!found) {
cout << "Lake not found with name: " << name << " and country: " << country << endl;
}
}

int main() {
system("color e5");
system("chcp 1251");
system("cls");

Lake lakes[3] = {
Lake("Dead Sea", "Israel and Jordan", 304.0, 33.7),
Lake("Lake Tahoe", "USA", 501.0, 0.1),
Lake("Caspian Sea", "Multiple Countries", 1025.0, 1.2)
};

displayLakeInfo(lakes, 3);
searchLake(lakes, 3, "Dead Sea", "Israel and Jordan");
searchLake(lakes, 3, "Lake Tahoe", "USA");
searchLake(lakes, 3, "Unknown Lake", "Unknown Country");

return 0;
}
Результати тестування програми:

Арк.

Змін. Арк. № докум. Підпис Дата

ФКЗЕ.121ООП00. 0ЛР 3
 Рисунок 1 – Завдання1
Завдання №2
Додати до класу з лабораторної роботи №1 дружній клас Time (А) та зв’язати
його з класом індивідуального завдання (В) таким чином щоб можна було через
обєкт класу індивідуального завдання виводити час:
― додати до класу Time private метод (RandTime()) генерації параметрів
класу Time;
― додати до реалазації метода вивода значень властивостей об’єкта клас
Індивідуального завдання виклик метода RandTime() класу Time.
Лістинг програми:
#include <iostream>
#include <string>
#include <iomanip>
#include <cstdlib>
#include <ctime>

using namespace std;

class Time {
private:
int h;
int m;

public:
void RandTime() {
h = rand() % 24;
m = rand() % 60;
}

Time() {
RandTime();
}

Time(int h, int m) : h(h), m(m) {}

Арк.

Змін. Арк. № докум. Підпис Дата

ФКЗЕ.121ООП00. 0ЛР 4
 void setHours(int h) { this->h = h; }
void setMinutes(int m) { this->m = m; }

int getHours() const { return h; }

int getMinutes() const { return m; }

friend class Lake;

};

class Lake {
private:
string lake_name;
string lake_country;
float lake_deep;
float lake_salt_perc;
Time time;

public:
Lake() : lake_deep(0.0), lake_salt_perc(0.0) {
time.RandTime();
}

Lake(const Lake&);
Lake(string, string, float, float, Time);
~Lake() {}

void setLakeName(string lake_name) { this->lake_name = lake_name; }

void setLakeCountry(string lake_country) { this->lake_country = lake_country; }
void setLakeDeep(float lake_deep) { this->lake_deep = lake_deep; }
void setLakeSaltPerc(float lake_salt_perc) { this->lake_salt_perc = lake_salt_perc; }

string getLakeName() const { return lake_name; }

string getLakeCountry() const { return lake_country; }
float getLakeDeep() const { return lake_deep; }
float getLakeSaltPerc() const { return lake_salt_perc; }

void print() const;

void scan();
Time getTime() const { return time; }
void displayTime() const;
};

Lake::Lake(string name, string country, float deep, float salt_perc, Time t) :

lake_name(name), lake_country(country), lake_deep(deep), lake_salt_perc(salt_perc),
time(t) {
}

Lake::Lake(const Lake& lake) {

lake_name = lake.lake_name;
lake_country = lake.lake_country;
lake_deep = lake.lake_deep;
lake_salt_perc = lake.lake_salt_perc;
time = lake.time;
}

void Lake::scan() {
cout << "Enter lake name: ";
getline(cin, lake_name);
cout << "Enter lake country: ";
getline(cin, lake_country);
cout << "Enter lake depth in m: ";
cin >> lake_deep;
cout << "Enter percentage of salt in water: ";

Арк.

Змін. Арк. № докум. Підпис Дата

ФКЗЕ.121ООП00. 0ЛР 5
 cin >> lake_salt_perc;
}

void Lake::print() const {

cout << setw(12) << lake_name.substr(0, 12) << " | "
<< setw(15) << lake_country.substr(0, 15) << " | "
<< setw(6) << lake_deep << " | "
<< setw(6) << lake_salt_perc << " | ";
}

void displayLakes(const Lake* arr, int n) {

cout << setw(3) << "No" << " | " << setw(12) << "Lake Name" << " | " << setw(15) <<
"Country" << " | " << setw(6) << "Depth" << " | " << setw(10) << "Salt %" << " | " << setw(10)
<< "Time" << " | " << endl;
cout << "-------------------------------------------------------------------------" <<
endl;
for (int i = 0; i < n; i++) {
cout << setw(3) << i + 1 << " | ";
arr[i].print();
cout << setw(5) << arr[i].getTime().getHours() << ":" << setw(2) << setfill('0') <<
arr[i].getTime().getMinutes() << setfill(' ') << " |" << endl;
cout << "-------------------------------------------------------------------------" <<
endl;
}
}

void find(const Lake* arr, int n) {

string str;

cout << "Enter name of lake for search > ";

cin.ignore();
getline(cin, str);

cout << " No | Lake Name | Country | Depth | Salt % | Time |\n";
cout << "--------------------------------------------------------------------\n";

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

if (arr[i].getLakeName() == str) {
cout << setw(3) << i + 1 << " | ";
arr[i].print();
cout << setw(5) << arr[i].getTime().getHours() << ":" << setw(2) << setfill('0')
<< arr[i].getTime().getMinutes() << setfill(' ') << " |" << endl;
cout << "--------------------------------------------------------------------\n";
}
}
}

void filterAndPrintLakes(const Lake* arr, int n) {

cout << "Lakes that are not deeper than 50 m and have more than 20% salt:" << endl;
cout << "----------------------------------------------------" << endl;

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

if (arr[i].getLakeDeep() <= 50.0 && arr[i].getLakeSaltPerc() > 20.0) {
cout << "Name of lake: " << arr[i].getLakeName() << endl;
cout << "Depth: " << arr[i].getLakeDeep() << " m" << endl;
cout << "Percentage of salt: " << arr[i].getLakeSaltPerc() << "%" << endl;

Time newTime;
arr[i].getTime() = newTime;

cout << "Time: " << arr[i].getTime().getHours() << ":" << setw(2) << setfill('0')
<< arr[i].getTime().getMinutes() << setfill(' ') << endl;
cout << "----------------------------------------------------" << endl;
}

Арк.

Змін. Арк. № докум. Підпис Дата

ФКЗЕ.121ООП00. 0ЛР 6
 }
}

int main() {
int ch = 9;
const int n = 4;
Lake lake_arr[n];
system("color e5");

srand(time(NULL)); // Инициализация генератора случайных чисел

lake_arr[0] = Lake("Devil's Lake", "Japan", 34.1, 23.4, Time());

lake_arr[1] = Lake("Great Salt Lake", "United States", 4.6, 20.0, Time());
lake_arr[2] = Lake("Dead Sea", "Israel and Jordan", 304.0, 33.7, Time());
lake_arr[3] = Lake("Caspian Sea", "Kazakhstan", 211.0, 1.2, Time());

do {
system("cls");
cout << "\twelcome \
n________________________________________________________________________________\n";
cout << "\nmenu:\n\n1 - Output info \n2 - Search\n3 - Individual task\n0 - Exit\n";

cin >> ch;

cin.ignore();

switch (ch) {
case 1:
system("cls");
displayLakes(lake_arr, n);
cin.ignore();
break;
case 2:
system("cls");
find(lake_arr, n);
cin.ignore();
break;
case 3:
system("cls");
filterAndPrintLakes(lake_arr, n);
cin.ignore();
break;
case 0:
exit(0);
break;
default:
break;
}
} while (ch != 0);

return 0;
}
Результати тестування програми:

Арк.

Змін. Арк. № докум. Підпис Дата

ФКЗЕ.121ООП00. 0ЛР 7
 Рисунки2-3 – Завдання 2

Відповіді на контрольні питання

1 Неповне оголошення класу;

Неповне оголошення класу - це оголошення класу, в якому визначено лише його
ім'я, але не вказані його поля та методи. Наприклад:
class MyClass; // Неповне оголошення класу MyClass
2 Оголошення дружньої функції;
Оголошення дружньої функції - це вказання, що функція має доступ до приватних
членів класу. Це використовується за допомогою ключового слова friend.
Наприклад:
class MyClass {
private:
int privateData;
public:
friend void friendFunction
3 Оголошення дружньої функції декільком класам одночасно;
Можна оголосити функцію дружньою для декількох класів, перераховуючи їх
імена через кому у списку друзів. Наприклад:
class ClassA;
class ClassB;
void friendFunction(ClassA &objA, ClassB &objB);
class ClassA {

Арк.

Змін. Арк. № докум. Підпис Дата

ФКЗЕ.121ООП00. 0ЛР 8
 private:
int privateDataA;
public:
friend void friendFunction(ClassA &objA, ClassB &objB); // Оголошення дружньої
функції для ClassA та ClassB
};
class ClassB {
private:
int privateDataB;
};
4 Оголошення дружнього класу;
Дружній клас - це клас, який має доступ до приватних та захищених членів
іншого класу. Це робиться за допомогою ключового слова friend. Наприклад:
class FriendClass; // Неповне оголошення дружнього класу
class MyClass {
private:
int privateData;
public:
friend class FriendClass; // Оголошення FriendClass як дружнього класу
};
5 Оголошення дружніх класів один до одного;
Два класи можуть бути дружніми один до одного, що дозволяє їм мати доступ до
приватних членів один одного. Наприклад:
class ClassA;
class ClassB;
class ClassA {
private:
int privateDataA;
public:

Арк.

Змін. Арк. № докум. Підпис Дата

ФКЗЕ.121ООП00. 0ЛР 9
 friend class ClassB; // Оголошення ClassB як дружнього класу для ClassA
};
class ClassB {
private:
int privateDataB;
public:
friend class ClassA; // Оголошення ClassA як дружнього класу для ClassB
};
6 Правила роботи дружніх класів
― Дружні класи/функції мають доступ до приватних та захищених членів
класу, але це не робить їх методами класу.
― Дружність є взаємною, тобто, якщо клас A - друг класу B, то клас B - друг
класу A.
― Дружність між класами може бути обмежена і не обов'язково включати всі
члени класу.
― Зазвичай використовують дружні класи або функції в обмеженому обсязі,
оскільки це порушує інкапсуляцію та може зробити код менш зрозумілим і
складним для обслуговування.

Висновок: навчилася складати програми з використанням композицій

дружніх функцій та дружніх класів

Арк.

Змін. Арк. № докум. Підпис Дата

ФКЗЕ.121ООП00. 0ЛР 10