959 lines
23 KiB
C++
959 lines
23 KiB
C++
#pragma once
|
|
#ifndef _STLVEC_H_
|
|
#define _STLVEC_H_
|
|
//#include <climits>
|
|
//#include <memory>
|
|
//#include <stdexcept>
|
|
|
|
#include <limits.h>
|
|
#include <stlmem.h>
|
|
#include <stlxutil.h>
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma pack(push,8)
|
|
#endif /* _MSC_VER */
|
|
|
|
_STD_BEGIN
|
|
|
|
// TEMPLATE CLASS vector
|
|
template<class _Ty, class _A = allocator<_Ty> >
|
|
class vector
|
|
{
|
|
public:
|
|
typedef vector<_Ty, _A> _Myt;
|
|
typedef _A allocator_type;
|
|
typedef _A::size_type size_type;
|
|
typedef _A::difference_type difference_type;
|
|
typedef _A::pointer _Tptr;
|
|
typedef _A::const_pointer _Ctptr;
|
|
typedef _A::reference reference;
|
|
typedef _A::const_reference const_reference;
|
|
typedef _A::value_type value_type;
|
|
typedef _Tptr iterator;
|
|
typedef _Ctptr const_iterator;
|
|
typedef reverse_iterator<const_iterator, value_type, const_reference,
|
|
_Ctptr, difference_type>
|
|
const_reverse_iterator;
|
|
|
|
typedef reverse_iterator<iterator, value_type,reference, _Tptr,
|
|
difference_type>
|
|
reverse_iterator;
|
|
|
|
explicit vector(const _A& _Al = _A())
|
|
: allocator(_Al), _First(0), _Last(0), _End(0)
|
|
{
|
|
|
|
}
|
|
explicit vector(size_type _N, const _Ty& _V = _Ty(),
|
|
const _A& _Al = _A())
|
|
: allocator(_Al)
|
|
{
|
|
_First = allocator.allocate(_N, (void *)0);
|
|
_Ufill(_First, _N, _V);
|
|
_Last = _First + _N;
|
|
_End = _Last;
|
|
}
|
|
vector(const _Myt& _X)
|
|
: allocator(_X.allocator)
|
|
{
|
|
_First = allocator.allocate(_X.size(), (void *)0);
|
|
_Last = _Ucopy(_X.begin(), _X.end(), _First);
|
|
_End = _Last;
|
|
}
|
|
typedef const_iterator _It;
|
|
vector(_It _F, _It _L, const _A& _Al = _A())
|
|
: allocator(_Al), _First(0), _Last(0), _End(0)
|
|
{
|
|
insert(begin(), _F, _L);
|
|
}
|
|
~vector()
|
|
{
|
|
_Destroy(_First, _Last);
|
|
allocator.deallocate(_First, _End - _First);
|
|
_First = 0, _Last = 0, _End = 0;
|
|
}
|
|
_Myt& operator=(const _Myt& _X)
|
|
{
|
|
if (this == &_X)
|
|
;
|
|
else if (_X.size() <= size())
|
|
{
|
|
iterator _S = copy(_X.begin(), _X.end(), _First);
|
|
_Destroy(_S, _Last);
|
|
_Last = _First + _X.size();
|
|
}
|
|
else if (_X.size() <= capacity())
|
|
{
|
|
const_iterator _S = _X.begin() + size();
|
|
copy(_X.begin(), _S, _First);
|
|
_Ucopy(_S, _X.end(), _Last);
|
|
_Last = _First + _X.size();
|
|
}
|
|
else
|
|
{
|
|
_Destroy(_First, _Last);
|
|
allocator.deallocate(_First, _End - _First);
|
|
_First = allocator.allocate(_X.size(), (void *)0);
|
|
_Last = _Ucopy(_X.begin(), _X.end(),
|
|
_First);
|
|
_End = _Last;
|
|
}
|
|
return (*this);
|
|
}
|
|
void reserve(size_type _N)
|
|
{
|
|
if (capacity() < _N)
|
|
{
|
|
iterator _S = allocator.allocate(_N, (void *)0);
|
|
_Ucopy(_First, _Last, _S);
|
|
_Destroy(_First, _Last);
|
|
allocator.deallocate(_First, _End - _First);
|
|
_End = _S + _N;
|
|
_Last = _S + size();
|
|
_First = _S;
|
|
}
|
|
}
|
|
size_type capacity() const
|
|
{
|
|
return (_First == 0 ? 0 : _End - _First);
|
|
}
|
|
iterator begin()
|
|
{
|
|
return (_First);
|
|
}
|
|
const_iterator begin() const
|
|
{
|
|
return ((const_iterator)_First);
|
|
}
|
|
iterator end()
|
|
{
|
|
return (_Last);
|
|
}
|
|
const_iterator end() const
|
|
{
|
|
return ((const_iterator)_Last);
|
|
}
|
|
reverse_iterator rbegin()
|
|
{
|
|
return (reverse_iterator(end()));
|
|
}
|
|
const_reverse_iterator rbegin() const
|
|
{
|
|
return (const_reverse_iterator(end()));
|
|
}
|
|
reverse_iterator rend()
|
|
{
|
|
return (reverse_iterator(begin()));
|
|
}
|
|
const_reverse_iterator rend() const
|
|
{
|
|
return (const_reverse_iterator(begin()));
|
|
}
|
|
void resize(size_type _N, const _Ty& _X = _Ty())
|
|
{
|
|
if (size() < _N)
|
|
insert(end(), _N - size(), _X);
|
|
else if (_N < size())
|
|
erase(begin() + _N, end());
|
|
}
|
|
size_type size() const
|
|
{
|
|
return (_First == 0 ? 0 : _Last - _First);
|
|
}
|
|
size_type max_size() const
|
|
{
|
|
return (allocator.max_size());
|
|
}
|
|
bool empty() const
|
|
{
|
|
return (size() == 0);
|
|
}
|
|
_A get_allocator() const
|
|
{
|
|
return (allocator);
|
|
}
|
|
const_reference at(size_type _P) const
|
|
{
|
|
ASSERT (_P < size());
|
|
return (*(begin() + _P));
|
|
}
|
|
reference at(size_type _P)
|
|
{
|
|
ASSERT (_P < size());
|
|
return (*(begin() + _P));
|
|
}
|
|
const_reference operator[](size_type _P) const
|
|
{
|
|
return (*(begin() + _P));
|
|
}
|
|
reference operator[](size_type _P)
|
|
{
|
|
return (*(begin() + _P));
|
|
}
|
|
reference front()
|
|
{
|
|
return (*begin());
|
|
}
|
|
const_reference front() const
|
|
{
|
|
return (*begin());
|
|
}
|
|
reference back()
|
|
{
|
|
return (*(end() - 1));
|
|
}
|
|
const_reference back() const
|
|
{
|
|
return (*(end() - 1));
|
|
}
|
|
void push_back(const _Ty& _X)
|
|
{
|
|
insert(end(), _X);
|
|
}
|
|
void pop_back()
|
|
{
|
|
erase(end() - 1);
|
|
}
|
|
void assign(_It _F, _It _L)
|
|
{
|
|
erase(begin(), end());
|
|
insert(begin(), _F, _L);
|
|
}
|
|
void assign(size_type _N, const _Ty& _X = _Ty())
|
|
{
|
|
erase(begin(), end());
|
|
insert(begin(), _N, _X);
|
|
}
|
|
iterator insert(iterator _P, const _Ty& _X = _Ty())
|
|
{
|
|
size_type _O = _P - begin();
|
|
insert(_P, 1, _X);
|
|
return (begin() + _O);
|
|
}
|
|
void insert(iterator _P, size_type _M, const _Ty& _X)
|
|
{
|
|
if ((size_type)(_End - _Last) < _M)
|
|
{
|
|
size_type _N = size() + (_M < size() ? size() : _M);
|
|
iterator _S = allocator.allocate(_N, (void *)0);
|
|
iterator _Q = _Ucopy(_First, _P, _S);
|
|
_Ufill(_Q, _M, _X);
|
|
_Ucopy(_P, _Last, _Q + _M);
|
|
_Destroy(_First, _Last);
|
|
allocator.deallocate(_First, _End - _First);
|
|
_End = _S + _N;
|
|
_Last = _S + size() + _M;
|
|
_First = _S;
|
|
}
|
|
else if ((size_type)(_Last - _P) < _M)
|
|
{
|
|
_Ucopy(_P, _Last, _P + _M);
|
|
_Ufill(_Last, _M - (_Last - _P), _X);
|
|
fill(_P, _Last, _X);
|
|
_Last += _M;
|
|
}
|
|
else if (0 < _M)
|
|
{
|
|
_Ucopy(_Last - _M, _Last, _Last);
|
|
copy_backward(_P, _Last - _M, _Last);
|
|
fill(_P, _P + _M, _X);
|
|
_Last += _M;
|
|
}
|
|
}
|
|
void insert(iterator _P, _It _F, _It _L)
|
|
{
|
|
difference_type _M = 0;
|
|
_Distance(_F, _L, _M);
|
|
if (_End - _Last < _M)
|
|
{
|
|
size_type _N = size() + (_M < (difference_type)size() ? size() : _M);
|
|
iterator _S = allocator.allocate(_N, (void *)0);
|
|
iterator _Q = _Ucopy(_First, _P, _S);
|
|
_Q = _Ucopy(_F, _L, _Q);
|
|
_Ucopy(_P, _Last, _Q);
|
|
_Destroy(_First, _Last);
|
|
allocator.deallocate(_First, _End - _First);
|
|
_End = _S + _N;
|
|
_Last = _S + size() + _M;
|
|
_First = _S;
|
|
}
|
|
else if (_Last - _P < _M)
|
|
{
|
|
_Ucopy(_P, _Last, _P + _M);
|
|
_Ucopy(_F + (_Last - _P), _L, _Last);
|
|
copy(_F, _F + (_Last - _P), _P);
|
|
_Last += _M;
|
|
}
|
|
else if (0 < _M)
|
|
{
|
|
_Ucopy(_Last - _M, _Last, _Last);
|
|
copy_backward(_P, _Last - _M, _Last);
|
|
copy(_F, _L, _P);
|
|
_Last += _M;
|
|
}
|
|
}
|
|
iterator erase(iterator _P)
|
|
{
|
|
copy(_P + 1, end(), _P);
|
|
_Destroy(_Last - 1, _Last);
|
|
--_Last;
|
|
return (_P);
|
|
}
|
|
iterator erase(iterator _F, iterator _L)
|
|
{
|
|
iterator _S = copy(_L, end(), _F);
|
|
_Destroy(_S, end());
|
|
_Last = _S;
|
|
return (_F);
|
|
}
|
|
void clear()
|
|
{
|
|
erase(begin(), end());
|
|
}
|
|
/*
|
|
bool operator==(const _Myt& _X) const
|
|
{
|
|
return (size() == _X.size()
|
|
&& equal(begin(), end(), _X.begin()));
|
|
}
|
|
bool operator!=(const _Myt& _X) const
|
|
{
|
|
return (!(*this == _X));
|
|
}
|
|
bool operator<(const _Myt& _X) const
|
|
{
|
|
return (lexicographical_compare(begin(), end(),
|
|
_X.begin(), _X.end()));
|
|
}
|
|
bool operator>(const _Myt& _X) const
|
|
{
|
|
return (_X < *this);
|
|
}
|
|
bool operator<=(const _Myt& _X) const
|
|
{
|
|
return (!(_X < *this));
|
|
}
|
|
bool operator>=(const _Myt& _X) const
|
|
{
|
|
return (!(*this < _X));
|
|
}
|
|
*/
|
|
void swap(_Myt& _X)
|
|
{
|
|
if (allocator == _X.allocator)
|
|
{
|
|
std::swap(_First, _X._First);
|
|
std::swap(_Last, _X._Last);
|
|
std::swap(_End, _X._End);
|
|
}
|
|
else
|
|
{
|
|
_Myt _Ts = *this; *this = _X, _X = _Ts;
|
|
}
|
|
}
|
|
friend void swap(_Myt& _X, _Myt& _Y)
|
|
{
|
|
_X.swap(_Y);
|
|
}
|
|
protected:
|
|
void _Destroy(iterator _F, iterator _L)
|
|
{
|
|
for (; _F != _L; ++_F)
|
|
allocator.destroy(_F);
|
|
}
|
|
iterator _Ucopy(const_iterator _F, const_iterator _L,
|
|
iterator _P)
|
|
{
|
|
for (; _F != _L; ++_P, ++_F)
|
|
allocator.construct(_P, *_F);
|
|
return (_P);
|
|
}
|
|
void _Ufill(iterator _F, size_type _N, const _Ty &_X)
|
|
{
|
|
for (; 0 < _N; --_N, ++_F)
|
|
allocator.construct(_F, _X);
|
|
}
|
|
_A allocator;
|
|
iterator _First, _Last, _End;
|
|
};
|
|
|
|
/*
|
|
// CLASS vector<_Bool, allocator>
|
|
typedef unsigned int _Vbase;
|
|
const int _VBITS = CHAR_BIT * sizeof (_Vbase);
|
|
typedef allocator<_Vbase> _Bool_allocator;
|
|
class vector<_Bool, _Bool_allocator>
|
|
{
|
|
public:
|
|
typedef _Bool_allocator _A;
|
|
typedef _Bool _Ty;
|
|
typedef vector<_Ty, _A> _Myt;
|
|
typedef vector<_Vbase, _A> _Vbtype;
|
|
typedef _A allocator_type;
|
|
typedef _A::size_type size_type;
|
|
typedef _A::difference_type difference_type;
|
|
// CLASS reference
|
|
class reference
|
|
{
|
|
public:
|
|
reference()
|
|
: _Mask(0), _Ptr(0)
|
|
{
|
|
|
|
}
|
|
reference(size_t _O, _Vbase *_P)
|
|
: _Mask((_Vbase)1 << _O), _Ptr(_P)
|
|
{
|
|
|
|
}
|
|
reference& operator=(const reference& _X)
|
|
{
|
|
return (*this = bool(_X));
|
|
}
|
|
reference& operator=(bool _V)
|
|
{
|
|
if (_V)
|
|
*_Ptr |= _Mask;
|
|
else
|
|
*_Ptr &= ~_Mask;
|
|
return (*this);
|
|
}
|
|
void flip()
|
|
{
|
|
*_Ptr ^= _Mask;
|
|
}
|
|
bool operator~() const
|
|
{
|
|
return (!bool(*this));
|
|
}
|
|
operator bool() const
|
|
{
|
|
return ((*_Ptr & _Mask) != 0);
|
|
}
|
|
protected:
|
|
_Vbase _Mask, *_Ptr;
|
|
};
|
|
typedef const reference const_reference;
|
|
typedef bool value_type;
|
|
// CLASS iterator
|
|
class iterator : public _Ranit<_Bool, difference_type>
|
|
{
|
|
public:
|
|
iterator()
|
|
: _Off(0), _Ptr(0)
|
|
{
|
|
|
|
}
|
|
iterator(size_t _O, _Vbase *_P)
|
|
: _Off(_O), _Ptr(_P)
|
|
{
|
|
|
|
}
|
|
reference operator*() const
|
|
{
|
|
return (reference(_Off, _Ptr));
|
|
}
|
|
iterator& operator++()
|
|
{
|
|
_Inc();
|
|
return (*this);
|
|
}
|
|
iterator operator++(int)
|
|
{
|
|
iterator _Tmp = *this;
|
|
_Inc();
|
|
return (_Tmp);
|
|
}
|
|
iterator& operator--()
|
|
{
|
|
_Dec();
|
|
return (*this);
|
|
}
|
|
iterator operator--(int)
|
|
{
|
|
iterator _Tmp = *this;
|
|
_Dec();
|
|
return (_Tmp);
|
|
}
|
|
iterator& operator+=(difference_type _N)
|
|
{
|
|
_Off += (size_t)_N;
|
|
_Ptr += _Off / _VBITS;
|
|
_Off %= _VBITS;
|
|
return (*this);
|
|
}
|
|
iterator& operator-=(difference_type _N)
|
|
{
|
|
return (*this += -_N);
|
|
}
|
|
iterator operator+(difference_type _N) const
|
|
{
|
|
iterator _Tmp = *this;
|
|
return (_Tmp += _N);
|
|
}
|
|
iterator operator-(difference_type _N) const
|
|
{
|
|
iterator _Tmp = *this;
|
|
return (_Tmp -= _N);
|
|
}
|
|
difference_type operator-(const iterator _X) const
|
|
{
|
|
return (_VBITS * (_Ptr - _X._Ptr)
|
|
+ (difference_type)_Off
|
|
- (difference_type)_X._Off);
|
|
}
|
|
reference operator[](difference_type _N) const
|
|
{
|
|
return (*(*this + _N));
|
|
}
|
|
bool operator==(const iterator& _X) const
|
|
{
|
|
return (_Ptr == _X._Ptr && _Off == _X._Off);
|
|
}
|
|
bool operator!=(const iterator& _X) const
|
|
{
|
|
return (!(*this == _X));
|
|
}
|
|
bool operator<(const iterator& _X) const
|
|
{
|
|
return (_Ptr < _X._Ptr
|
|
|| _Ptr == _X._Ptr && _Off < _X._Off);
|
|
}
|
|
bool operator>(const iterator& _X) const
|
|
{
|
|
return (_X < *this);
|
|
}
|
|
bool operator<=(const iterator& _X) const
|
|
{
|
|
return (!(_X < *this));
|
|
}
|
|
bool operator>=(const iterator& _X) const
|
|
{
|
|
return (!(*this < _X));
|
|
}
|
|
protected:
|
|
void _Dec()
|
|
{
|
|
if (_Off != 0)
|
|
--_Off;
|
|
else
|
|
_Off = _VBITS - 1, --_Ptr;
|
|
}
|
|
void _Inc()
|
|
{
|
|
if (_Off < _VBITS - 1)
|
|
++_Off;
|
|
else
|
|
_Off = 0, ++_Ptr;
|
|
}
|
|
size_t _Off;
|
|
_Vbase *_Ptr;
|
|
};
|
|
// CLASS const_iterator
|
|
class const_iterator : public iterator
|
|
{
|
|
public:
|
|
const_iterator()
|
|
: iterator()
|
|
{
|
|
|
|
}
|
|
const_iterator(size_t _O, const _Vbase *_P)
|
|
: iterator(_O, (_Vbase *)_P)
|
|
{
|
|
|
|
}
|
|
const_iterator(const iterator& _X)
|
|
: iterator(_X)
|
|
{
|
|
|
|
}
|
|
const_reference operator*() const
|
|
{
|
|
return (reference(_Off, _Ptr));
|
|
}
|
|
const_iterator& operator++()
|
|
{
|
|
_Inc();
|
|
return (*this);
|
|
}
|
|
const_iterator operator++(int)
|
|
{
|
|
const_iterator _Tmp = *this;
|
|
_Inc();
|
|
return (_Tmp);
|
|
}
|
|
const_iterator& operator--()
|
|
{
|
|
_Dec();
|
|
return (*this);
|
|
}
|
|
const_iterator operator--(int)
|
|
{
|
|
const_iterator _Tmp = *this;
|
|
_Dec();
|
|
return (_Tmp);
|
|
}
|
|
const_iterator& operator+=(difference_type _N)
|
|
{
|
|
_Off += (size_t)_N;
|
|
_Ptr += _Off / _VBITS;
|
|
_Off %= _VBITS;
|
|
return (*this);
|
|
}
|
|
const_iterator& operator-=(difference_type _N)
|
|
{
|
|
return (*this += -_N);
|
|
}
|
|
const_iterator operator+(difference_type _N) const
|
|
{
|
|
const_iterator _Tmp = *this;
|
|
return (_Tmp += _N);
|
|
}
|
|
const_iterator operator-(difference_type _N) const
|
|
{
|
|
const_iterator _Tmp = *this;
|
|
return (_Tmp -= _N);
|
|
}
|
|
difference_type operator-(const const_iterator _X) const
|
|
{
|
|
return (_VBITS * (_Ptr - _X._Ptr)
|
|
+ (difference_type)_Off
|
|
- (difference_type)_X._Off);
|
|
}
|
|
const_reference operator[](difference_type _N) const
|
|
{
|
|
return (*(*this + _N));
|
|
}
|
|
bool operator==(const const_iterator& _X) const
|
|
{
|
|
return (_Ptr == _X._Ptr && _Off == _X._Off);
|
|
}
|
|
bool operator!=(const const_iterator& _X) const
|
|
{
|
|
return (!(*this == _X));
|
|
}
|
|
bool operator<(const const_iterator& _X) const
|
|
{
|
|
return (_Ptr < _X._Ptr
|
|
|| _Ptr == _X._Ptr && _Off < _X._Off);
|
|
}
|
|
bool operator>(const const_iterator& _X) const
|
|
{
|
|
return (_X < *this);
|
|
}
|
|
bool operator<=(const const_iterator& _X) const
|
|
{
|
|
return (!(_X < *this));
|
|
}
|
|
bool operator>=(const const_iterator& _X) const
|
|
{
|
|
return (!(*this < _X));
|
|
}
|
|
};
|
|
typedef reverse_iterator<const_iterator, value_type,
|
|
const_reference, const_reference *, difference_type>
|
|
const_reverse_iterator;
|
|
typedef reverse_iterator<iterator, value_type,
|
|
reference, reference *, difference_type>
|
|
reverse_iterator;
|
|
explicit vector(const _A& _Al = _A())
|
|
: _Size(0), _Vec(_Al)
|
|
{
|
|
|
|
}
|
|
explicit vector(size_type _N, const bool _V = false,
|
|
const _A& _Al = _A())
|
|
: _Vec(_Nw(_N), _V ? -1 : 0, _Al)
|
|
{
|
|
_Trim(_N);
|
|
}
|
|
typedef const_iterator _It;
|
|
vector(_It _F, _It _L, const _A& _Al = _A())
|
|
: _Size(0), _Vec(_Al)
|
|
{
|
|
insert(begin(), _F, _L);
|
|
}
|
|
~vector()
|
|
{
|
|
_Size = 0;
|
|
}
|
|
void reserve(size_type _N)
|
|
{
|
|
_Vec.reserve(_Nw(_N));
|
|
}
|
|
size_type capacity() const
|
|
{
|
|
return (_Vec.capacity() * _VBITS);
|
|
}
|
|
iterator begin()
|
|
{
|
|
return (iterator(0, _Vec.begin()));
|
|
}
|
|
const_iterator begin() const
|
|
{
|
|
return (const_iterator(0, _Vec.begin()));
|
|
}
|
|
iterator end()
|
|
{
|
|
iterator _Tmp = begin();
|
|
if (0 < _Size)
|
|
_Tmp += _Size;
|
|
return (_Tmp);
|
|
}
|
|
const_iterator end() const
|
|
{
|
|
const_iterator _Tmp = begin();
|
|
if (0 < _Size)
|
|
_Tmp += _Size;
|
|
return (_Tmp);
|
|
}
|
|
reverse_iterator rbegin()
|
|
{
|
|
return (reverse_iterator(end()));
|
|
}
|
|
const_reverse_iterator rbegin() const
|
|
{
|
|
return (const_reverse_iterator(end()));
|
|
}
|
|
reverse_iterator rend()
|
|
{
|
|
return (reverse_iterator(begin()));
|
|
}
|
|
const_reverse_iterator rend() const
|
|
{
|
|
return (const_reverse_iterator(begin()));
|
|
}
|
|
void resize(size_type _N, bool _X = false)
|
|
{
|
|
if (size() < _N)
|
|
insert(end(), _N - size(), _X);
|
|
else if (_N < size())
|
|
erase(begin() + _N, end());
|
|
}
|
|
size_type size() const
|
|
{
|
|
return (_Size);
|
|
}
|
|
size_type max_size() const
|
|
{
|
|
return (_Vec.max_size() * _VBITS);
|
|
}
|
|
bool empty() const
|
|
{
|
|
return (size() == 0);
|
|
}
|
|
_A get_allocator() const
|
|
{
|
|
return (_Vec.get_allocator());
|
|
}
|
|
const_reference at(size_type _P) const
|
|
{
|
|
if (size() <= _P)
|
|
_Xran();
|
|
return (*(begin() + _P));
|
|
}
|
|
reference at(size_type _P)
|
|
{
|
|
if (size() <= _P)
|
|
_Xran();
|
|
return (*(begin() + _P));
|
|
}
|
|
const_reference operator[](size_type _P) const
|
|
{
|
|
return (*(begin() + _P));
|
|
}
|
|
reference operator[](size_type _P)
|
|
{
|
|
return (*(begin() + _P));
|
|
}
|
|
reference front()
|
|
{
|
|
return (*begin());
|
|
}
|
|
const_reference front() const
|
|
{
|
|
return (*begin());
|
|
}
|
|
reference back()
|
|
{
|
|
return (*(end() - 1));
|
|
}
|
|
const_reference back() const
|
|
{
|
|
return (*(end() - 1));
|
|
}
|
|
void push_back(const bool _X)
|
|
{
|
|
insert(end(), _X);
|
|
}
|
|
void pop_back()
|
|
{
|
|
erase(end() - 1);
|
|
}
|
|
void assign(_It _F, _It _L)
|
|
{
|
|
erase(begin(), end());
|
|
insert(begin(), _F, _L);
|
|
}
|
|
void assign(size_type _N, const bool _X = false)
|
|
{
|
|
erase(begin(), end());
|
|
insert(begin(), _N, _X);
|
|
}
|
|
iterator insert(iterator _P, const bool _X = false)
|
|
{
|
|
size_type _O = _P - begin();
|
|
insert(_P, 1, _X);
|
|
return (begin() + _O);
|
|
}
|
|
void insert(iterator _P, size_type _M, const bool _X)
|
|
{
|
|
if (0 < _M)
|
|
{
|
|
if (capacity() - size() < _M)
|
|
{
|
|
size_type _O = _P - begin();
|
|
_Vec.resize(_Nw(size() + _M), 0);
|
|
_P = begin() + _O;
|
|
}
|
|
copy_backward(_P, end(), end() + _M);
|
|
fill(_P, _P + _M, _X);
|
|
_Size += _M;
|
|
}
|
|
}
|
|
void insert(iterator _P, _It _F, _It _L)
|
|
{
|
|
size_type _M = 0;
|
|
_Distance(_F, _L, _M);
|
|
if (0 < _M)
|
|
{
|
|
if (capacity() - size() < _M)
|
|
{
|
|
size_type _O = _P - begin();
|
|
_Vec.resize(_Nw(size() + _M), 0);
|
|
_P = begin() + _O;
|
|
}
|
|
copy_backward(_P, end(), end() + _M);
|
|
copy(_F, _L, _P);
|
|
_Size += _M;
|
|
}
|
|
}
|
|
iterator erase(iterator _P)
|
|
{
|
|
copy(_P + 1, end(), _P);
|
|
_Trim(_Size - 1);
|
|
return (_P);
|
|
}
|
|
iterator erase(iterator _F, iterator _L)
|
|
{
|
|
iterator _S = copy(_L, end(), _F);
|
|
_Trim(_S - begin());
|
|
return (_F);
|
|
}
|
|
void clear()
|
|
{
|
|
erase(begin(), end());
|
|
}
|
|
void flip()
|
|
{
|
|
for (_Vbtype::iterator _S = _Vec.begin();
|
|
_S != _Vec.end(); ++_S)
|
|
*_S = ~*_S;
|
|
_Trim(_Size);
|
|
}
|
|
bool operator==(const _Myt& _X) const
|
|
{
|
|
return (_Size == _X._Size && _Vec == _X._Vec);
|
|
}
|
|
bool operator!=(const _Myt& _X) const
|
|
{
|
|
return (!(*this == _X));
|
|
}
|
|
bool operator<(const _Myt& _X) const
|
|
{
|
|
return (_Size < _X._Size
|
|
|| _Size == _X._Size && _Vec < _X._Vec);
|
|
}
|
|
bool operator>(const _Myt& _X) const
|
|
{
|
|
return (_X < *this);
|
|
}
|
|
bool operator<=(const _Myt& _X) const
|
|
{
|
|
return (!(_X < *this));
|
|
}
|
|
bool operator>=(const _Myt& _X) const
|
|
{
|
|
return (!(*this < _X));
|
|
}
|
|
void swap(_Myt& _X)
|
|
{
|
|
std::swap(_Size, _X._Size);
|
|
_Vec.swap(_X._Vec);
|
|
}
|
|
friend void swap(_Myt& _X, _Myt& _Y)
|
|
{
|
|
_X.swap(_Y);
|
|
}
|
|
static void swap(reference _X, reference _Y)
|
|
{
|
|
bool _V = _X;
|
|
_X = _Y;
|
|
_Y = _V;
|
|
}
|
|
protected:
|
|
static size_type _Nw(size_type _N)
|
|
{
|
|
return ((_N + _VBITS - 1) / _VBITS);
|
|
}
|
|
void _Trim(size_type _N)
|
|
{
|
|
size_type _M = _Nw(_N);
|
|
if (_M < _Vec.size())
|
|
_Vec.erase(_Vec.begin() + _M, _Vec.end());
|
|
_Size = _N;
|
|
_N %= _VBITS;
|
|
if (0 < _N)
|
|
_Vec[_M - 1] &= ((_Vbase)1 << _N) - 1;
|
|
}
|
|
void _Xran() const
|
|
{
|
|
_THROW(out_of_range, "invalid vector<bool> subscript");
|
|
}
|
|
size_type _Size;
|
|
_Vbtype _Vec;
|
|
};
|
|
typedef vector<_Bool, _Bool_allocator> _Bvector;
|
|
*/
|
|
|
|
_STD_END
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma pack(pop)
|
|
#endif /* _MSC_VER */
|
|
|
|
#endif /* _STLVEC_H_ */
|
|
|
|
/*
|
|
* Copyright (c) 1995 by P.J. Plauger. ALL RIGHTS RESERVED.
|
|
* Consult your license regarding permissions and restrictions.
|
|
*/
|
|
|
|
/*
|
|
* This file is derived from software bearing the following
|
|
* restrictions:
|
|
*
|
|
* Copyright (c) 1994
|
|
* Hewlett-Packard Company
|
|
*
|
|
* Permission to use, copy, modify, distribute and sell this
|
|
* software and its documentation for any purpose is hereby
|
|
* granted without fee, provided that the above copyright notice
|
|
* appear in all copies and that both that copyright notice and
|
|
* this permission notice appear in supporting documentation.
|
|
* Hewlett-Packard Company makes no representations about the
|
|
* suitability of this software for any purpose. It is provided
|
|
* "as is" without express or implied warranty.
|
|
*/
|