00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061 #ifndef __GLIBCPP_INTERNAL_BVECTOR_H
00062 #define __GLIBCPP_INTERNAL_BVECTOR_H
00063
00064 namespace std
00065 {
00066 typedef unsigned long _Bit_type;
00067 enum { _M_word_bit = int(CHAR_BIT * sizeof(_Bit_type)) };
00068
00069 struct _Bit_reference {
00070
00071 _Bit_type * _M_p;
00072 _Bit_type _M_mask;
00073 _Bit_reference(_Bit_type * __x, _Bit_type __y)
00074 : _M_p(__x), _M_mask(__y) {}
00075
00076 public:
00077 _Bit_reference() : _M_p(0), _M_mask(0) {}
00078 operator bool() const { return !!(*_M_p & _M_mask); }
00079 _Bit_reference& operator=(bool __x)
00080 {
00081 if (__x) *_M_p |= _M_mask;
00082 else *_M_p &= ~_M_mask;
00083 return *this;
00084 }
00085 _Bit_reference& operator=(const _Bit_reference& __x)
00086 { return *this = bool(__x); }
00087 bool operator==(const _Bit_reference& __x) const
00088 { return bool(*this) == bool(__x); }
00089 bool operator<(const _Bit_reference& __x) const
00090 { return !bool(*this) && bool(__x); }
00091 void flip() { *_M_p ^= _M_mask; }
00092 };
00093
00094 struct _Bit_iterator_base : public iterator<random_access_iterator_tag, bool>
00095 {
00096 _Bit_type * _M_p;
00097 unsigned int _M_offset;
00098
00099 _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
00100 : _M_p(__x), _M_offset(__y) {}
00101
00102 void _M_bump_up() {
00103 if (_M_offset++ == _M_word_bit - 1) {
00104 _M_offset = 0;
00105 ++_M_p;
00106 }
00107 }
00108 void _M_bump_down() {
00109 if (_M_offset-- == 0) {
00110 _M_offset = _M_word_bit - 1;
00111 --_M_p;
00112 }
00113 }
00114
00115 void _M_incr(ptrdiff_t __i) {
00116 difference_type __n = __i + _M_offset;
00117 _M_p += __n / _M_word_bit;
00118 __n = __n % _M_word_bit;
00119 if (__n < 0) {
00120 _M_offset = (unsigned int) __n + _M_word_bit;
00121 --_M_p;
00122 } else
00123 _M_offset = (unsigned int) __n;
00124 }
00125
00126 bool operator==(const _Bit_iterator_base& __i) const {
00127 return _M_p == __i._M_p && _M_offset == __i._M_offset;
00128 }
00129 bool operator<(const _Bit_iterator_base& __i) const {
00130 return _M_p < __i._M_p || (_M_p == __i._M_p && _M_offset < __i._M_offset);
00131 }
00132 bool operator!=(const _Bit_iterator_base& __i) const {
00133 return !(*this == __i);
00134 }
00135 bool operator>(const _Bit_iterator_base& __i) const {
00136 return __i < *this;
00137 }
00138 bool operator<=(const _Bit_iterator_base& __i) const {
00139 return !(__i < *this);
00140 }
00141 bool operator>=(const _Bit_iterator_base& __i) const {
00142 return !(*this < __i);
00143 }
00144 };
00145
00146 inline ptrdiff_t
00147 operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) {
00148 return _M_word_bit * (__x._M_p - __y._M_p) + __x._M_offset - __y._M_offset;
00149 }
00150
00151
00152 struct _Bit_iterator : public _Bit_iterator_base
00153 {
00154 typedef _Bit_reference reference;
00155 typedef _Bit_reference* pointer;
00156 typedef _Bit_iterator iterator;
00157
00158 _Bit_iterator() : _Bit_iterator_base(0, 0) {}
00159 _Bit_iterator(_Bit_type * __x, unsigned int __y)
00160 : _Bit_iterator_base(__x, __y) {}
00161
00162 reference operator*() const { return reference(_M_p, 1UL << _M_offset); }
00163 iterator& operator++() {
00164 _M_bump_up();
00165 return *this;
00166 }
00167 iterator operator++(int) {
00168 iterator __tmp = *this;
00169 _M_bump_up();
00170 return __tmp;
00171 }
00172 iterator& operator--() {
00173 _M_bump_down();
00174 return *this;
00175 }
00176 iterator operator--(int) {
00177 iterator __tmp = *this;
00178 _M_bump_down();
00179 return __tmp;
00180 }
00181 iterator& operator+=(difference_type __i) {
00182 _M_incr(__i);
00183 return *this;
00184 }
00185 iterator& operator-=(difference_type __i) {
00186 *this += -__i;
00187 return *this;
00188 }
00189 iterator operator+(difference_type __i) const {
00190 iterator __tmp = *this;
00191 return __tmp += __i;
00192 }
00193 iterator operator-(difference_type __i) const {
00194 iterator __tmp = *this;
00195 return __tmp -= __i;
00196 }
00197
00198 reference operator[](difference_type __i) { return *(*this + __i); }
00199 };
00200
00201 inline _Bit_iterator
00202 operator+(ptrdiff_t __n, const _Bit_iterator& __x) { return __x + __n; }
00203
00204
00205 struct _Bit_const_iterator : public _Bit_iterator_base
00206 {
00207 typedef bool reference;
00208 typedef bool const_reference;
00209 typedef const bool* pointer;
00210 typedef _Bit_const_iterator const_iterator;
00211
00212 _Bit_const_iterator() : _Bit_iterator_base(0, 0) {}
00213 _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
00214 : _Bit_iterator_base(__x, __y) {}
00215 _Bit_const_iterator(const _Bit_iterator& __x)
00216 : _Bit_iterator_base(__x._M_p, __x._M_offset) {}
00217
00218 const_reference operator*() const {
00219 return _Bit_reference(_M_p, 1UL << _M_offset);
00220 }
00221 const_iterator& operator++() {
00222 _M_bump_up();
00223 return *this;
00224 }
00225 const_iterator operator++(int) {
00226 const_iterator __tmp = *this;
00227 _M_bump_up();
00228 return __tmp;
00229 }
00230 const_iterator& operator--() {
00231 _M_bump_down();
00232 return *this;
00233 }
00234 const_iterator operator--(int) {
00235 const_iterator __tmp = *this;
00236 _M_bump_down();
00237 return __tmp;
00238 }
00239 const_iterator& operator+=(difference_type __i) {
00240 _M_incr(__i);
00241 return *this;
00242 }
00243 const_iterator& operator-=(difference_type __i) {
00244 *this += -__i;
00245 return *this;
00246 }
00247 const_iterator operator+(difference_type __i) const {
00248 const_iterator __tmp = *this;
00249 return __tmp += __i;
00250 }
00251 const_iterator operator-(difference_type __i) const {
00252 const_iterator __tmp = *this;
00253 return __tmp -= __i;
00254 }
00255 const_reference operator[](difference_type __i) {
00256 return *(*this + __i);
00257 }
00258 };
00259
00260 inline _Bit_const_iterator
00261 operator+(ptrdiff_t __n, const _Bit_const_iterator& __x) { return __x + __n; }
00262
00263
00264
00265
00266
00267
00268 template <class _Allocator, bool __is_static>
00269 class _Bvector_alloc_base {
00270 public:
00271 typedef typename _Alloc_traits<bool, _Allocator>::allocator_type
00272 allocator_type;
00273 allocator_type get_allocator() const { return _M_data_allocator; }
00274
00275 _Bvector_alloc_base(const allocator_type& __a)
00276 : _M_data_allocator(__a), _M_start(), _M_finish(), _M_end_of_storage(0) {}
00277
00278 protected:
00279 _Bit_type * _M_bit_alloc(size_t __n)
00280 { return _M_data_allocator.allocate((__n + _M_word_bit - 1)/_M_word_bit); }
00281 void _M_deallocate() {
00282 if (_M_start._M_p)
00283 _M_data_allocator.deallocate(_M_start._M_p,
00284 _M_end_of_storage - _M_start._M_p);
00285 }
00286
00287 typename _Alloc_traits<_Bit_type, _Allocator>::allocator_type
00288 _M_data_allocator;
00289 _Bit_iterator _M_start;
00290 _Bit_iterator _M_finish;
00291 _Bit_type * _M_end_of_storage;
00292 };
00293
00294
00295 template <class _Allocator>
00296 class _Bvector_alloc_base<_Allocator, true> {
00297 public:
00298 typedef typename _Alloc_traits<bool, _Allocator>::allocator_type
00299 allocator_type;
00300 allocator_type get_allocator() const { return allocator_type(); }
00301
00302 _Bvector_alloc_base(const allocator_type&)
00303 : _M_start(), _M_finish(), _M_end_of_storage(0) {}
00304
00305 protected:
00306 typedef typename _Alloc_traits<_Bit_type, _Allocator>::_Alloc_type
00307 _Alloc_type;
00308
00309 _Bit_type * _M_bit_alloc(size_t __n)
00310 { return _Alloc_type::allocate((__n + _M_word_bit - 1)/_M_word_bit); }
00311 void _M_deallocate() {
00312 if (_M_start._M_p)
00313 _Alloc_type::deallocate(_M_start._M_p,
00314 _M_end_of_storage - _M_start._M_p);
00315 }
00316
00317 _Bit_iterator _M_start;
00318 _Bit_iterator _M_finish;
00319 _Bit_type * _M_end_of_storage;
00320 };
00321
00322 template <class _Alloc>
00323 class _Bvector_base
00324 : public _Bvector_alloc_base<_Alloc,
00325 _Alloc_traits<bool, _Alloc>::_S_instanceless>
00326 {
00327 typedef _Bvector_alloc_base<_Alloc,
00328 _Alloc_traits<bool, _Alloc>::_S_instanceless>
00329 _Base;
00330 public:
00331 typedef typename _Base::allocator_type allocator_type;
00332
00333 _Bvector_base(const allocator_type& __a) : _Base(__a) {}
00334 ~_Bvector_base() { _Base::_M_deallocate(); }
00335 };
00336
00337 }
00338
00339
00340 #include <bits/stl_vector.h>
00341 namespace std
00342 {
00343
00344 template <typename _Alloc>
00345 class vector<bool, _Alloc> : public _Bvector_base<_Alloc>
00346 {
00347 public:
00348 typedef bool value_type;
00349 typedef size_t size_type;
00350 typedef ptrdiff_t difference_type;
00351 typedef _Bit_reference reference;
00352 typedef bool const_reference;
00353 typedef _Bit_reference* pointer;
00354 typedef const bool* const_pointer;
00355
00356 typedef _Bit_iterator iterator;
00357 typedef _Bit_const_iterator const_iterator;
00358
00359 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
00360 typedef std::reverse_iterator<iterator> reverse_iterator;
00361
00362 typedef typename _Bvector_base<_Alloc>::allocator_type allocator_type;
00363 allocator_type get_allocator() const {
00364 return _Bvector_base<_Alloc>::get_allocator();
00365 }
00366
00367 protected:
00368 using _Bvector_base<_Alloc>::_M_bit_alloc;
00369 using _Bvector_base<_Alloc>::_M_deallocate;
00370 using _Bvector_base<_Alloc>::_M_start;
00371 using _Bvector_base<_Alloc>::_M_finish;
00372 using _Bvector_base<_Alloc>::_M_end_of_storage;
00373
00374 protected:
00375 void _M_initialize(size_type __n) {
00376 _Bit_type * __q = _M_bit_alloc(__n);
00377 _M_end_of_storage = __q + (__n + _M_word_bit - 1)/_M_word_bit;
00378 _M_start = iterator(__q, 0);
00379 _M_finish = _M_start + difference_type(__n);
00380 }
00381 void _M_insert_aux(iterator __position, bool __x) {
00382 if (_M_finish._M_p != _M_end_of_storage) {
00383 copy_backward(__position, _M_finish, _M_finish + 1);
00384 *__position = __x;
00385 ++_M_finish;
00386 }
00387 else {
00388 size_type __len = size()
00389 ? 2 * size() : static_cast<size_type>(_M_word_bit);
00390 _Bit_type * __q = _M_bit_alloc(__len);
00391 iterator __i = copy(begin(), __position, iterator(__q, 0));
00392 *__i++ = __x;
00393 _M_finish = copy(__position, end(), __i);
00394 _M_deallocate();
00395 _M_end_of_storage = __q + (__len + _M_word_bit - 1)/_M_word_bit;
00396 _M_start = iterator(__q, 0);
00397 }
00398 }
00399
00400 template <class _InputIterator>
00401 void _M_initialize_range(_InputIterator __first, _InputIterator __last,
00402 input_iterator_tag) {
00403 _M_start = iterator();
00404 _M_finish = iterator();
00405 _M_end_of_storage = 0;
00406 for ( ; __first != __last; ++__first)
00407 push_back(*__first);
00408 }
00409
00410 template <class _ForwardIterator>
00411 void _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
00412 forward_iterator_tag) {
00413 size_type __n = distance(__first, __last);
00414 _M_initialize(__n);
00415 copy(__first, __last, _M_start);
00416 }
00417
00418 template <class _InputIterator>
00419 void _M_insert_range(iterator __pos,
00420 _InputIterator __first, _InputIterator __last,
00421 input_iterator_tag) {
00422 for ( ; __first != __last; ++__first) {
00423 __pos = insert(__pos, *__first);
00424 ++__pos;
00425 }
00426 }
00427
00428 template <class _ForwardIterator>
00429 void _M_insert_range(iterator __position,
00430 _ForwardIterator __first, _ForwardIterator __last,
00431 forward_iterator_tag) {
00432 if (__first != __last) {
00433 size_type __n = distance(__first, __last);
00434 if (capacity() - size() >= __n) {
00435 copy_backward(__position, end(), _M_finish + difference_type(__n));
00436 copy(__first, __last, __position);
00437 _M_finish += difference_type(__n);
00438 }
00439 else {
00440 size_type __len = size() + max(size(), __n);
00441 _Bit_type * __q = _M_bit_alloc(__len);
00442 iterator __i = copy(begin(), __position, iterator(__q, 0));
00443 __i = copy(__first, __last, __i);
00444 _M_finish = copy(__position, end(), __i);
00445 _M_deallocate();
00446 _M_end_of_storage = __q + (__len + _M_word_bit - 1)/_M_word_bit;
00447 _M_start = iterator(__q, 0);
00448 }
00449 }
00450 }
00451
00452 public:
00453 iterator begin() { return _M_start; }
00454 const_iterator begin() const { return _M_start; }
00455 iterator end() { return _M_finish; }
00456 const_iterator end() const { return _M_finish; }
00457
00458 reverse_iterator rbegin() { return reverse_iterator(end()); }
00459 const_reverse_iterator rbegin() const {
00460 return const_reverse_iterator(end());
00461 }
00462 reverse_iterator rend() { return reverse_iterator(begin()); }
00463 const_reverse_iterator rend() const {
00464 return const_reverse_iterator(begin());
00465 }
00466
00467 size_type size() const { return size_type(end() - begin()); }
00468 size_type max_size() const { return size_type(-1); }
00469 size_type capacity() const {
00470 return size_type(const_iterator(_M_end_of_storage, 0) - begin());
00471 }
00472 bool empty() const { return begin() == end(); }
00473
00474 reference operator[](size_type __n)
00475 { return *(begin() + difference_type(__n)); }
00476 const_reference operator[](size_type __n) const
00477 { return *(begin() + difference_type(__n)); }
00478
00479 void _M_range_check(size_type __n) const {
00480 if (__n >= this->size())
00481 __throw_out_of_range("vector<bool>");
00482 }
00483
00484 reference at(size_type __n)
00485 { _M_range_check(__n); return (*this)[__n]; }
00486 const_reference at(size_type __n) const
00487 { _M_range_check(__n); return (*this)[__n]; }
00488
00489 explicit vector(const allocator_type& __a = allocator_type())
00490 : _Bvector_base<_Alloc>(__a) {}
00491
00492 vector(size_type __n, bool __value,
00493 const allocator_type& __a = allocator_type())
00494 : _Bvector_base<_Alloc>(__a)
00495 {
00496 _M_initialize(__n);
00497 fill(_M_start._M_p, _M_end_of_storage, __value ? ~0 : 0);
00498 }
00499
00500 explicit vector(size_type __n)
00501 : _Bvector_base<_Alloc>(allocator_type())
00502 {
00503 _M_initialize(__n);
00504 fill(_M_start._M_p, _M_end_of_storage, 0);
00505 }
00506
00507 vector(const vector& __x) : _Bvector_base<_Alloc>(__x.get_allocator()) {
00508 _M_initialize(__x.size());
00509 copy(__x.begin(), __x.end(), _M_start);
00510 }
00511
00512
00513
00514 template <class _Integer>
00515 void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) {
00516 _M_initialize(__n);
00517 fill(_M_start._M_p, _M_end_of_storage, __x ? ~0 : 0);
00518 }
00519
00520 template <class _InputIterator>
00521 void _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
00522 __false_type) {
00523 _M_initialize_range(__first, __last, __iterator_category(__first));
00524 }
00525
00526 template <class _InputIterator>
00527 vector(_InputIterator __first, _InputIterator __last,
00528 const allocator_type& __a = allocator_type())
00529 : _Bvector_base<_Alloc>(__a)
00530 {
00531 typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
00532 _M_initialize_dispatch(__first, __last, _Integral());
00533 }
00534
00535 ~vector() { }
00536
00537 vector& operator=(const vector& __x) {
00538 if (&__x == this) return *this;
00539 if (__x.size() > capacity()) {
00540 _M_deallocate();
00541 _M_initialize(__x.size());
00542 }
00543 copy(__x.begin(), __x.end(), begin());
00544 _M_finish = begin() + difference_type(__x.size());
00545 return *this;
00546 }
00547
00548
00549
00550
00551
00552
00553 void _M_fill_assign(size_t __n, bool __x) {
00554 if (__n > size()) {
00555 fill(_M_start._M_p, _M_end_of_storage, __x ? ~0 : 0);
00556 insert(end(), __n - size(), __x);
00557 }
00558 else {
00559 erase(begin() + __n, end());
00560 fill(_M_start._M_p, _M_end_of_storage, __x ? ~0 : 0);
00561 }
00562 }
00563
00564 void assign(size_t __n, bool __x) { _M_fill_assign(__n, __x); }
00565
00566 template <class _InputIterator>
00567 void assign(_InputIterator __first, _InputIterator __last) {
00568 typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
00569 _M_assign_dispatch(__first, __last, _Integral());
00570 }
00571
00572 template <class _Integer>
00573 void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
00574 { _M_fill_assign((size_t) __n, (bool) __val); }
00575
00576 template <class _InputIter>
00577 void _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type)
00578 { _M_assign_aux(__first, __last, __iterator_category(__first)); }
00579
00580 template <class _InputIterator>
00581 void _M_assign_aux(_InputIterator __first, _InputIterator __last,
00582 input_iterator_tag) {
00583 iterator __cur = begin();
00584 for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
00585 *__cur = *__first;
00586 if (__first == __last)
00587 erase(__cur, end());
00588 else
00589 insert(end(), __first, __last);
00590 }
00591
00592 template <class _ForwardIterator>
00593 void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
00594 forward_iterator_tag) {
00595 size_type __len = distance(__first, __last);
00596 if (__len < size())
00597 erase(copy(__first, __last, begin()), end());
00598 else {
00599 _ForwardIterator __mid = __first;
00600 advance(__mid, size());
00601 copy(__first, __mid, begin());
00602 insert(end(), __mid, __last);
00603 }
00604 }
00605
00606 void reserve(size_type __n) {
00607 if (__n > this->max_size())
00608 __throw_length_error("vector::reserve");
00609 if (this->capacity() < __n) {
00610 _Bit_type * __q = _M_bit_alloc(__n);
00611 _M_finish = copy(begin(), end(), iterator(__q, 0));
00612 _M_deallocate();
00613 _M_start = iterator(__q, 0);
00614 _M_end_of_storage = __q + (__n + _M_word_bit - 1)/_M_word_bit;
00615 }
00616 }
00617
00618 reference front() { return *begin(); }
00619 const_reference front() const { return *begin(); }
00620 reference back() { return *(end() - 1); }
00621 const_reference back() const { return *(end() - 1); }
00622 void push_back(bool __x) {
00623 if (_M_finish._M_p != _M_end_of_storage)
00624 *_M_finish++ = __x;
00625 else
00626 _M_insert_aux(end(), __x);
00627 }
00628 void swap(vector<bool, _Alloc>& __x) {
00629 std::swap(_M_start, __x._M_start);
00630 std::swap(_M_finish, __x._M_finish);
00631 std::swap(_M_end_of_storage, __x._M_end_of_storage);
00632 }
00633
00634
00635 static void swap(reference __x, reference __y) {
00636 bool __tmp = __x;
00637 __x = __y;
00638 __y = __tmp;
00639 }
00640
00641 iterator insert(iterator __position, bool __x = bool()) {
00642 difference_type __n = __position - begin();
00643 if (_M_finish._M_p != _M_end_of_storage && __position == end())
00644 *_M_finish++ = __x;
00645 else
00646 _M_insert_aux(__position, __x);
00647 return begin() + __n;
00648 }
00649
00650
00651
00652 template <class _Integer>
00653 void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
00654 __true_type) {
00655 _M_fill_insert(__pos, __n, __x);
00656 }
00657
00658 template <class _InputIterator>
00659 void _M_insert_dispatch(iterator __pos,
00660 _InputIterator __first, _InputIterator __last,
00661 __false_type) {
00662 _M_insert_range(__pos, __first, __last, __iterator_category(__first));
00663 }
00664
00665 template <class _InputIterator>
00666 void insert(iterator __position,
00667 _InputIterator __first, _InputIterator __last) {
00668 typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
00669 _M_insert_dispatch(__position, __first, __last, _Integral());
00670 }
00671
00672 void _M_fill_insert(iterator __position, size_type __n, bool __x) {
00673 if (__n == 0) return;
00674 if (capacity() - size() >= __n) {
00675 copy_backward(__position, end(), _M_finish + difference_type(__n));
00676 fill(__position, __position + difference_type(__n), __x);
00677 _M_finish += difference_type(__n);
00678 }
00679 else {
00680 size_type __len = size() + max(size(), __n);
00681 _Bit_type * __q = _M_bit_alloc(__len);
00682 iterator __i = copy(begin(), __position, iterator(__q, 0));
00683 fill_n(__i, __n, __x);
00684 _M_finish = copy(__position, end(), __i + difference_type(__n));
00685 _M_deallocate();
00686 _M_end_of_storage = __q + (__len + _M_word_bit - 1)/_M_word_bit;
00687 _M_start = iterator(__q, 0);
00688 }
00689 }
00690
00691 void insert(iterator __position, size_type __n, bool __x) {
00692 _M_fill_insert(__position, __n, __x);
00693 }
00694
00695 void pop_back() { --_M_finish; }
00696 iterator erase(iterator __position) {
00697 if (__position + 1 != end())
00698 copy(__position + 1, end(), __position);
00699 --_M_finish;
00700 return __position;
00701 }
00702 iterator erase(iterator __first, iterator __last) {
00703 _M_finish = copy(__last, end(), __first);
00704 return __first;
00705 }
00706 void resize(size_type __new_size, bool __x = bool()) {
00707 if (__new_size < size())
00708 erase(begin() + difference_type(__new_size), end());
00709 else
00710 insert(end(), __new_size - size(), __x);
00711 }
00712 void flip() {
00713 for (_Bit_type * __p = _M_start._M_p; __p != _M_end_of_storage; ++__p)
00714 *__p = ~*__p;
00715 }
00716
00717 void clear() { erase(begin(), end()); }
00718 };
00719
00720
00721 typedef vector<bool, __alloc> bit_vector;
00722
00723 }
00724
00725 #endif
00726
00727
00728
00729