libstdc++
stl_bvector.h
Go to the documentation of this file.
1// vector<bool> specialization -*- C++ -*-
2
3// Copyright (C) 2001-2022 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/*
26 *
27 * Copyright (c) 1994
28 * Hewlett-Packard Company
29 *
30 * Permission to use, copy, modify, distribute and sell this software
31 * and its documentation for any purpose is hereby granted without fee,
32 * provided that the above copyright notice appear in all copies and
33 * that both that copyright notice and this permission notice appear
34 * in supporting documentation. Hewlett-Packard Company makes no
35 * representations about the suitability of this software for any
36 * purpose. It is provided "as is" without express or implied warranty.
37 *
38 *
39 * Copyright (c) 1996-1999
40 * Silicon Graphics Computer Systems, Inc.
41 *
42 * Permission to use, copy, modify, distribute and sell this software
43 * and its documentation for any purpose is hereby granted without fee,
44 * provided that the above copyright notice appear in all copies and
45 * that both that copyright notice and this permission notice appear
46 * in supporting documentation. Silicon Graphics makes no
47 * representations about the suitability of this software for any
48 * purpose. It is provided "as is" without express or implied warranty.
49 */
50
51/** @file bits/stl_bvector.h
52 * This is an internal header file, included by other library headers.
53 * Do not attempt to use it directly. @headername{vector}
54 */
55
56#ifndef _STL_BVECTOR_H
57#define _STL_BVECTOR_H 1
58
59#if __cplusplus >= 201103L
60#include <initializer_list>
62#endif
63
64namespace std _GLIBCXX_VISIBILITY(default)
65{
66_GLIBCXX_BEGIN_NAMESPACE_VERSION
67
68 typedef unsigned long _Bit_type;
69 enum { _S_word_bit = int(__CHAR_BIT__ * sizeof(_Bit_type)) };
70
71 __attribute__((__nonnull__))
72 _GLIBCXX20_CONSTEXPR
73 void
74 __fill_bvector_n(_Bit_type*, size_t, bool) _GLIBCXX_NOEXCEPT;
75
76_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
77
78 struct _Bit_reference
79 {
80 _Bit_type * _M_p;
81 _Bit_type _M_mask;
82
83 _GLIBCXX20_CONSTEXPR
84 _Bit_reference(_Bit_type * __x, _Bit_type __y)
85 : _M_p(__x), _M_mask(__y) { }
86
87 _GLIBCXX20_CONSTEXPR
88 _Bit_reference() _GLIBCXX_NOEXCEPT : _M_p(0), _M_mask(0) { }
89
90#if __cplusplus >= 201103L
91 _Bit_reference(const _Bit_reference&) = default;
92#endif
93
94 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
95 operator bool() const _GLIBCXX_NOEXCEPT
96 { return !!(*_M_p & _M_mask); }
97
98 _GLIBCXX20_CONSTEXPR
99 _Bit_reference&
100 operator=(bool __x) _GLIBCXX_NOEXCEPT
101 {
102 if (__x)
103 *_M_p |= _M_mask;
104 else
105 *_M_p &= ~_M_mask;
106 return *this;
107 }
108
109 _GLIBCXX20_CONSTEXPR
110 _Bit_reference&
111 operator=(const _Bit_reference& __x) _GLIBCXX_NOEXCEPT
112 { return *this = bool(__x); }
113
114 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
115 bool
116 operator==(const _Bit_reference& __x) const
117 { return bool(*this) == bool(__x); }
118
119 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
120 bool
121 operator<(const _Bit_reference& __x) const
122 { return !bool(*this) && bool(__x); }
123
124 _GLIBCXX20_CONSTEXPR
125 void
126 flip() _GLIBCXX_NOEXCEPT
127 { *_M_p ^= _M_mask; }
128
129#if __cplusplus >= 201103L
130 _GLIBCXX20_CONSTEXPR
131 friend void
132 swap(_Bit_reference __x, _Bit_reference __y) noexcept
133 {
134 bool __tmp = __x;
135 __x = __y;
136 __y = __tmp;
137 }
138
139 _GLIBCXX20_CONSTEXPR
140 friend void
141 swap(_Bit_reference __x, bool& __y) noexcept
142 {
143 bool __tmp = __x;
144 __x = __y;
145 __y = __tmp;
146 }
147
148 _GLIBCXX20_CONSTEXPR
149 friend void
150 swap(bool& __x, _Bit_reference __y) noexcept
151 {
152 bool __tmp = __x;
153 __x = __y;
154 __y = __tmp;
155 }
156#endif
157 };
158
159// Ignore warnings about std::iterator.
160#pragma GCC diagnostic push
161#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
162 struct _Bit_iterator_base
163 : public std::iterator<std::random_access_iterator_tag, bool>
164 {
165 _Bit_type * _M_p;
166 unsigned int _M_offset;
167
168 _GLIBCXX20_CONSTEXPR
169 _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
170 : _M_p(__x), _M_offset(__y) { }
171
172 _GLIBCXX20_CONSTEXPR
173 void
174 _M_bump_up()
175 {
176 if (_M_offset++ == int(_S_word_bit) - 1)
177 {
178 _M_offset = 0;
179 ++_M_p;
180 }
181 }
182
183 _GLIBCXX20_CONSTEXPR
184 void
185 _M_bump_down()
186 {
187 if (_M_offset-- == 0)
188 {
189 _M_offset = int(_S_word_bit) - 1;
190 --_M_p;
191 }
192 }
193
194 _GLIBCXX20_CONSTEXPR
195 void
196 _M_incr(ptrdiff_t __i)
197 {
198 difference_type __n = __i + _M_offset;
199 _M_p += __n / int(_S_word_bit);
200 __n = __n % int(_S_word_bit);
201 if (__n < 0)
202 {
203 __n += int(_S_word_bit);
204 --_M_p;
205 }
206 _M_offset = static_cast<unsigned int>(__n);
207 }
208
209 _GLIBCXX_NODISCARD
210 friend _GLIBCXX20_CONSTEXPR bool
211 operator==(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
212 { return __x._M_p == __y._M_p && __x._M_offset == __y._M_offset; }
213
214#if __cpp_lib_three_way_comparison
215 [[nodiscard]]
216 friend constexpr strong_ordering
217 operator<=>(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
218 noexcept
219 {
220 if (const auto __cmp = __x._M_p <=> __y._M_p; __cmp != 0)
221 return __cmp;
222 return __x._M_offset <=> __y._M_offset;
223 }
224#else
225 _GLIBCXX_NODISCARD
226 friend bool
227 operator<(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
228 {
229 return __x._M_p < __y._M_p
230 || (__x._M_p == __y._M_p && __x._M_offset < __y._M_offset);
231 }
232
233 _GLIBCXX_NODISCARD
234 friend bool
235 operator!=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
236 { return !(__x == __y); }
237
238 _GLIBCXX_NODISCARD
239 friend bool
240 operator>(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
241 { return __y < __x; }
242
243 _GLIBCXX_NODISCARD
244 friend bool
245 operator<=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
246 { return !(__y < __x); }
247
248 _GLIBCXX_NODISCARD
249 friend bool
250 operator>=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
251 { return !(__x < __y); }
252#endif // three-way comparison
253
254 friend _GLIBCXX20_CONSTEXPR ptrdiff_t
255 operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
256 {
257 return (int(_S_word_bit) * (__x._M_p - __y._M_p)
258 + __x._M_offset - __y._M_offset);
259 }
260 };
261#pragma GCC diagnostic pop
262
263 struct _Bit_iterator : public _Bit_iterator_base
264 {
265 typedef _Bit_reference reference;
266#if __cplusplus > 201703L
267 typedef void pointer;
268#else
269 typedef _Bit_reference* pointer;
270#endif
271 typedef _Bit_iterator iterator;
272
273 _GLIBCXX20_CONSTEXPR
274 _Bit_iterator() : _Bit_iterator_base(0, 0) { }
275
276 _GLIBCXX20_CONSTEXPR
277 _Bit_iterator(_Bit_type * __x, unsigned int __y)
278 : _Bit_iterator_base(__x, __y) { }
279
280 _GLIBCXX20_CONSTEXPR
281 iterator
282 _M_const_cast() const
283 { return *this; }
284
285 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
286 reference
287 operator*() const
288 { return reference(_M_p, 1UL << _M_offset); }
289
290 _GLIBCXX20_CONSTEXPR
291 iterator&
292 operator++()
293 {
294 _M_bump_up();
295 return *this;
296 }
297
298 _GLIBCXX20_CONSTEXPR
299 iterator
300 operator++(int)
301 {
302 iterator __tmp = *this;
303 _M_bump_up();
304 return __tmp;
305 }
306
307 _GLIBCXX20_CONSTEXPR
308 iterator&
309 operator--()
310 {
311 _M_bump_down();
312 return *this;
313 }
314
315 _GLIBCXX20_CONSTEXPR
316 iterator
317 operator--(int)
318 {
319 iterator __tmp = *this;
320 _M_bump_down();
321 return __tmp;
322 }
323
324 _GLIBCXX20_CONSTEXPR
325 iterator&
326 operator+=(difference_type __i)
327 {
328 _M_incr(__i);
329 return *this;
330 }
331
332 _GLIBCXX20_CONSTEXPR
333 iterator&
334 operator-=(difference_type __i)
335 {
336 *this += -__i;
337 return *this;
338 }
339
340 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
341 reference
342 operator[](difference_type __i) const
343 { return *(*this + __i); }
344
345 _GLIBCXX_NODISCARD
346 friend _GLIBCXX20_CONSTEXPR iterator
347 operator+(const iterator& __x, difference_type __n)
348 {
349 iterator __tmp = __x;
350 __tmp += __n;
351 return __tmp;
352 }
353
354 _GLIBCXX_NODISCARD
355 friend _GLIBCXX20_CONSTEXPR iterator
356 operator+(difference_type __n, const iterator& __x)
357 { return __x + __n; }
358
359 _GLIBCXX_NODISCARD
360 friend _GLIBCXX20_CONSTEXPR iterator
361 operator-(const iterator& __x, difference_type __n)
362 {
363 iterator __tmp = __x;
364 __tmp -= __n;
365 return __tmp;
366 }
367 };
368
369 struct _Bit_const_iterator : public _Bit_iterator_base
370 {
371 typedef bool reference;
372 typedef bool const_reference;
373#if __cplusplus > 201703L
374 typedef void pointer;
375#else
376 typedef const bool* pointer;
377#endif
378 typedef _Bit_const_iterator const_iterator;
379
380 _GLIBCXX20_CONSTEXPR
381 _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
382
383 _GLIBCXX20_CONSTEXPR
384 _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
385 : _Bit_iterator_base(__x, __y) { }
386
387 _GLIBCXX20_CONSTEXPR
388 _Bit_const_iterator(const _Bit_iterator& __x)
389 : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
390
391 _GLIBCXX20_CONSTEXPR
392 _Bit_iterator
393 _M_const_cast() const
394 { return _Bit_iterator(_M_p, _M_offset); }
395
396 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
397 const_reference
398 operator*() const
399 { return _Bit_reference(_M_p, 1UL << _M_offset); }
400
401 _GLIBCXX20_CONSTEXPR
402 const_iterator&
403 operator++()
404 {
405 _M_bump_up();
406 return *this;
407 }
408
409 _GLIBCXX20_CONSTEXPR
410 const_iterator
411 operator++(int)
412 {
413 const_iterator __tmp = *this;
414 _M_bump_up();
415 return __tmp;
416 }
417
418 _GLIBCXX20_CONSTEXPR
419 const_iterator&
420 operator--()
421 {
422 _M_bump_down();
423 return *this;
424 }
425
426 _GLIBCXX20_CONSTEXPR
427 const_iterator
428 operator--(int)
429 {
430 const_iterator __tmp = *this;
431 _M_bump_down();
432 return __tmp;
433 }
434
435 _GLIBCXX20_CONSTEXPR
436 const_iterator&
437 operator+=(difference_type __i)
438 {
439 _M_incr(__i);
440 return *this;
441 }
442
443 _GLIBCXX20_CONSTEXPR
444 const_iterator&
445 operator-=(difference_type __i)
446 {
447 *this += -__i;
448 return *this;
449 }
450
451 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
452 const_reference
453 operator[](difference_type __i) const
454 { return *(*this + __i); }
455
456 _GLIBCXX_NODISCARD
457 friend _GLIBCXX20_CONSTEXPR const_iterator
458 operator+(const const_iterator& __x, difference_type __n)
459 {
460 const_iterator __tmp = __x;
461 __tmp += __n;
462 return __tmp;
463 }
464
465 _GLIBCXX_NODISCARD
466 friend _GLIBCXX20_CONSTEXPR const_iterator
467 operator-(const const_iterator& __x, difference_type __n)
468 {
469 const_iterator __tmp = __x;
470 __tmp -= __n;
471 return __tmp;
472 }
473
474 _GLIBCXX_NODISCARD
475 friend _GLIBCXX20_CONSTEXPR const_iterator
476 operator+(difference_type __n, const const_iterator& __x)
477 { return __x + __n; }
478 };
479
480 template<typename _Alloc>
481 struct _Bvector_base
482 {
484 rebind<_Bit_type>::other _Bit_alloc_type;
486 _Bit_alloc_traits;
487 typedef typename _Bit_alloc_traits::pointer _Bit_pointer;
488
489 struct _Bvector_impl_data
490 {
491#if !_GLIBCXX_INLINE_VERSION
492 _Bit_iterator _M_start;
493#else
494 // We don't need the offset field for the start, it's always zero.
495 struct {
496 _Bit_type* _M_p;
497 // Allow assignment from iterators (assume offset is zero):
498 _GLIBCXX20_CONSTEXPR
499 void operator=(_Bit_iterator __it) { _M_p = __it._M_p; }
500 } _M_start;
501#endif
502 _Bit_iterator _M_finish;
503 _Bit_pointer _M_end_of_storage;
504
505 _GLIBCXX20_CONSTEXPR
506 _Bvector_impl_data() _GLIBCXX_NOEXCEPT
507 : _M_start(), _M_finish(), _M_end_of_storage()
508 { }
509
510#if __cplusplus >= 201103L
511 _Bvector_impl_data(const _Bvector_impl_data&) = default;
512
513 _Bvector_impl_data&
514 operator=(const _Bvector_impl_data&) = default;
515
516 _GLIBCXX20_CONSTEXPR
517 _Bvector_impl_data(_Bvector_impl_data&& __x) noexcept
518 : _Bvector_impl_data(__x)
519 { __x._M_reset(); }
520
521 _GLIBCXX20_CONSTEXPR
522 void
523 _M_move_data(_Bvector_impl_data&& __x) noexcept
524 {
525 *this = __x;
526 __x._M_reset();
527 }
528#endif
529
530 _GLIBCXX20_CONSTEXPR
531 void
532 _M_reset() _GLIBCXX_NOEXCEPT
533 { *this = _Bvector_impl_data(); }
534
535 _GLIBCXX20_CONSTEXPR
536 void
537 _M_swap_data(_Bvector_impl_data& __x) _GLIBCXX_NOEXCEPT
538 {
539 // Do not use std::swap(_M_start, __x._M_start), etc as it loses
540 // information used by TBAA.
541 std::swap(*this, __x);
542 }
543 };
544
545 struct _Bvector_impl
546 : public _Bit_alloc_type, public _Bvector_impl_data
547 {
548 _GLIBCXX20_CONSTEXPR
549 _Bvector_impl() _GLIBCXX_NOEXCEPT_IF(
550 is_nothrow_default_constructible<_Bit_alloc_type>::value)
551#if __cpp_concepts
552 requires is_default_constructible_v<_Bit_alloc_type>
553#endif
554 : _Bit_alloc_type()
555 { }
556
557 _GLIBCXX20_CONSTEXPR
558 _Bvector_impl(const _Bit_alloc_type& __a) _GLIBCXX_NOEXCEPT
559 : _Bit_alloc_type(__a)
560 { }
561
562#if __cplusplus >= 201103L
563 // Not defaulted, to enforce noexcept(true) even when
564 // !is_nothrow_move_constructible<_Bit_alloc_type>.
565 _GLIBCXX20_CONSTEXPR
566 _Bvector_impl(_Bvector_impl&& __x) noexcept
567 : _Bit_alloc_type(std::move(__x)), _Bvector_impl_data(std::move(__x))
568 { }
569
570 _GLIBCXX20_CONSTEXPR
571 _Bvector_impl(_Bit_alloc_type&& __a, _Bvector_impl&& __x) noexcept
572 : _Bit_alloc_type(std::move(__a)), _Bvector_impl_data(std::move(__x))
573 { }
574#endif
575
576 _GLIBCXX20_CONSTEXPR
577 _Bit_type*
578 _M_end_addr() const _GLIBCXX_NOEXCEPT
579 {
580 if (this->_M_end_of_storage)
581 return std::__addressof(this->_M_end_of_storage[-1]) + 1;
582 return 0;
583 }
584 };
585
586 public:
587 typedef _Alloc allocator_type;
588
589 _GLIBCXX20_CONSTEXPR
590 _Bit_alloc_type&
591 _M_get_Bit_allocator() _GLIBCXX_NOEXCEPT
592 { return this->_M_impl; }
593
594 _GLIBCXX20_CONSTEXPR
595 const _Bit_alloc_type&
596 _M_get_Bit_allocator() const _GLIBCXX_NOEXCEPT
597 { return this->_M_impl; }
598
599 _GLIBCXX20_CONSTEXPR
600 allocator_type
601 get_allocator() const _GLIBCXX_NOEXCEPT
602 { return allocator_type(_M_get_Bit_allocator()); }
603
604#if __cplusplus >= 201103L
605 _Bvector_base() = default;
606#else
607 _Bvector_base() { }
608#endif
609
610 _GLIBCXX20_CONSTEXPR
611 _Bvector_base(const allocator_type& __a)
612 : _M_impl(__a) { }
613
614#if __cplusplus >= 201103L
615 _Bvector_base(_Bvector_base&&) = default;
616
617 _GLIBCXX20_CONSTEXPR
618 _Bvector_base(_Bvector_base&& __x, const allocator_type& __a) noexcept
619 : _M_impl(_Bit_alloc_type(__a), std::move(__x._M_impl))
620 { }
621#endif
622
623 _GLIBCXX20_CONSTEXPR
624 ~_Bvector_base()
625 { this->_M_deallocate(); }
626
627 protected:
628 _Bvector_impl _M_impl;
629
630 _GLIBCXX20_CONSTEXPR
631 _Bit_pointer
632 _M_allocate(size_t __n)
633 {
634 _Bit_pointer __p = _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n));
635#if __cpp_lib_is_constant_evaluated && __cpp_constexpr_dynamic_alloc
637 {
638 __n = _S_nword(__n);
639 for (size_t __i = 0; __i < __n; ++__i)
640 std::construct_at(std::to_address(__p) + __i);
641 }
642#endif
643 return __p;
644 }
645
646 _GLIBCXX20_CONSTEXPR
647 void
648 _M_deallocate()
649 {
650 if (_M_impl._M_start._M_p)
651 {
652 const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p;
654 _M_impl._M_end_of_storage - __n,
655 __n);
656 _M_impl._M_reset();
657 }
658 }
659
660#if __cplusplus >= 201103L
661 _GLIBCXX20_CONSTEXPR
662 void
663 _M_move_data(_Bvector_base&& __x) noexcept
664 { _M_impl._M_move_data(std::move(__x._M_impl)); }
665#endif
666
667 _GLIBCXX_CONSTEXPR
668 static size_t
669 _S_nword(size_t __n)
670 { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); }
671 };
672
673 /**
674 * @brief A specialization of vector for booleans which offers fixed time
675 * access to individual elements in any order.
676 *
677 * @ingroup sequences
678 * @headerfile vector
679 * @since C++98
680 *
681 * @tparam _Alloc Allocator type.
682 *
683 * Note that vector<bool> does not actually meet the requirements for being
684 * a container. This is because the reference and pointer types are not
685 * really references and pointers to bool. See DR96 for details. @see
686 * vector for function documentation.
687 *
688 * In some terminology a %vector can be described as a dynamic
689 * C-style array, it offers fast and efficient access to individual
690 * elements in any order and saves the user from worrying about
691 * memory and size allocation. Subscripting ( @c [] ) access is
692 * also provided as with C-style arrays.
693 */
694 template<typename _Alloc>
695 class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
696 {
697 typedef _Bvector_base<_Alloc> _Base;
698 typedef typename _Base::_Bit_pointer _Bit_pointer;
700
701#if __cplusplus >= 201103L
702 friend struct std::hash<vector>;
703#endif
704
705 public:
706 typedef bool value_type;
707 typedef size_t size_type;
708 typedef ptrdiff_t difference_type;
709 typedef _Bit_reference reference;
710 typedef bool const_reference;
711 typedef _Bit_reference* pointer;
712 typedef const bool* const_pointer;
713 typedef _Bit_iterator iterator;
714 typedef _Bit_const_iterator const_iterator;
717 typedef _Alloc allocator_type;
718
720 allocator_type
721 get_allocator() const
722 { return _Base::get_allocator(); }
723
724 protected:
725 using _Base::_M_allocate;
726 using _Base::_M_deallocate;
727 using _Base::_S_nword;
728 using _Base::_M_get_Bit_allocator;
729
730 public:
731#if __cplusplus >= 201103L
732 vector() = default;
733#else
734 vector() { }
735#endif
736
738 explicit
739 vector(const allocator_type& __a)
740 : _Base(__a) { }
741
742#if __cplusplus >= 201103L
744 explicit
745 vector(size_type __n, const allocator_type& __a = allocator_type())
746 : vector(__n, false, __a)
747 { }
748
750 vector(size_type __n, const bool& __value,
751 const allocator_type& __a = allocator_type())
752#else
753 explicit
754 vector(size_type __n, const bool& __value = bool(),
755 const allocator_type& __a = allocator_type())
756#endif
757 : _Base(__a)
758 {
759 _M_initialize(__n);
760 _M_initialize_value(__value);
761 }
762
764 vector(const vector& __x)
765 : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator()))
766 {
767 _M_initialize(__x.size());
768 _M_copy_aligned(__x.begin(), __x.end(), begin());
769 }
770
771#if __cplusplus >= 201103L
772 vector(vector&&) = default;
773
774 private:
776 vector(vector&& __x, const allocator_type& __a, true_type) noexcept
777 : _Base(std::move(__x), __a)
778 { }
779
781 vector(vector&& __x, const allocator_type& __a, false_type)
782 : _Base(__a)
783 {
784 if (__x.get_allocator() == __a)
785 this->_M_move_data(std::move(__x));
786 else
787 {
788 _M_initialize(__x.size());
789 _M_copy_aligned(__x.begin(), __x.end(), begin());
790 __x.clear();
791 }
792 }
793
794 public:
797 noexcept(_Bit_alloc_traits::_S_always_equal())
798 : vector(std::move(__x), __a,
800 { }
801
803 vector(const vector& __x, const __type_identity_t<allocator_type>& __a)
804 : _Base(__a)
805 {
806 _M_initialize(__x.size());
807 _M_copy_aligned(__x.begin(), __x.end(), begin());
808 }
809
812 const allocator_type& __a = allocator_type())
813 : _Base(__a)
814 {
815 _M_initialize_range(__l.begin(), __l.end(),
817 }
818#endif
819
820#if __cplusplus >= 201103L
821 template<typename _InputIterator,
824 vector(_InputIterator __first, _InputIterator __last,
825 const allocator_type& __a = allocator_type())
826 : _Base(__a)
827 {
828 _M_initialize_range(__first, __last,
829 std::__iterator_category(__first));
830 }
831#else
832 template<typename _InputIterator>
833 vector(_InputIterator __first, _InputIterator __last,
834 const allocator_type& __a = allocator_type())
835 : _Base(__a)
836 {
837 // Check whether it's an integral type. If so, it's not an iterator.
838 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
839 _M_initialize_dispatch(__first, __last, _Integral());
840 }
841#endif
842
845
847 vector&
848 operator=(const vector& __x)
849 {
850 if (&__x == this)
851 return *this;
852#if __cplusplus >= 201103L
853 if (_Bit_alloc_traits::_S_propagate_on_copy_assign())
854 {
855 if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator())
856 {
857 this->_M_deallocate();
858 std::__alloc_on_copy(_M_get_Bit_allocator(),
859 __x._M_get_Bit_allocator());
860 _M_initialize(__x.size());
861 }
862 else
863 std::__alloc_on_copy(_M_get_Bit_allocator(),
864 __x._M_get_Bit_allocator());
865 }
866#endif
867 if (__x.size() > capacity())
868 {
869 this->_M_deallocate();
870 _M_initialize(__x.size());
871 }
872 this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
873 begin());
874 return *this;
875 }
876
877#if __cplusplus >= 201103L
879 vector&
880 operator=(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_move())
881 {
882 if (_Bit_alloc_traits::_S_propagate_on_move_assign()
883 || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator())
884 {
885 this->_M_deallocate();
886 this->_M_move_data(std::move(__x));
887 std::__alloc_on_move(_M_get_Bit_allocator(),
888 __x._M_get_Bit_allocator());
889 }
890 else
891 {
892 if (__x.size() > capacity())
893 {
894 this->_M_deallocate();
895 _M_initialize(__x.size());
896 }
897 this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
898 begin());
899 __x.clear();
900 }
901 return *this;
902 }
903
905 vector&
907 {
908 this->assign(__l.begin(), __l.end());
909 return *this;
910 }
911#endif
912
913 // assign(), a generalized assignment member function. Two
914 // versions: one that takes a count, and one that takes a range.
915 // The range version is a member template, so we dispatch on whether
916 // or not the type is an integer.
918 void
919 assign(size_type __n, const bool& __x)
920 { _M_fill_assign(__n, __x); }
921
922#if __cplusplus >= 201103L
923 template<typename _InputIterator,
926 void
927 assign(_InputIterator __first, _InputIterator __last)
928 { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
929#else
930 template<typename _InputIterator>
931 void
932 assign(_InputIterator __first, _InputIterator __last)
933 {
934 // Check whether it's an integral type. If so, it's not an iterator.
935 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
936 _M_assign_dispatch(__first, __last, _Integral());
937 }
938#endif
939
940#if __cplusplus >= 201103L
942 void
944 { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); }
945#endif
946
947 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
948 iterator
950 { return iterator(this->_M_impl._M_start._M_p, 0); }
951
952 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
953 const_iterator
955 { return const_iterator(this->_M_impl._M_start._M_p, 0); }
956
957 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
958 iterator
960 { return this->_M_impl._M_finish; }
961
962 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
963 const_iterator
964 end() const _GLIBCXX_NOEXCEPT
965 { return this->_M_impl._M_finish; }
966
967 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
970 { return reverse_iterator(end()); }
971
972 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
975 { return const_reverse_iterator(end()); }
976
977 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
980 { return reverse_iterator(begin()); }
981
982 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
984 rend() const _GLIBCXX_NOEXCEPT
985 { return const_reverse_iterator(begin()); }
986
987#if __cplusplus >= 201103L
989 const_iterator
990 cbegin() const noexcept
991 { return const_iterator(this->_M_impl._M_start._M_p, 0); }
992
994 const_iterator
995 cend() const noexcept
996 { return this->_M_impl._M_finish; }
997
1000 crbegin() const noexcept
1001 { return const_reverse_iterator(end()); }
1002
1005 crend() const noexcept
1006 { return const_reverse_iterator(begin()); }
1007#endif
1008
1009 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1010 size_type
1011 size() const _GLIBCXX_NOEXCEPT
1012 { return size_type(end() - begin()); }
1013
1014 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1015 size_type
1017 {
1018 const size_type __isize =
1019 __gnu_cxx::__numeric_traits<difference_type>::__max
1020 - int(_S_word_bit) + 1;
1021 const size_type __asize
1022 = _Bit_alloc_traits::max_size(_M_get_Bit_allocator());
1023 return (__asize <= __isize / int(_S_word_bit)
1024 ? __asize * int(_S_word_bit) : __isize);
1025 }
1026
1027 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1028 size_type
1030 { return size_type(const_iterator(this->_M_impl._M_end_addr(), 0)
1031 - begin()); }
1032
1033 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1034 bool
1035 empty() const _GLIBCXX_NOEXCEPT
1036 { return begin() == end(); }
1037
1038 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1039 reference
1040 operator[](size_type __n)
1041 { return begin()[__n]; }
1042
1043 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1044 const_reference
1045 operator[](size_type __n) const
1046 { return begin()[__n]; }
1047
1048 protected:
1050 void
1051 _M_range_check(size_type __n) const
1052 {
1053 if (__n >= this->size())
1054 __throw_out_of_range_fmt(__N("vector<bool>::_M_range_check: __n "
1055 "(which is %zu) >= this->size() "
1056 "(which is %zu)"),
1057 __n, this->size());
1058 }
1059
1060 public:
1062 reference
1063 at(size_type __n)
1064 {
1065 _M_range_check(__n);
1066 return (*this)[__n];
1067 }
1068
1070 const_reference
1071 at(size_type __n) const
1072 {
1073 _M_range_check(__n);
1074 return (*this)[__n];
1075 }
1076
1078 void
1079 reserve(size_type __n)
1080 {
1081 if (__n > max_size())
1082 __throw_length_error(__N("vector::reserve"));
1083 if (capacity() < __n)
1084 _M_reallocate(__n);
1085 }
1086
1087 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1088 reference
1089 front()
1090 { return *begin(); }
1091
1092 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1093 const_reference
1094 front() const
1095 { return *begin(); }
1096
1097 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1098 reference
1099 back()
1100 { return *(end() - 1); }
1101
1102 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1103 const_reference
1104 back() const
1105 { return *(end() - 1); }
1106
1108 void
1109 push_back(bool __x)
1110 {
1111 if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
1112 *this->_M_impl._M_finish++ = __x;
1113 else
1114 _M_insert_aux(end(), __x);
1115 }
1116
1118 void
1120 {
1121#if __cplusplus >= 201103L
1122 __glibcxx_assert(_Bit_alloc_traits::propagate_on_container_swap::value
1123 || _M_get_Bit_allocator() == __x._M_get_Bit_allocator());
1124#endif
1125 this->_M_impl._M_swap_data(__x._M_impl);
1126 _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(),
1127 __x._M_get_Bit_allocator());
1128 }
1129
1130 // [23.2.5]/1, third-to-last entry in synopsis listing
1132 static void
1133 swap(reference __x, reference __y) _GLIBCXX_NOEXCEPT
1134 {
1135 bool __tmp = __x;
1136 __x = __y;
1137 __y = __tmp;
1138 }
1139
1141 iterator
1142#if __cplusplus >= 201103L
1143 insert(const_iterator __position, const bool& __x)
1144#else
1145 insert(iterator __position, const bool& __x)
1146#endif
1147 {
1148 const difference_type __n = __position - begin();
1149 if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()
1150 && __position == end())
1151 *this->_M_impl._M_finish++ = __x;
1152 else
1153 _M_insert_aux(__position._M_const_cast(), __x);
1154 return begin() + __n;
1155 }
1156
1157#if _GLIBCXX_USE_DEPRECATED
1158 _GLIBCXX_DEPRECATED_SUGGEST("insert(position, false)")
1159 iterator
1160 insert(const_iterator __position)
1161 { return this->insert(__position._M_const_cast(), false); }
1162#endif
1163
1164#if __cplusplus >= 201103L
1165 template<typename _InputIterator,
1168 iterator
1169 insert(const_iterator __position,
1170 _InputIterator __first, _InputIterator __last)
1171 {
1172 difference_type __offset = __position - cbegin();
1173 _M_insert_range(__position._M_const_cast(),
1174 __first, __last,
1175 std::__iterator_category(__first));
1176 return begin() + __offset;
1177 }
1178#else
1179 template<typename _InputIterator>
1180 void
1181 insert(iterator __position,
1182 _InputIterator __first, _InputIterator __last)
1183 {
1184 // Check whether it's an integral type. If so, it's not an iterator.
1185 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
1186 _M_insert_dispatch(__position, __first, __last, _Integral());
1187 }
1188#endif
1189
1190#if __cplusplus >= 201103L
1192 iterator
1193 insert(const_iterator __position, size_type __n, const bool& __x)
1194 {
1195 difference_type __offset = __position - cbegin();
1196 _M_fill_insert(__position._M_const_cast(), __n, __x);
1197 return begin() + __offset;
1198 }
1199#else
1200 void
1201 insert(iterator __position, size_type __n, const bool& __x)
1202 { _M_fill_insert(__position, __n, __x); }
1203#endif
1204
1205#if __cplusplus >= 201103L
1207 iterator
1208 insert(const_iterator __p, initializer_list<bool> __l)
1209 { return this->insert(__p, __l.begin(), __l.end()); }
1210#endif
1211
1213 void
1214 pop_back()
1215 { --this->_M_impl._M_finish; }
1216
1218 iterator
1219#if __cplusplus >= 201103L
1220 erase(const_iterator __position)
1221#else
1222 erase(iterator __position)
1223#endif
1224 { return _M_erase(__position._M_const_cast()); }
1225
1227 iterator
1228#if __cplusplus >= 201103L
1229 erase(const_iterator __first, const_iterator __last)
1230#else
1231 erase(iterator __first, iterator __last)
1232#endif
1233 { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
1234
1236 void
1237 resize(size_type __new_size, bool __x = bool())
1238 {
1239 if (__new_size < size())
1240 _M_erase_at_end(begin() + difference_type(__new_size));
1241 else
1242 insert(end(), __new_size - size(), __x);
1243 }
1244
1245#if __cplusplus >= 201103L
1247 void
1249 { _M_shrink_to_fit(); }
1250#endif
1251
1253 void
1254 flip() _GLIBCXX_NOEXCEPT
1255 {
1256 _Bit_type * const __end = this->_M_impl._M_end_addr();
1257 for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p)
1258 *__p = ~*__p;
1259 }
1260
1262 void
1264 { _M_erase_at_end(begin()); }
1265
1266#if __cplusplus >= 201103L
1267 template<typename... _Args>
1268#if __cplusplus > 201402L
1270 reference
1271#else
1272 void
1273#endif
1274 emplace_back(_Args&&... __args)
1275 {
1276 push_back(bool(__args...));
1277#if __cplusplus > 201402L
1278 return back();
1279#endif
1280 }
1281
1282 template<typename... _Args>
1284 iterator
1285 emplace(const_iterator __pos, _Args&&... __args)
1286 { return insert(__pos, bool(__args...)); }
1287#endif
1288
1289 protected:
1290 // Precondition: __first._M_offset == 0 && __result._M_offset == 0.
1292 iterator
1293 _M_copy_aligned(const_iterator __first, const_iterator __last,
1294 iterator __result)
1295 {
1296 _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
1297 return std::copy(const_iterator(__last._M_p, 0), __last,
1298 iterator(__q, 0));
1299 }
1300
1302 void
1303 _M_initialize(size_type __n)
1304 {
1305 if (__n)
1306 {
1307 _Bit_pointer __q = this->_M_allocate(__n);
1308 this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
1309 iterator __start = iterator(std::__addressof(*__q), 0);
1310 this->_M_impl._M_start = __start;
1311 this->_M_impl._M_finish = __start + difference_type(__n);
1312 }
1313 }
1314
1316 void
1317 _M_initialize_value(bool __x) _GLIBCXX_NOEXCEPT
1318 {
1319 if (_Bit_type* __p = this->_M_impl._M_start._M_p)
1320 __fill_bvector_n(__p, this->_M_impl._M_end_addr() - __p, __x);
1321 }
1322
1324 void
1325 _M_reallocate(size_type __n);
1326
1327#if __cplusplus >= 201103L
1329 bool
1330 _M_shrink_to_fit();
1331#endif
1332
1333#if __cplusplus < 201103L
1334 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1335 // 438. Ambiguity in the "do the right thing" clause
1336 template<typename _Integer>
1337 void
1338 _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
1339 {
1340 _M_initialize(static_cast<size_type>(__n));
1341 _M_initialize_value(__x);
1342 }
1343
1344 template<typename _InputIterator>
1345 void
1346 _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
1347 __false_type)
1348 { _M_initialize_range(__first, __last,
1349 std::__iterator_category(__first)); }
1350#endif
1351
1352 template<typename _InputIterator>
1354 void
1355 _M_initialize_range(_InputIterator __first, _InputIterator __last,
1357 {
1358 for (; __first != __last; ++__first)
1359 push_back(*__first);
1360 }
1361
1362 template<typename _ForwardIterator>
1364 void
1365 _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
1367 {
1368 const size_type __n = std::distance(__first, __last);
1369 _M_initialize(__n);
1370 std::copy(__first, __last, begin());
1371 }
1372
1373#if __cplusplus < 201103L
1374 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1375 // 438. Ambiguity in the "do the right thing" clause
1376 template<typename _Integer>
1377 void
1378 _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
1379 { _M_fill_assign(__n, __val); }
1380
1381 template<class _InputIterator>
1382 void
1383 _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
1384 __false_type)
1385 { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
1386#endif
1387
1389 void
1390 _M_fill_assign(size_t __n, bool __x)
1391 {
1392 if (__n > size())
1393 {
1394 _M_initialize_value(__x);
1395 insert(end(), __n - size(), __x);
1396 }
1397 else
1398 {
1399 _M_erase_at_end(begin() + __n);
1400 _M_initialize_value(__x);
1401 }
1402 }
1403
1404 template<typename _InputIterator>
1406 void
1407 _M_assign_aux(_InputIterator __first, _InputIterator __last,
1409 {
1410 iterator __cur = begin();
1411 for (; __first != __last && __cur != end(); ++__cur, (void)++__first)
1412 *__cur = *__first;
1413 if (__first == __last)
1414 _M_erase_at_end(__cur);
1415 else
1416 insert(end(), __first, __last);
1417 }
1418
1419 template<typename _ForwardIterator>
1421 void
1422 _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
1424 {
1425 const size_type __len = std::distance(__first, __last);
1426 if (__len < size())
1427 _M_erase_at_end(std::copy(__first, __last, begin()));
1428 else
1429 {
1430 _ForwardIterator __mid = __first;
1432 std::copy(__first, __mid, begin());
1433 insert(end(), __mid, __last);
1434 }
1435 }
1436
1437#if __cplusplus < 201103L
1438 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1439 // 438. Ambiguity in the "do the right thing" clause
1440 template<typename _Integer>
1441 void
1442 _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
1443 __true_type)
1444 { _M_fill_insert(__pos, __n, __x); }
1445
1446 template<typename _InputIterator>
1447 void
1448 _M_insert_dispatch(iterator __pos,
1449 _InputIterator __first, _InputIterator __last,
1450 __false_type)
1451 { _M_insert_range(__pos, __first, __last,
1452 std::__iterator_category(__first)); }
1453#endif
1454
1456 void
1457 _M_fill_insert(iterator __position, size_type __n, bool __x);
1458
1459 template<typename _InputIterator>
1461 void
1462 _M_insert_range(iterator __pos, _InputIterator __first,
1464 {
1465 for (; __first != __last; ++__first)
1466 {
1467 __pos = insert(__pos, *__first);
1468 ++__pos;
1469 }
1470 }
1471
1472 template<typename _ForwardIterator>
1474 void
1475 _M_insert_range(iterator __position, _ForwardIterator __first,
1477
1479 void
1480 _M_insert_aux(iterator __position, bool __x);
1481
1483 size_type
1484 _M_check_len(size_type __n, const char* __s) const
1485 {
1486 if (max_size() - size() < __n)
1487 __throw_length_error(__N(__s));
1488
1489 const size_type __len = size() + std::max(size(), __n);
1490 return (__len < size() || __len > max_size()) ? max_size() : __len;
1491 }
1492
1494 void
1495 _M_erase_at_end(iterator __pos)
1496 { this->_M_impl._M_finish = __pos; }
1497
1499 iterator
1500 _M_erase(iterator __pos);
1501
1503 iterator
1504 _M_erase(iterator __first, iterator __last);
1505
1506 protected:
1507 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1508 // DR 464. Suggestion for new member functions in standard containers.
1509 // N.B. DR 464 says nothing about vector<bool> but we need something
1510 // here due to the using-declaration in __gnu_debug::vector.
1511 // vector class.
1512#if __cplusplus >= 201103L
1513 void data() = delete;
1514#else
1515 void data() { }
1516#endif
1517 };
1518
1519_GLIBCXX_END_NAMESPACE_CONTAINER
1520
1521 // Fill a partial word.
1523 inline void
1524 __fill_bvector(_Bit_type* __v, unsigned int __first, unsigned int __last,
1525 bool __x) _GLIBCXX_NOEXCEPT
1526 {
1527 const _Bit_type __fmask = ~0ul << __first;
1528 const _Bit_type __lmask = ~0ul >> (_S_word_bit - __last);
1529 const _Bit_type __mask = __fmask & __lmask;
1530
1531 if (__x)
1532 *__v |= __mask;
1533 else
1534 *__v &= ~__mask;
1535 }
1536
1537 // Fill N full words, as if using memset, but usable in constant expressions.
1538 __attribute__((__nonnull__))
1539 _GLIBCXX20_CONSTEXPR
1540 inline void
1541 __fill_bvector_n(_Bit_type* __p, size_t __n, bool __x) _GLIBCXX_NOEXCEPT
1542 {
1543#if __cpp_lib_is_constant_evaluated
1545 {
1546 for (size_t __i = 0; __i < __n; ++__i)
1547 __p[__i] = __x ? ~0ul : 0ul;
1548 return;
1549 }
1550#endif
1551 __builtin_memset(__p, __x ? ~0 : 0, __n * sizeof(_Bit_type));
1552 }
1553
1554
1555 _GLIBCXX20_CONSTEXPR
1556 inline void
1557 __fill_a1(_GLIBCXX_STD_C::_Bit_iterator __first,
1558 _GLIBCXX_STD_C::_Bit_iterator __last, const bool& __x)
1559 {
1560 if (__first._M_p != __last._M_p)
1561 {
1562 _Bit_type* __first_p = __first._M_p;
1563 if (__first._M_offset != 0)
1564 __fill_bvector(__first_p++, __first._M_offset, _S_word_bit, __x);
1565
1566 __fill_bvector_n(__first_p, __last._M_p - __first_p, __x);
1567
1568 if (__last._M_offset != 0)
1569 __fill_bvector(__last._M_p, 0, __last._M_offset, __x);
1570 }
1571 else if (__first._M_offset != __last._M_offset)
1572 __fill_bvector(__first._M_p, __first._M_offset, __last._M_offset, __x);
1573 }
1574
1575#if __cplusplus >= 201103L
1576 // DR 1182.
1577 /// std::hash specialization for vector<bool>.
1578 template<typename _Alloc>
1579 struct hash<_GLIBCXX_STD_C::vector<bool, _Alloc>>
1580 : public __hash_base<size_t, _GLIBCXX_STD_C::vector<bool, _Alloc>>
1581 {
1582 size_t
1583 operator()(const _GLIBCXX_STD_C::vector<bool, _Alloc>&) const noexcept;
1584 };
1585#endif // C++11
1586
1587_GLIBCXX_END_NAMESPACE_VERSION
1588} // namespace std
1589
1590#endif
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
Definition complex:392
constexpr complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
Definition complex:362
constexpr complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
Definition complex:332
constexpr _Tp * to_address(_Tp *__ptr) noexcept
Obtain address referenced by a pointer to an object.
Definition ptr_traits.h:247
constexpr bool is_constant_evaluated() noexcept
Returns true only when called during constant evaluation.
Definition type_traits:3541
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition move.h:104
void swap(any &__x, any &__y) noexcept
Exchange the states of two any objects.
Definition any:429
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
Definition move.h:49
constexpr const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
constexpr iterator_traits< _Iter >::iterator_category __iterator_category(const _Iter &)
ISO C++ entities toplevel namespace is std.
constexpr iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
constexpr void advance(_InputIterator &__i, _Distance __n)
A generalization of pointer arithmetic.
Primary class template hash.
integral_constant
Definition type_traits:63
typename __detected_or_t< is_empty< _Alloc >, __equal, _Alloc >::type is_always_equal
Whether all instances of the allocator type compare equal.
Marking input iterators.
Forward iterators support a superset of input iterator operations.
Random-access iterators support a superset of bidirectional iterator operations.
Common iterator class.
ptrdiff_t difference_type
Distance between iterators is represented as this type.
A standard container which offers fixed time access to individual elements in any order.
Definition stl_vector.h:429
constexpr iterator insert(const_iterator __position, const value_type &__x)
Inserts given value into vector before specified iterator.
Definition vector.tcc:135
constexpr void push_back(const value_type &__x)
Add data to the end of the vector.
constexpr reverse_iterator rbegin() noexcept
Definition stl_vector.h:913
constexpr iterator end() noexcept
Definition stl_vector.h:893
vector()=default
Creates a vector with no elements.
constexpr iterator emplace(const_iterator __position, _Args &&... __args)
Inserts an object in vector before specified iterator.
constexpr iterator begin() noexcept
Definition stl_vector.h:873
constexpr size_type capacity() const noexcept
constexpr ~vector() noexcept
Definition stl_vector.h:733
constexpr void assign(size_type __n, const value_type &__val)
Assigns a given value to a vector.
Definition stl_vector.h:808
constexpr void swap(vector &__x) noexcept
Swaps data with another vector.
constexpr _Tp * data() noexcept
constexpr vector & operator=(const vector &__x)
Vector assignment operator.
constexpr void pop_back() noexcept
Removes last element.
constexpr void reserve(size_type __n)
Attempt to preallocate enough memory for specified number of elements.
Definition vector.tcc:68
constexpr reference at(size_type __n)
Provides access to the data contained in the vector.
constexpr void resize(size_type __new_size)
Resizes the vector to the specified number of elements.
constexpr void _M_range_check(size_type __n) const
Safety check used only from at().
constexpr reference front() noexcept
constexpr iterator erase(const_iterator __position)
Remove element at given position.
constexpr bool empty() const noexcept
constexpr reverse_iterator rend() noexcept
Definition stl_vector.h:933
constexpr const_reverse_iterator crbegin() const noexcept
Definition stl_vector.h:974
constexpr const_iterator cbegin() const noexcept
Definition stl_vector.h:954
constexpr void clear() noexcept
constexpr allocator_type get_allocator() const noexcept
Get a copy of the memory allocation object.
Definition stl_vector.h:311
constexpr size_type size() const noexcept
Definition stl_vector.h:992
constexpr reference back() noexcept
constexpr const_reverse_iterator crend() const noexcept
Definition stl_vector.h:984
constexpr const_iterator cend() const noexcept
Definition stl_vector.h:964
constexpr reference operator[](size_type __n) noexcept
Subscript access to the data contained in the vector.
constexpr void shrink_to_fit()
constexpr size_type max_size() const noexcept
Definition stl_vector.h:998
Uniform interface to C++98 and C++11 allocators.
static constexpr pointer allocate(_Alloc &__a, size_type __n)
Allocate memory.
static constexpr void deallocate(_Alloc &__a, pointer __p, size_type __n)
Deallocate memory.