|
|
|
1 |
|
// array TR1 header |
2 |
|
#pragma once |
3 |
|
#ifndef _ARRAY_ |
4 |
|
#define _ARRAY_ |
5 |
|
#ifndef RC_INVOKED |
6 |
|
#include <algorithm> |
7 |
|
#include <iterator> |
8 |
|
|
9 |
|
#pragma pack(push,_CRT_PACKING) |
10 |
|
#pragma warning(push,3) |
11 |
|
#pragma warning(disable: 4284) |
12 |
|
#pragma warning(disable: 4996) |
13 |
|
|
14 |
|
_STD_BEGIN |
15 |
|
namespace tr1 { // TR1 additions |
16 |
|
|
17 |
|
_CRTIMP2_PURE __declspec(noreturn) void __CLRCALL_PURE_OR_CDECL _Xoutrange(); |
18 |
|
|
19 |
|
// static_assert |
20 |
|
template<bool expr> |
21 |
|
struct _Assert_failed; |
22 |
|
template<> |
23 |
|
struct _Assert_failed<true> |
24 |
|
{ // specialize for true |
25 |
|
}; |
26 |
|
|
27 |
|
#define _Assert_static(EXPR) \ |
28 |
|
enum {static_assert_failure = sizeof (_Assert_failed<(bool)(EXPR)>)} |
29 |
|
|
30 |
|
template<class _Ty, |
31 |
|
size_t _Size> |
32 |
|
class array; |
33 |
|
|
34 |
|
// TEMPLATE CLASS _Array_const_iterator |
35 |
|
template<class _Ty, |
36 |
|
size_t _Size> |
37 |
|
class _Array_const_iterator |
38 |
|
: public _Iterator_base_universal |
39 |
|
{ // iterator for nonmutable array |
40 |
|
public: |
41 |
|
typedef _Array_const_iterator<_Ty, _Size> _Myiter; |
42 |
|
typedef array<_Ty, _Size> _Myarr; |
43 |
|
typedef random_access_iterator_tag iterator_category; |
44 |
|
|
45 |
|
typedef typename _Myarr::pointer _Tptr; |
46 |
|
typedef typename _Myarr::value_type value_type; |
47 |
|
typedef typename _Myarr::size_type size_type; |
48 |
|
typedef typename _Myarr::difference_type difference_type; |
49 |
|
typedef typename _Myarr::const_pointer pointer; |
50 |
|
typedef typename _Myarr::const_reference reference; |
51 |
|
|
52 |
|
_Array_const_iterator() |
53 |
|
{ // construct with null pointer |
54 |
|
_Ptr = 0; |
55 |
|
_Idx = 0; |
56 |
|
} |
57 |
|
|
58 |
|
_Array_const_iterator(_Tptr _Parg, size_t _Off) |
59 |
|
{ // construct with pointer and offset |
60 |
|
_Ptr = _Parg; |
61 |
|
_Idx = _Off; |
62 |
|
} |
63 |
|
|
64 |
|
enum {_EEN_SIZE = _Size}; // helper for expression evaluator |
65 |
|
|
66 |
|
typedef _Range_checked_iterator_tag _Checked_iterator_category; |
67 |
|
typedef value_type _Inner_type; |
68 |
|
typedef pointer _Checked_iterator_base_type; |
69 |
|
|
70 |
|
_Checked_iterator_base_type _Checked_iterator_base() const |
71 |
|
{ // get unchecked version of iterator |
72 |
|
return (_Ptr + _Idx); |
73 |
|
} |
74 |
|
|
75 |
|
void _Checked_iterator_assign_from_base(_Checked_iterator_base_type _Iter) |
76 |
|
{ // resync with unchecked version |
77 |
|
_Idx = _Iter - _Ptr; |
78 |
|
} |
79 |
|
|
80 |
|
reference operator*() const |
81 |
|
{ // return designated object |
82 |
|
#if _HAS_ITERATOR_DEBUGGING |
83 |
|
if (_Ptr == 0 |
84 |
|
|| _Size <= _Idx) |
85 |
|
{ // report error |
86 |
|
_DEBUG_ERROR("array iterator not dereferencable"); |
87 |
|
_SCL_SECURE_OUT_OF_RANGE; |
88 |
|
} |
89 |
|
#endif /* _HAS_ITERATOR_DEBUGGING */ |
90 |
|
|
91 |
|
_SCL_SECURE_VALIDATE(_Ptr != 0); |
92 |
|
_SCL_SECURE_VALIDATE_RANGE(_Idx < _Size); |
93 |
|
|
94 |
|
return (_Ptr[_Idx]); |
95 |
|
} |
96 |
|
|
97 |
|
pointer operator->() const |
98 |
|
{ // return pointer to class object |
99 |
|
return (&**this); |
100 |
|
} |
101 |
|
|
102 |
|
_Myiter& operator++() |
103 |
|
{ // preincrement |
104 |
|
#if _HAS_ITERATOR_DEBUGGING |
105 |
|
if (_Ptr == 0 |
106 |
|
|| _Size <= _Idx) |
107 |
|
{ // report error |
108 |
|
_DEBUG_ERROR("array iterator not incrementable"); |
109 |
|
_SCL_SECURE_OUT_OF_RANGE; |
110 |
|
} |
111 |
|
#endif /* _HAS_ITERATOR_DEBUGGING */ |
112 |
|
|
113 |
|
_SCL_SECURE_VALIDATE(_Ptr != 0); |
114 |
|
_SCL_SECURE_VALIDATE_RANGE(_Idx < _Size); |
115 |
|
|
116 |
|
++_Idx; |
117 |
|
return (*this); |
118 |
|
} |
119 |
|
|
120 |
|
_Myiter operator++(int) |
121 |
|
{ // postincrement |
122 |
|
_Myiter _Tmp = *this; |
123 |
|
++*this; |
124 |
|
return (_Tmp); |
125 |
|
} |
126 |
|
|
127 |
|
_Myiter& operator--() |
128 |
|
{ // predecrement |
129 |
|
#if _HAS_ITERATOR_DEBUGGING |
130 |
|
if (_Ptr == 0 |
131 |
|
|| _Idx <= 0) |
132 |
|
{ // report error |
133 |
|
_DEBUG_ERROR("array iterator not decrementable"); |
134 |
|
_SCL_SECURE_OUT_OF_RANGE; |
135 |
|
} |
136 |
|
#endif /* _HAS_ITERATOR_DEBUGGING */ |
137 |
|
|
138 |
|
_SCL_SECURE_VALIDATE(_Ptr != 0); |
139 |
|
_SCL_SECURE_VALIDATE_RANGE(0 < _Idx); |
140 |
|
|
141 |
|
--_Idx; |
142 |
|
return (*this); |
143 |
|
} |
144 |
|
|
145 |
|
_Myiter operator--(int) |
146 |
|
{ // postdecrement |
147 |
|
_Myiter _Tmp = *this; |
148 |
|
--*this; |
149 |
|
return (_Tmp); |
150 |
|
} |
151 |
|
|
152 |
|
_Myiter& operator+=(difference_type _Off) |
153 |
|
{ // increment by integer |
154 |
|
_Idx += _Off; |
155 |
|
return (*this); |
156 |
|
} |
157 |
|
|
158 |
|
_Myiter operator+(difference_type _Off) const |
159 |
|
{ // return this + integer |
160 |
|
_Myiter _Tmp = *this; |
161 |
|
return (_Tmp += _Off); |
162 |
|
} |
163 |
|
|
164 |
|
_Myiter& operator-=(difference_type _Off) |
165 |
|
{ // decrement by integer |
166 |
|
return (*this += -_Off); |
167 |
|
} |
168 |
|
|
169 |
|
_Myiter operator-(difference_type _Off) const |
170 |
|
{ // return this - integer |
171 |
|
_Myiter _Tmp = *this; |
172 |
|
return (_Tmp -= _Off); |
173 |
|
} |
174 |
|
|
175 |
|
difference_type operator-(const _Myiter& _Right) const |
176 |
|
{ // return difference of iterators |
177 |
|
_Compat(_Right); |
178 |
|
return (_Idx < _Right._Idx |
179 |
|
? -(difference_type)(_Right._Idx - _Idx) |
180 |
|
: (difference_type)_Idx - _Right._Idx); |
181 |
|
} |
182 |
|
|
183 |
|
reference operator[](difference_type _Off) const |
184 |
|
{ // subscript |
185 |
|
return (*(*this + _Off)); |
186 |
|
} |
187 |
|
|
188 |
|
bool operator==(const _Myiter& _Right) const |
189 |
|
{ // test for iterator equality |
190 |
|
_Compat(_Right); |
191 |
|
return (_Idx == _Right._Idx); |
192 |
|
} |
193 |
|
|
194 |
|
bool operator!=(const _Myiter& _Right) const |
195 |
|
{ // test for iterator inequality |
196 |
|
return (!(*this == _Right)); |
197 |
|
} |
198 |
|
|
199 |
|
bool operator<(const _Myiter& _Right) const |
200 |
|
{ // test if this < _Right |
201 |
|
_Compat(_Right); |
202 |
|
return (_Idx < _Right._Idx); |
203 |
|
} |
204 |
|
|
205 |
|
bool operator>(const _Myiter& _Right) const |
206 |
|
{ // test if this > _Right |
207 |
|
return (_Right < *this); |
208 |
|
} |
209 |
|
|
210 |
|
bool operator<=(const _Myiter& _Right) const |
211 |
|
{ // test if this <= _Right |
212 |
|
return (!(_Right < *this)); |
213 |
|
} |
214 |
|
|
215 |
|
bool operator>=(const _Myiter& _Right) const |
216 |
|
{ // test if this >= _Right |
217 |
|
return (!(*this < _Right)); |
218 |
|
} |
219 |
|
|
220 |
|
void _Compat(const _Myiter& _Right) const |
221 |
|
{ // test for compatible iterator pair |
222 |
|
#if _HAS_ITERATOR_DEBUGGING |
223 |
|
if (_Ptr != _Right._Ptr) |
224 |
|
{ // report error |
225 |
|
_DEBUG_ERROR("array iterators incompatible"); |
226 |
|
_SCL_SECURE_INVALID_ARGUMENT; |
227 |
|
} |
228 |
|
#endif /* _HAS_ITERATOR_DEBUGGING */ |
229 |
|
|
230 |
|
_SCL_SECURE_VALIDATE_RANGE(_Ptr == _Right._Ptr); |
231 |
|
} |
232 |
|
|
233 |
|
_Tptr _Ptr; // beginning of array |
234 |
|
size_t _Idx; // offset into array |
235 |
|
}; |
236 |
|
|
237 |
|
template<class _Ty, |
238 |
|
size_t _Size> inline |
239 |
|
_Array_const_iterator<_Ty, _Size> operator+( |
240 |
|
typename _Array_const_iterator<_Ty, _Size>::difference_type _Off, |
241 |
|
_Array_const_iterator<_Ty, _Size> _Next) |
242 |
|
{ // add offset to iterator |
243 |
|
return (_Next += _Off); |
244 |
|
} |
245 |
|
|
246 |
|
// TEMPLATE CLASS _Array_iterator |
247 |
|
template<class _Ty, |
248 |
|
size_t _Size> |
249 |
|
class _Array_iterator |
250 |
|
: public _Array_const_iterator<_Ty, _Size> |
251 |
|
{ // iterator for mutable array |
252 |
|
public: |
253 |
|
typedef _Array_iterator<_Ty, _Size> _Myiter; |
254 |
|
typedef _Array_const_iterator<_Ty, _Size> _Mybase; |
255 |
|
typedef array<_Ty, _Size> _Myarr; |
256 |
|
typedef random_access_iterator_tag iterator_category; |
257 |
|
|
258 |
|
typedef typename _Myarr::value_type value_type; |
259 |
|
typedef typename _Myarr::size_type size_type; |
260 |
|
typedef typename _Myarr::difference_type difference_type; |
261 |
|
typedef typename _Myarr::pointer pointer; |
262 |
|
typedef typename _Myarr::reference reference; |
263 |
|
|
264 |
|
_Array_iterator() |
265 |
|
{ // construct with null pointer |
266 |
|
} |
267 |
|
|
268 |
|
_Array_iterator(pointer _Parg, size_t _Off) |
269 |
|
: _Mybase(_Parg, _Off) |
270 |
|
{ // construct with pointer and offset |
271 |
|
} |
272 |
|
|
273 |
|
enum {_EEN_SIZE = _Size}; // helper for expression evaluator |
274 |
|
|
275 |
|
typedef _Range_checked_iterator_tag _Checked_iterator_category; |
276 |
|
typedef _Ty _Inner_type; |
277 |
|
typedef pointer _Checked_iterator_base_type; |
278 |
|
|
279 |
|
_Checked_iterator_base_type _Checked_iterator_base() const |
280 |
|
{ // get unchecked version of iterator |
281 |
|
return (this->_Ptr + this->_Idx); |
282 |
|
} |
283 |
|
|
284 |
|
void _Checked_iterator_assign_from_base(_Checked_iterator_base_type _Iter) |
285 |
|
{ // resync with unchecked version |
286 |
|
this->_Idx = _Iter - this->_Ptr; |
287 |
|
} |
288 |
|
|
289 |
|
reference operator*() const |
290 |
|
{ // return designated object |
291 |
|
return ((reference)**(_Mybase *)this); |
292 |
|
} |
293 |
|
|
294 |
|
pointer operator->() const |
295 |
|
{ // return pointer to class object |
296 |
|
return (&**this); |
297 |
|
} |
298 |
|
|
299 |
|
_Myiter& operator++() |
300 |
|
{ // preincrement |
301 |
|
++*(_Mybase *)this; |
302 |
|
return (*this); |
303 |
|
} |
304 |
|
|
305 |
|
_Myiter operator++(int) |
306 |
|
{ // postincrement |
307 |
|
_Myiter _Tmp = *this; |
308 |
|
++*this; |
309 |
|
return (_Tmp); |
310 |
|
} |
311 |
|
|
312 |
|
_Myiter& operator--() |
313 |
|
{ // predecrement |
314 |
|
--*(_Mybase *)this; |
315 |
|
return (*this); |
316 |
|
} |
317 |
|
|
318 |
|
_Myiter operator--(int) |
319 |
|
{ // postdecrement |
320 |
|
_Myiter _Tmp = *this; |
321 |
|
--*this; |
322 |
|
return (_Tmp); |
323 |
|
} |
324 |
|
|
325 |
|
_Myiter& operator+=(difference_type _Off) |
326 |
|
{ // increment by integer |
327 |
|
*(_Mybase *)this += _Off; |
328 |
|
return (*this); |
329 |
|
} |
330 |
|
|
331 |
|
_Myiter operator+(difference_type _Off) const |
332 |
|
{ // return this + integer |
333 |
|
_Myiter _Tmp = *this; |
334 |
|
return (_Tmp += _Off); |
335 |
|
} |
336 |
|
|
337 |
|
_Myiter& operator-=(difference_type _Off) |
338 |
|
{ // decrement by integer |
339 |
|
return (*this += -_Off); |
340 |
|
} |
341 |
|
|
352 |
|
|
353 |
|
reference operator[](difference_type _Off) const |
354 |
|
{ // subscript |
355 |
|
return (*(*this + _Off)); |
356 |
|
} |
357 |
|
}; |
358 |
|
|
359 |
|
template<class _Ty, |
360 |
|
size_t _Size> inline |
361 |
|
_Array_iterator<_Ty, _Size> operator+( |
362 |
|
typename _Array_iterator<_Ty, _Size>::difference_type _Off, |
363 |
|
_Array_iterator<_Ty, _Size> _Next) |
364 |
|
{ // add offset to iterator |
365 |
|
return (_Next += _Off); |
366 |
|
} |
367 |
|
|
368 |
|
// TEMPLATE CLASS array |
369 |
|
template<class _Ty, |
370 |
|
size_t _Size> |
371 |
|
class array |
372 |
|
{ // fixed size array of values |
373 |
|
public: |
374 |
|
enum {_EEN_SIZE = _Size}; // helper for expression evaluator |
375 |
|
|
376 |
|
typedef array<_Ty, _Size> _Myt; |
377 |
|
typedef _Ty value_type; |
378 |
|
typedef size_t size_type; |
379 |
|
typedef ptrdiff_t difference_type; |
380 |
|
typedef _Ty *pointer; |
381 |
|
typedef const _Ty *const_pointer; |
382 |
|
typedef _Ty& reference; |
383 |
|
typedef const _Ty& const_reference; |
384 |
|
|
385 |
|
typedef _Array_iterator<_Ty, _Size> iterator; |
386 |
|
typedef _Array_const_iterator<_Ty, _Size> const_iterator; |
387 |
|
|
388 |
|
typedef std::reverse_iterator<iterator> reverse_iterator; |
389 |
|
typedef std::reverse_iterator<const_iterator> const_reverse_iterator; |
390 |
|
|
391 |
|
void assign(const _Ty& _Value) |
392 |
|
{ // assign value to all elements |
393 |
|
std::fill_n(_Elems, _Size, _Value); |
394 |
|
} |
395 |
|
|
396 |
|
void swap(_Myt& _Other) |
397 |
|
{ // swap contents with _Other |
398 |
|
std::swap_ranges(_Other.begin(), _Other.end(), begin()); |
399 |
|
} |
400 |
|
|
401 |
|
iterator begin() |
402 |
|
{ // return iterator for beginning of mutable sequence |
403 |
|
return (iterator(&_Elems[0], 0)); |
404 |
|
} |
405 |
|
|
406 |
|
const_iterator begin() const |
407 |
|
{ // return iterator for beginning of nonmutable sequence |
408 |
|
return (const_iterator((pointer)&_Elems[0], 0)); |
409 |
|
} |
410 |
|
|
411 |
|
iterator end() |
412 |
|
{ // return iterator for end of mutable sequence |
413 |
|
return (iterator(&_Elems[0], _Size)); |
414 |
|
} |
415 |
|
|
416 |
|
const_iterator end() const |
417 |
|
{ // return iterator for beginning of nonmutable sequence |
418 |
|
return (const_iterator((pointer)&_Elems[0], _Size)); |
419 |
|
} |
420 |
|
|
421 |
|
reverse_iterator rbegin() |
422 |
|
{ // return iterator for beginning of reversed mutable sequence |
423 |
|
return (reverse_iterator(end())); |
424 |
|
} |
425 |
|
|
426 |
|
const_reverse_iterator rbegin() const |
427 |
|
{ // return iterator for beginning of reversed nonmutable sequence |
428 |
|
return (const_reverse_iterator(end())); |
429 |
|
} |
430 |
|
|
431 |
|
reverse_iterator rend() |
432 |
|
{ // return iterator for end of reversed mutable sequence |
433 |
|
return (reverse_iterator(begin())); |
434 |
|
} |
435 |
|
|
436 |
|
const_reverse_iterator rend() const |
437 |
|
{ // return iterator for end of reversed nonmutable sequence |
438 |
|
return (const_reverse_iterator(begin())); |
439 |
|
} |
440 |
|
|
441 |
|
size_type size() const |
442 |
|
{ // return length of sequence |
443 |
|
return (_Size); |
444 |
|
} |
445 |
|
|
446 |
|
size_type max_size() const |
447 |
|
{ // return maximum possible length of sequence |
448 |
|
return (_Size); |
449 |
|
} |
450 |
|
|
451 |
|
bool empty() const |
452 |
|
{ // test if sequence is empty |
453 |
|
return (_Size == 0); |
454 |
|
} |
455 |
|
|
456 |
|
reference at(size_type _Pos) |
457 |
|
{ // subscript mutable sequence with checking |
458 |
|
if (_Size <= _Pos) |
459 |
|
_Xoutrange(); |
460 |
|
return (_Elems[_Pos]); |
461 |
|
} |
462 |
|
|
463 |
|
const_reference at(size_type _Pos) const |
464 |
|
{ // subscript nonmutable sequence with checking |
465 |
|
if (_Size <= _Pos) |
466 |
|
_Xoutrange(); |
467 |
|
return (_Elems[_Pos]); |
468 |
|
} |
469 |
|
|
470 |
|
reference operator[](size_type _Pos) |
471 |
|
{ // subscript mutable sequence |
472 |
|
#if _HAS_ITERATOR_DEBUGGING |
473 |
|
if (_Size <= _Pos) |
474 |
|
_DEBUG_ERROR("array subscript out of range"); |
475 |
|
#endif /* _HAS_ITERATOR_DEBUGGING */ |
476 |
|
|
477 |
|
_SCL_SECURE_VALIDATE_RANGE(_Pos < _Size); |
478 |
|
|
479 |
|
return (_Elems[_Pos]); |
480 |
|
} |
481 |
|
|
482 |
|
const_reference operator[](size_type _Pos) const |
483 |
|
{ // subscript nonmutable sequence |
484 |
|
#if _HAS_ITERATOR_DEBUGGING |
485 |
|
if (_Size <= _Pos) |
486 |
|
_DEBUG_ERROR("array subscript out of range"); |
487 |
|
#endif /* _HAS_ITERATOR_DEBUGGING */ |
488 |
|
|
489 |
|
_SCL_SECURE_VALIDATE_RANGE(_Pos < _Size); |
490 |
|
|
491 |
|
return (_Elems[_Pos]); |
492 |
|
} |
493 |
|
|
494 |
|
reference front() |
495 |
|
{ // return first element of mutable sequence |
496 |
|
#if _HAS_ITERATOR_DEBUGGING |
497 |
|
if (_Size == 0) |
498 |
|
_DEBUG_ERROR("array<T, 0>::front() invalid"); |
499 |
|
#endif /* _HAS_ITERATOR_DEBUGGING */ |
500 |
|
|
501 |
|
_SCL_SECURE_VALIDATE_RANGE(0 < _Size); |
502 |
|
|
503 |
|
return (_Elems[0]); |
504 |
|
} |
505 |
|
|
506 |
|
const_reference front() const |
507 |
|
{ // return first element of nonmutable sequence |
508 |
|
#if _HAS_ITERATOR_DEBUGGING |
509 |
|
if (_Size == 0) |
510 |
|
_DEBUG_ERROR("array<T, 0>::front() invalid"); |
511 |
|
#endif /* _HAS_ITERATOR_DEBUGGING */ |
512 |
|
|
513 |
|
_SCL_SECURE_VALIDATE_RANGE(0 < _Size); |
514 |
|
|
515 |
|
return (_Elems[0]); |
516 |
|
} |
517 |
|
|
518 |
|
reference back() |
519 |
|
{ // return last element of mutable sequence |
520 |
|
#if _HAS_ITERATOR_DEBUGGING |
521 |
|
if (_Size == 0) |
522 |
|
_DEBUG_ERROR("array<T, 0>::back() invalid"); |
523 |
|
#endif /* _HAS_ITERATOR_DEBUGGING */ |
524 |
|
|
525 |
|
_SCL_SECURE_VALIDATE_RANGE(0 < _Size); |
526 |
|
|
527 |
|
return (_Elems[_Size - 1]); |
528 |
|
} |
529 |
|
|
530 |
|
const_reference back() const |
531 |
|
{ // return last element of nonmutable sequence |
532 |
|
#if _HAS_ITERATOR_DEBUGGING |
533 |
|
if (_Size == 0) |
534 |
|
_DEBUG_ERROR("array<T, 0>::back() invalid"); |
535 |
|
#endif /* _HAS_ITERATOR_DEBUGGING */ |
536 |
|
|
537 |
|
_SCL_SECURE_VALIDATE_RANGE(0 < _Size); |
538 |
|
|
539 |
|
return (_Elems[_Size - 1]); |
540 |
|
} |
541 |
|
|
542 |
|
_Ty *data() |
543 |
|
{ // return pointer to mutable data array |
544 |
|
return (_Elems); |
545 |
|
} |
546 |
|
|
547 |
|
const _Ty *data() const |
548 |
|
{ // return pointer to nonmutable data array |
549 |
|
return (_Elems); |
550 |
|
} |
551 |
|
|
552 |
|
_Ty _Elems[_Size == 0 ? 1 : _Size]; |
553 |
|
}; |
554 |
|
|
555 |
|
template<class _Ty, |
556 |
|
size_t _Size> |
557 |
|
void swap(array<_Ty,_Size>& _Left, |
558 |
|
array<_Ty,_Size>& _Right) |
559 |
|
{ // swap arrays |
560 |
|
return (_Left.swap(_Right)); |
561 |
|
} |
562 |
|
|
563 |
|
template<class _Ty, |
564 |
|
size_t _Size> |
565 |
|
bool operator==(const array<_Ty,_Size>& _Left, |
566 |
|
const array<_Ty,_Size>& _Right) |
567 |
|
{ // test for array equality |
568 |
|
return (std::equal(_Left.begin(), _Left.end(), _Right.begin())); |
569 |
|
} |
570 |
|
|
571 |
|
template<class _Ty, |
572 |
|
size_t _Size> |
573 |
|
bool operator!=(const array<_Ty,_Size>& _Left, |
574 |
|
const array<_Ty,_Size>& _Right) |
575 |
|
{ // test for array inequality |
576 |
|
return (!(_Left == _Right)); |
577 |
|
} |
578 |
|
|
579 |
|
template<class _Ty, |
580 |
|
size_t _Size> |
581 |
|
bool operator<(const array<_Ty,_Size>& _Left, |
582 |
|
const array<_Ty,_Size>& _Right) |
583 |
|
{ // test if _Left < _Right for arrays |
584 |
|
return (std::lexicographical_compare(_Left.begin(), _Left.end(), |
585 |
|
_Right.begin(), _Right.end())); |
586 |
|
} |
587 |
|
|
588 |
|
template<class _Ty, |
589 |
|
size_t _Size> |
590 |
|
bool operator>(const array<_Ty,_Size>& _Left, |
591 |
|
const array<_Ty,_Size>& _Right) |
592 |
|
{ // test if _Left > _Right for arrays |
593 |
|
return (_Right < _Left); |
594 |
|
} |
595 |
|
|
596 |
|
template<class _Ty, |
597 |
|
size_t _Size> |
598 |
|
bool operator<=(const array<_Ty,_Size>& _Left, |
599 |
|
const array<_Ty,_Size>& _Right) |
600 |
|
{ // test if _Left <= _Right for arrays |
601 |
|
return (!(_Right < _Left)); |
602 |
|
} |
603 |
|
|
604 |
|
template<class _Ty, |
605 |
|
size_t _Size> |
606 |
|
bool operator>=(const array<_Ty,_Size>& _Left, |
607 |
|
const array<_Ty,_Size>& _Right) |
608 |
|
{ // test if _Left >= _Right for arrays |
609 |
|
return (!(_Left < _Right)); |
610 |
|
} |
611 |
|
|
612 |
|
#if _HAS_TR1 |
613 |
|
// TUPLE INTERFACE TO array |
614 |
|
template<class _Tuple> |
615 |
|
struct tuple_size; |
616 |
|
|
617 |
|
template<int _Idx, |
618 |
|
class _Tuple> |
619 |
|
struct tuple_element; |
620 |
|
|
621 |
|
template<class _Ty, |
622 |
|
size_t _Size> |
623 |
|
struct tuple_size<array<_Ty, _Size> > |
624 |
|
{ // struct to determine number of elements in array |
625 |
|
static const int value = _Size; |
626 |
|
}; |
627 |
|
|
628 |
|
template<int _Idx, |
629 |
|
class _Ty, |
630 |
|
size_t _Size> |
631 |
|
struct tuple_element<_Idx, array<_Ty, _Size> > |
632 |
|
{ // struct to determine type of element _Idx in array |
633 |
|
typedef _Ty type; |
634 |
|
}; |
635 |
|
|
636 |
|
template<int _Idx, |
637 |
|
class _Ty, |
638 |
|
size_t _Size> |
639 |
|
_Ty& get(array<_Ty, _Size>& _Arr) |
640 |
|
{ // return element at _Idx in array _Arr |
641 |
|
_Assert_static(0 <= _Idx && _Idx < _Size); |
642 |
|
return (_Arr[_Idx]); |
643 |
|
} |
644 |
|
|
645 |
|
template<int _Idx, |
646 |
|
class _Ty, |
647 |
|
size_t _Size> |
648 |
|
const _Ty& get(const array<_Ty, _Size>& _Arr) |
649 |
|
{ // return element at _Idx in array _Arr |
650 |
|
_Assert_static(0 <= _Idx && _Idx < _Size); |
651 |
|
return (_Arr[_Idx]); |
652 |
|
} |
653 |
|
#endif /* _HAS_TR1 */ |
654 |
|
|
655 |
|
} // namespace tr1 |
656 |
|
|
657 |
|
// array implements a performant swap if its elements do |
658 |
|
template<class _Ty, |
659 |
|
size_t _Size> |
660 |
|
class _Move_operation_category<tr1::array<_Ty, _Size> > |
661 |
|
{ |
662 |
|
public: |
663 |
|
typedef typename _Move_operation_category<_Ty>::_Move_cat _Move_cat; |
664 |
|
}; |
665 |
|
|
666 |
|
_STD_END |
667 |
|
#pragma warning(default: 4996) |
668 |
|
#pragma warning(default: 4284) |
669 |
|
#pragma warning(pop) |
670 |
|
#pragma pack(pop) |
671 |
|
#endif /* RC_INVOKED */ |
672 |
|
#endif /* _ARRAY_ */ |
673 |
|
|
674 |
|
/* |
675 |
|
* Copyright (c) 1992-2008 by P.J. Plauger. ALL RIGHTS RESERVED. |
676 |
|
* Consult your license regarding permissions and restrictions. |
677 |
|
V5.05:0009 */ |
678 |
|
|
|
|
|