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
|
# Композиция на обекти. Шаблони.
## Композиция
Композиция – класове като елементи на други класове (влагане на класове) Един клас може да включва в себе си обекти от други класове като член-данни. Когато обект от даден клас се дефинира, автоматично се извиква неговият конструктор. Ако класът съдържа член-данни, в неговия конструктор трябва да се укаже кои конструктори на член-данните да се извикват.
#### Пример 1
```c++
class A
{
.
.
.
}
class B
{
int n;
A obj;
}
```
В тази ситуация се извикват **default-ните те конструктори на n и obj**.
#### Пример 2
```c++
class A
{
A(int a, int b)
.
.
.
}
class B
{
B() : A(1, 2)
{}
int n;
A obj;
}
```
Тук A няма default-ен конструктор. Това означава, че в конструктора на B трябва да се извика **експлицитно** някой от неговите конструктори
### Композиция на обекти с динамична памет
Когато имаме композиция и в главния клас има динамично заделяне на памет, то трябва в реализацията на копи-конструктора и оператор= **експлицитно** да се извикват копи-конструкторите и оператора = за всички член-данни (композирани обекти).
```c++
class B;
class A
{
void copyFrom(const A& other)
{
arr = new int[other.size];
for (int i = 0; i < other.size; i++)
arr[i] = other.arr[i];
size = other.size;
}
void free()
{
delete[] arr;
}
public:
B nestedObject;
int* arr; //dynamic array
size_t size;
A(int n) : size(n)
{
arr = new int[n];
}
A(const A& other) : nestedObject(other.objTest), size(other.size)
{
copyFrom(other);
}
A& operator=(const A& other)
{
if (this != &other)
{
free();
nestedObject= other.nestedObject;
size = other.size;
copyFrom(other);
}
return *this;
}
~A()
{
free();
}
};
```
**ВАЖНО**: Деструкторите на член-данните **НЕ** трябва да се извикват експлицитно в деструктора на класа.
## Шаблони
Функция/клас, която работи не с променливи от някакъв дефиниран тип, а с абстрактни променливи, се нарича шаблонна функция/клас
```c++
#include <iostream>
using namespace std;
template <class T>
T sum(const T& a, const T& b)
{
return a + b;
}
int main()
{
int a = 4;
int b = 9;
cout << sum<int>(a, b) << endl;
double c = 3.14;
double d = 4.5;
cout << sum<double>(c,d) << endl;
return 0;
}
```
Компилаторът генерира т. нар. шаблонна функция, като замества параметрите на шаблона с типовете на съответните фактически параметри.
**Задача 1:**
Релизирайте структурата от данни опашка. Опашката трябва да работи с **произволни типове**. След като е добавен един елемент в края на опашката, той ще може да бъде извлечен (премахнат) единствено след като бъдат премахнати всички елементи преди него в реда, в който са добавени.
**Пример**:
```c++
int main()
{
quene<int> q;
q.push(3);
q.push(5);
q.push(10);
cout << q.peek() << endl; //3
q.pop();
cout << q.peek() << endl; //5
q.pop();
cout << q.peek() << endl; //10
q.pop();
cout << q.isEmpty() << endl; //1
}
```
**Задача 2:**
Създайте **шаблонна** опашка с k приоритета. При взимане на елемент от опашката трябва да се връща най-отдавна добавения елемент от тези с най-висок приоритет. **Важно:** Използвайте имплементацията на опашка от предната задача!
```c++
int main()
{
kPriorityQueue<char> q(4); // 4 priorities - 0, 1, 2 и 3.
q.push('A',0): //adds A with lowest priority: 0
q.push('B',3);
q.push('C',2);
q.push('D',2);
q.push('E',1);
//q.push('F', 5); //error! No such priority!
q.peek(); // B
q.pop();
q.peek(); // C
q.pop();
q.peek(); // D
q.pop();
q.peek(); // E
q.pop();
q.peek(); // A
q.pop();
}
```
|
