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