dl
dl_array.h
浏览该文件的文档.
1
13#pragma once
14
15#include <array>
16#include <cassert>
17#include <stdexcept>
18
19#if 1
20namespace dl
21{
22//#define DL_ALIGN16
23//#define DL_ALIGN16 alignas(16)
24
26template<typename T, size_t N>
27class Array
28{
29public:
30 using value_type = T;
32 Array() = default;
33
34 constexpr Array(std::initializer_list<T> data)
35 {
36 size_t i = 0;
37 for (auto iter : data)
38 {
39 _data[i] = iter;
40 ++i;
41 if (i >= N)
42 return;
43 }
44 for (; i < N; ++i)
45 _data[i] = {};
46 }
47 constexpr T& operator[](size_t i)
48 {
49 assert(i < N);
50 return _data[i];
51 }
52 constexpr const T& operator[](size_t i) const
53 {
54 assert(i < N);
55 return _data[i];
56 }
57 constexpr T& at(size_t i)
58 {
59 if (i >= N)
60 throw std::out_of_range();
61 return _data[i];
62 }
63 constexpr const T& at(size_t i) const
64 {
65 if (i >= N)
66 throw std::out_of_range();
67 return _data[i];
68 }
69
70 T* begin() { return &_data[0]; }
71 T* end() { return &_data[N]; }
72 const T* begin() const { return &_data[0]; }
73 const T* end() const { return &_data[N]; }
74 bool empty() const { return false; }
75};
76
77template<typename T>
78 requires std::is_trivial_v<T>
79class Array<T, 2>
80{
81public:
82 using value_type = T;
83 union
84 {
85 T _data[2];
86 struct
87 {
90 };
91 struct
92 {
95 };
96 };
97 Array() = default;
98
99 constexpr Array(std::initializer_list<T> data)
100 {
101 size_t N_LIST = std::size(data);
102 for (size_t i = 0; i < 2; ++i)
103 _data[i] = i < N_LIST ? *(data.begin() + i) : T{};
104 }
105 constexpr const T& Get(size_t i) const
106 {
107 assert(i < 2);
108 return _data[i];
109 }
110 constexpr T& operator[](size_t i)
111 {
112 assert(i < 2);
113 return _data[i];
114 }
115 constexpr const T& operator[](size_t i) const
116 {
117 assert(i < 2);
118 return _data[i];
119 }
120 constexpr T& at(size_t i)
121 {
122 assert(i < 2);
123 if (i < 2)
124 return _data[i];
125 else
126 throw std::out_of_range("dl::Array::at outrange");
127 }
128 constexpr const T& at(size_t i) const
129 {
130 assert(i < 2);
131 if (i < 2)
132 return _data[i];
133 else
134 throw std::out_of_range("dl::Array::at outrange");
135 }
136
137 T* begin() { return &x; }
138 T* end() { return &x + 2; }
139 const T* begin() const { return &x; }
140 const T* end() const { return &x + 2; }
141 bool empty() const { return false; }
142};
143
144template<typename T>
145 requires std::is_trivial_v<T>
146class Array<T, 3>
147{
148public:
149 using value_type = T;
150 union
151 {
153 struct
154 {
158 };
159 struct
160 {
164 };
165 };
166 Array() = default;
167
168 constexpr Array(std::initializer_list<T> data)
169 {
170 size_t N_LIST = std::size(data);
171 for (size_t i = 0; i < 3; ++i)
172 _data[i] = i < N_LIST ? *(data.begin() + i) : T{};
173 }
174 constexpr const T& Get(size_t i) const
175 {
176 assert(i < 3);
177 return _data[i];
178 }
179 constexpr T& operator[](size_t i)
180 {
181 assert(i < 3);
182 return _data[i];
183 }
184 constexpr const T& operator[](size_t i) const
185 {
186 assert(i < 3);
187 return _data[i];
188 }
189 constexpr T& at(size_t i)
190 {
191 assert(i < 3);
192 if (i < 3)
193 return _data[i];
194 else
195 throw std::out_of_range();
196 }
197 constexpr const T& at(size_t i) const
198 {
199 assert(i < 3);
200 if (i < 3)
201 return _data[i];
202 else
203 throw std::out_of_range();
204 }
205
206 T* begin() { return &x; }
207 T* end() { return &x + 3; }
208 const T* begin() const { return &x; }
209 const T* end() const { return &x + 3; }
210 bool empty() const { return false; }
211};
212
213template<typename T>
214 requires std::is_trivial_v<T>
215class Array<T, 4>
216{
217public:
218 using value_type = T;
219 union
220 {
222 struct
223 {
228 };
229 struct
230 {
235 };
236 };
237 Array() = default;
238
239 constexpr Array(std::initializer_list<T> data)
240 {
241 size_t N_LIST = std::size(data);
242 for (size_t i = 0; i < 4; ++i)
243 _data[i] = i < N_LIST ? *(data.begin() + i) : T{};
244 }
245 constexpr const T& Get(size_t i) const
246 {
247 assert(i < 4);
248 return _data[i];
249 }
250 constexpr T Sum(size_t i, size_t j) const
251 {
252 assert(i < 4);
253 assert(j < 4);
254 return _data[i] + _data[j];
255 }
256 constexpr T& operator[](size_t i)
257 {
258 assert(i < 4);
259 return _data[i];
260 }
261 constexpr const T& operator[](size_t i) const
262 {
263 assert(i < 4);
264 return _data[i];
265 }
266 constexpr T& at(size_t i)
267 {
268 assert(i < 4);
269 if (i < 4)
270 return _data[i];
271 else
272 throw std::out_of_range();
273 }
274 constexpr const T& at(size_t i) const
275 {
276 assert(i < 4);
277 if (i < 4)
278 return _data[i];
279 else
280 throw std::out_of_range();
281 }
282
283 T* begin() { return &x; }
284 T* end() { return &x + 4; }
285 const T* begin() const { return &x; }
286 const T* end() const { return &x + 4; }
287 bool empty() const { return false; }
288};
289
290template<typename T>
291class Array<T, 0>
292{
293public:
294 using value_type = T;
296 Array() = default;
297
298 constexpr Array(std::initializer_list<T> data)
299 {
300 }
301 constexpr T& operator[](size_t i)
302 {
303 return *begin();
304 }
305 constexpr const T& operator[](size_t i) const
306 {
307 return *begin();
308 }
309 constexpr T& at(size_t i)
310 {
311 throw std::out_of_range();
312 }
313 constexpr const T& at(size_t i) const
314 {
315 throw std::out_of_range();
316 }
317
318 T* begin() { return nullptr; }
319 T* end() { return nullptr; }
320 const T* begin() const { return nullptr; }
321 const T* end() const { return nullptr; }
322 bool empty() const { return true; }
323};
324
325template<typename T, size_t N>
326constexpr bool operator==(const Array<T, N>& a, const Array<T, N>& b)
327{
328 for (size_t i = 0; i < N; ++i)
329 {
330 if (a[i] != b[i])
331 return false;
332 }
333 return true;
334}
335}
336#else
337template<typename T, size_t N>
338using Array = std::array<T, N>;
339#endif
340
constexpr const T & at(size_t i) const
constexpr Array(std::initializer_list< T > data)
constexpr const T & operator[](size_t i) const
constexpr T & at(size_t i)
constexpr const T & Get(size_t i) const
constexpr const T & operator[](size_t i) const
constexpr const T & at(size_t i) const
constexpr T & operator[](size_t i)
constexpr T & operator[](size_t i)
const T * end() const
constexpr T & operator[](size_t i)
constexpr const T & at(size_t i) const
const T * end() const
Array()=default
const T * begin() const
bool empty() const
const T * end() const
constexpr T & at(size_t i)
constexpr Array(std::initializer_list< T > data)
constexpr const T & operator[](size_t i) const
constexpr const T & operator[](size_t i) const
constexpr T & at(size_t i)
constexpr const T & at(size_t i) const
const T * begin() const
constexpr T & at(size_t i)
constexpr const T & at(size_t i) const
constexpr const T & Get(size_t i) const
constexpr const T & operator[](size_t i) const
constexpr const T & Get(size_t i) const
constexpr Array(std::initializer_list< T > data)
constexpr T & operator[](size_t i)
constexpr T Sum(size_t i, size_t j) const
constexpr Array(std::initializer_list< T > data)
constexpr Array(std::initializer_list< T > data)
const T * begin() const
constexpr T & operator[](size_t i)
const T * end() const
const T * end() const
constexpr T & at(size_t i)
const T * begin() const
const T * begin() const
constexpr bool operator==(const Array< T, N > &a, const Array< T, N > &b)