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
|
#pragma once
template <class T, class U>
class TwoArray {
T* first;
U* second;
unsigned allocated;
unsigned size;
void free();
void copyFrom(const TwoArray& other);
public:
TwoArray();
~TwoArray();
TwoArray(const TwoArray& other);
TwoArray& operator=(const TwoArray& other);
TwoArray(TwoArray&& other);
TwoArray& operator=(TwoArray&& other);
T& operator[](int index);
const T& operator[](int index) const;
U& operator()(int index);
const U& operator()(int index) const;
};
template <class T, class U>
void TwoArray<T, U>::free() {
delete[] first;
delete[] second;
}
template <class T, class U>
void TwoArray<T, U>::copyFrom(const TwoArray& other) {
this->size = other.size;
this->allocated = other.allocated;
first = new T[allocated];
second = new U[allocated];
for (int i = 0; i < size; i++) {
first[i] = other.first[i];
second[i] = other.second[i];
}
}
template <class T, class U>
TwoArray<T, U>::TwoArray() {
first = second = nullptr;
size = allocated = 0;
}
template <class T, class U>
TwoArray<T, U>::~TwoArray() {
free();
}
template <class T, class U>
TwoArray<T, U>::TwoArray(const TwoArray& other) {
copyFrom(other);
}
template <class T, class U>
TwoArray<T, U>& TwoArray<T, U>::operator=(const TwoArray& other) {
if (this != &other) {
free();
copyFrom(other);
}
return *this;
}
template <class T, class U>
TwoArray<T, U>::TwoArray(TwoArray&& other) {
this->first = other.first;
other.first = nullptr;
this->second = other.second;
other.second = nullptr;
this->allocated = other.allocated;
this->size = other.size;
}
template <class T, class U>
TwoArray<T, U>& TwoArray<T, U>::operator=(TwoArray&& other) {
if (this != &other) {
free();
this->first = other.first;
other.first = nullptr;
this->second = other.second;
other.second = nullptr;
this->allocated = other.allocated;
this->size = other.size;
}
return *this;
}
template <class T, class U>
T& TwoArray<T, U>::operator[](int index) {
if (index < 0 || index >= size) throw "Invalid index!";
return first[index];
}
template <class T, class U>
const T& TwoArray<T, U>::operator[](int index) const {
if (index < 0 || index >= size) throw "Invalid index!";
return first[index];
}
template <class T, class U>
U& TwoArray<T, U>::operator()(int index) {
if (index < 0 || index >= size) throw "Invalid index!";
return second[index];
}
template <class T, class U>
const U& TwoArray<T, U>::operator()(int index) const {
if (index < 0 || index >= size) throw "Invalid index!";
return second[index];
}
|
