1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
# Разделна компилация. Абстракция. Копиращ конструктор и оператор=
## Разделна компилация.
Една програма на С++ може да бъде разбита в множество файлове, които се **компилират независимо един от друг**, т.е. осъществява се **разделна компилация**. В резултат на компилацията се получават няколко **обектни файла** (файлове с разширение **.obj**). Изпълнимият код напрограмата (файл с разширение .ехе) се получава след свързване на обектните файлове (**Linking**).
За да се възполваме максимално от разделната компилация, разделяме класовете на **.h** и **.cpp** файлове. Навсякъде където ще работим с класа, ще включваме **само .h файла.** По този начин, ако променим реализацията на някоя от функциите на класа, ще се **прекомпилира само този файл**.
## Абстракция
Пример за **лоша абстракция**:
```c++
struct Triangle
{
int x1;
int y1;
int x2;
int y2;
int x3;
int y3;
};
int getPer(const Triangle& t)
{
return
sqrt( (t.x1-t.x2)*(t.x1-t.x2) + (t.y1-t.y2)*(t.y1-t.y2) +
sqrt( (t.x2-t.x3)*(t.x2-t.x3) + (t.y2-t.y3)*(t.y2-t.y3) +
sqrt( (t.x3-t.x1)*(t.x3-t.x1) + (t.y3-t.y1)*(t.y3-t.y1);
}
```
Пример за **по-добра абстракция**:
```c++
struct Point
{
int x;
int y
double getDistTo(const Point& other)
{
return sqrt((x-other.x)*(x-other.x)+(y-other.y)*(y-other.y));
}
};
struct Triangle
{
Point p1;
Point p2;
Point p3;
};
int getPer(const Triangle& t)
{
return t.p1.getDistTo(t.p2) + t.p2.getDistTo(t.p3) + t.p3.getDistTo(t.p1);
}
```
## Копиращ конструктор и оператор =
Заедно с конструктора по подразбиране и деструктора във всеки клас се дефинират и следните член-функции:
- Копиращ конструктор - конструктор, който приема обект от същия клас и създава новият обект като негово копие.
- Оператор= - функция/оператор, който приема обект от същия клас и променя данните на съществуващ обект от същия клас (обектът от който извикваме функцията.
**Забележка:** Копиращият конструктор създава нов обект, а оператор= модифицира вече съществуващ такъв!
```c++
#include <iostream>
using namespace std;
struct Test
{
Test()
{
cout << "Default constructor" <<endl;
}
Test(const Test& other)
{
cout << "Copy constructor" <<endl;
}
Test& operator=(const Test& other)
{
cout << "operator=" <<endl;
}
~Test()
{
cout << "Destructor" <<endl;
}
};
void f(Test object)
{
//do Stuff
}
void g(Test& object)
{
//do Stuff
}
int main()
{
Test t; //Default constructor;
Test t2(t) // Copy constructor
Test t3(t2) // Copy constructor
Test t2 = t3 // operator=
Test t3 = t // operator=
Test newTest = t; //Copy constructor !!!!!!!
f(t); // Copy constructor
g(t); // nothing. We are passing it as a reference. We are not copying it!
Test* ptr = new Test(); // Default constructor // we create a new object in the dynamic memory. The destructor must be invoked explicitly (with delete)
delete ptr; // Destructor
} //Destructor Destructor Destructor Destructor
```
## Задачи
**Задача 1:**
Реализирайте клас **Time**, който ще се използва за работа с часове (13:05:45).
Вашият клас трябва да има следния интерфейс:
- Подразбиращ се контруктор, който създава часа на **00:00:00**.
- Конструктор, който приема три параметъра - **час, минути и секунди**.
- Член-функция, която **добавя/изважда** часове.
- Член-функция, която **добавя/изважда** минути.
- Член-функция, която **добавя/изважда** секунди.
- Член-функция, която връща оставащото време до **полунощ**.
- Член-функция, която връща дали е **време за вечеря**. В рамките на задачата време за вечеря е между **20:30** и **22:00**.
- Член-функция, която връща дали е **време за парти**. В рамките на задачата време за парти е между **23:00** и **06:00**.
- Член-функция, която приема друг обект от тип **Time** и връща обект от тип **Time**, което е разликата между двете времена.
- Член-функция, която която приема друг обект от тип **Time** и сравнява двата обекта (по-къснен/по-ранен)
```c++
int main()
{
Time t(12,30,45); //12:30:45
Time t2; //00:00:00
t.addSeconds(15); //12:31:00
t.addMinutes(29); // 13:00:00;
t.isPartyTime(); // false
Time result = t.timeToMidnight(); // 11:00:00
t2.compareTo(t); //some value that indicates that t2 < t
}
```
|
