blob: eaf790b73dd2a93267515393690a5634f76e6feb (
plain) (
blame)
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
|
#include <iostream>
#include <exception>
template <typename T>
class MyQueue
{
T* data;
size_t capacity;
size_t size;
size_t get;
size_t put;
void resize();
void copyFrom(const MyQueue<T>& other);
void free();
public:
MyQueue();
MyQueue(const MyQueue<T>& other);
MyQueue<T>& operator=(const MyQueue<T>& other);
void push(const T& obj);
void push(T&& obj); //позволява и местене
void pop();
const T& peek() const;
bool isEmpty() const;
~MyQueue();
};
template <typename T>
MyQueue<T>::MyQueue()
{
capacity = 4;
data = new T[capacity];
size = 0;
get = put = 0;
}
template <typename T>
void MyQueue<T>::push(const T& obj)
{
if (size == capacity)
resize();
data[put] = obj; //operator=
(++put) %= capacity;
size++;
}
template <typename T>
void MyQueue<T>::push(T&& obj)
{
if (size == capacity)
resize();
data[put] = std::move(obj); //move operator =
(++put) %= capacity;
size++;
}
template <typename T>
bool MyQueue<T>::isEmpty() const
{
return size == 0;
}
template <typename T>
const T& MyQueue<T>::peek() const
{
if (isEmpty())
throw std::logic_error("Empty queue!");
return data[get];
}
template <typename T>
void MyQueue<T>::pop()
{
if (isEmpty())
throw std::logic_error("Empty queue!");
(++get) %= capacity;
size--;
}
template <typename T>
void MyQueue<T>::resize()
{
T* resizedData = new T[capacity * 2];
for (size_t i = 0; i < size; i++)
{
resizedData[i] = data[get];
(++get) %= capacity;
}
capacity *= 2;
delete[] data;
data = resizedData;
get = 0;
put = size;
}
template <typename T>
void MyQueue<T>::copyFrom(const MyQueue<T>& other)
{
data = new T[other.capacity];
for (int i = 0; i < other.capacity; i++)
data[i] = other.data[i];
get = other.get;
put = other.put;
size = other.size;
capacity = other.capacity;
}
template <typename T>
void MyQueue<T>::free()
{
delete[] data;
}
template <typename T>
MyQueue<T>::MyQueue(const MyQueue<T>& other)
{
copyFrom(other);
}
template <typename T>
MyQueue<T>& MyQueue<T>::operator=(const MyQueue<T>& other)
{
if (this != &other)
{
free();
copyFrom(other);
}
return *this;
}
template <typename T>
MyQueue<T>::~MyQueue()
{
free();
}
|
