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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
|
# Член-функции. Конструктори и деструктор. Модификатори за достъп. Капсулация.
## Член-функции.
Член-функциите са функции, които работят с член-данните на обекта от дадена структура.
```c++
struct Point
{
int x;
int y;
};
bool isInFirstQuadrant(const Point& p)
{
return p.x >= 0 && p.y >= 0;
}
int main()
{
Point p1 = {3, 4};
Point p2 = {-9, 8};
cout << isInFirstQuadrant(p1) << endl;
cout << isInFirstQuadrant(p2) << endl;
}
```
Може функцията да бъде член-функция:
```c++
struct Point
{
int x;
int y
bool isInFirstQuadrant()
{
return x >= 0 && y >= 0;
}
};
int main()
{
Point p1 = {3, 4};
Point p2 = {-9, 8};
cout << p1.isInFirstQuadrant() << endl;
cout << p2.isInFirstQuadrant() << endl;
}
```
#
**Член-функциите**:
- Работят с член-данните на класа.
- Извикват се с обект на класа
- Компилаторът преобразува всяка **член-функция** на дадена структура в
обикновена функция с уникално име и един допълнителен параметър
–**указател към обекта**.
**Константни член-функции**:
- Не променят член-данните на структурата.
- Оказва се чрез записването на ключовата дума **const** в декларацията и в края на заглавието в дефиницията им
- Могат да се извикват от константни обекти.
## Конструктори и деструктор.
**Жизнен цикъл на обект**:
- Създаване на обект в даден scope – заделя се памет и член-данните се инициализират.
- Достига се до края на скоупа(област).
- Обектът и паметта, която е асоциирана с него се разрушава.
**Конструктор**:
- Извиква се веднъж - при създаването на обекта.
- Не се оказва експлицитно тип на връщане (връща констатна референция).
- Има същото име като класа.
**Деструктор**:
- Извиква се веднъж - при изтриването на обекта.
- Не се оказва експлицитно тип на връщане.
- Има същото име като класа със симовла '~' в началото.
```c++
#include <iostream>
using namespace std;
struct Test
{
Test()
{
cout << "Object is created" <<endl;
}
~Test()
{
cout << "Object is destroyed" <<endl;
}
int a;
int b;
};
int main()
{
while ()
{
Test t;// Object is created
if ()
{
Test t2; // Object is created
}// Object is destroyed (t2)
}//Object is destroyed (t)
}
```
## Капсулация (encapsulation).
Понякога искаме потребителите да **нямат достъп до всички член-данни и методи на даден клас**.
Това е така, защото тяхната промяна може да доведе до **неочаквано поведение** на нашата програма. Принципът за **капсулация** ни помага като позволява да определим кои методи и атрибути може да използват потребителите на нашия клас.
**Модификатор за достъп**:
| Модификатор за достъп: | Достъп: |
|------------------------|---------------------------------|
| private | В текущия клас. |
| protected | В текущия клас и *наследниците. |
| public | За всеки |
**Пример за get-ъри и set-ъри**
```c++
#include <iostream>
using namespace std;
struct Student
{
private:
int grade;
int age;
public:
Student(int grade, int age)
{
setGrade(grade);
setAge(age);
}
int getGrade()
{
return grade;
}
int getAge()
{
return age;
}
void setGrade(int grade)
{
if(grade >= 2 && grade <= 6)
this->grade = grade;
}
int setAge(int age)
{
if(age >= 0)
this->age = age;
}
};
int main()
{
while ()
{
Test t;// Object is created
if ()
{
Test t2; // Object is created
}// Object is destroyed (t2)
}//Object is destroyed (t)
}
```
## Задачи
**Задача 1:**
Реализирайте клас/структура интервал, който представлява интервал [a,b] (задължително а <= b) от реалната права. Нашият интервал ще бъде дискретен - началото и краят му ще бъдат цели числа и ще разглеждаме само точки, които са цели числа. Релизирайте следният интерфейс:
- Подразбиращ се контруктор, който създава интервала **[0,0]**.
- Конструктор, който приема двата параметъра. Ако a<=b, то създава интервала **[a,b]**. В противен случай, създава **[0,0]**.
- Член-функция, която връща **дължината на интервала**.
- Член-функция, която приема число и проверява **дали е част от интервала**.
- Член-функция, която връща **броя на простите числа** в интервала.
- Член-функция, която връща **броя на числата в интервала**, които са палиндорми.
- Член-функция, която връща **броя на числата, които нямат повтарящи цифри**.
- Член-функция, която връща дали началото и края на интервала са **степени на 2-ката**. ([2,16] - истина)
- Член-функция, която приема интервал и връща **сечението на текущия интервал с подадения**. (Сечението на [1, 5] [3, 7] e [3, 5]).
- Член-функция, която приема интервал и връща дали подадения (като параметър) интервал е **подинтервал на текущия**(обектът, от който се извиква функцията).
**Пример за работа с класа:**
```c++
int main()
{
Interval t1(3,10); // [3, 10]
Interval t2(4,14); // [4, 14]
Interval t3; // [0, 0]
Interval result = t1.intersect(t2); // [4, 10]
t2.isSuperInterval(result); //true
result.calcPrimeNumbersInTheInterval() // 2 (only 5 and 7)
}
```
|
