vector< bool, _Alloc > Class Template Reference

Inheritance diagram for vector< bool, _Alloc >:

Public Types
enum	{ _EEN_VBITS = _VBITS }
typedef vector< bool, _Alloc >	_Myt
typedef _Vb_val< _Alloc >	_Mybase
typedef _Mybase::_Alty	_Alty
typedef _Mybase::_Vectype	_Vectype
typedef _Alty::size_type	size_type
typedef _Alty::difference_type	difference_type
typedef bool	_Ty
typedef _Alloc	allocator_type
typedef _Vb_reference< _Alty >	reference
typedef bool	const_reference
typedef bool	value_type
typedef reference	_Reft
typedef _Vb_const_iterator< _Alty >	const_iterator
typedef _Vb_iterator< _Alty >	iterator
typedef iterator	pointer
typedef const_iterator	const_pointer
typedef _STD reverse_iterator< iterator >	reverse_iterator
typedef _STD reverse_iterator< const_iterator >	const_reverse_iterator
Public Types inherited from _Vb_val< _Alloc >
typedef vector< _Vbase, _Alloc >	_Vectype
typedef _Vectype::_Alty	_Alty
typedef _Alty::size_type	size_type

Public Member Functions
	vector ()
	vector (const _Alloc &_Al)
	vector (size_type _Count, const _Alloc &_Al=_Alloc())
	vector (size_type _Count, const bool &_Val, const _Alloc &_Al=_Alloc())
	vector (const _Myt &_Right)
	vector (const _Myt &_Right, const _Alloc &_Al)
template<class _Iter , class = typename enable_if<_Is_iterator<_Iter>::value, void>::type>
	vector (_Iter _First, _Iter _Last, const _Alloc &_Al=_Alloc())
template<class _Iter >
void	_BConstruct (_Iter _First, _Iter _Last)
	vector (_Myt &&_Right)
	vector (_Myt &&_Right, const _Alloc &_Al)
_Myt &	operator= (_Myt &&_Right)
template<class... _Valty>
void	emplace_back (_Valty &&..._Val)
template<class... _Valty>
iterator	emplace (const_iterator _Where, _Valty &&..._Val)
	vector (_XSTD initializer_list< bool > _Ilist, const _Alloc &_Al=allocator_type())
_Myt &	operator= (_XSTD initializer_list< bool > _Ilist)
void	assign (_XSTD initializer_list< bool > _Ilist)
iterator	insert (const_iterator _Where, _XSTD initializer_list< bool > _Ilist)
	~vector () _NOEXCEPT
_Myt &	operator= (const _Myt &_Right)
void	reserve (size_type _Count)
size_type	capacity () const _NOEXCEPT
iterator	begin () _NOEXCEPT
const_iterator	begin () const _NOEXCEPT
iterator	end () _NOEXCEPT
const_iterator	end () const _NOEXCEPT
const_iterator	cbegin () const _NOEXCEPT
const_iterator	cend () const _NOEXCEPT
const_reverse_iterator	crbegin () const _NOEXCEPT
const_reverse_iterator	crend () const _NOEXCEPT
void	shrink_to_fit ()
iterator	_Make_iter (const_iterator _Where)
reverse_iterator	rbegin () _NOEXCEPT
const_reverse_iterator	rbegin () const _NOEXCEPT
reverse_iterator	rend () _NOEXCEPT
const_reverse_iterator	rend () const _NOEXCEPT
void	resize (size_type _Newsize, bool _Val=false)
size_type	size () const _NOEXCEPT
size_type	max_size () const _NOEXCEPT
bool	empty () const _NOEXCEPT
_Alloc	get_allocator () const _NOEXCEPT
const_reference	at (size_type _Off) const
reference	at (size_type _Off)
const_reference	operator[] (size_type _Off) const
reference	operator[] (size_type _Off)
reference	front ()
const_reference	front () const
reference	back ()
const_reference	back () const
void	push_back (const bool &_Val)
void	pop_back ()
template<class _Iter >
enable_if< _Is_iterator< _Iter >::value, void >::type	assign (_Iter _First, _Iter _Last)
void	assign (size_type _Count, const bool &_Val)
iterator	insert (const_iterator _Where, const bool &_Val)
iterator	insert (const_iterator _Where, size_type _Count, const bool &_Val)
template<class _Iter >
enable_if< _Is_iterator< _Iter >::value, iterator >::type	insert (const_iterator _Where, _Iter _First, _Iter _Last)
template<class _Iter >
void	_Insert (const_iterator _Where, _Iter _First, _Iter _Last, input_iterator_tag)
template<class _Iter >
void	_Insert (const_iterator _Where, _Iter _First, _Iter _Last, forward_iterator_tag)
iterator	erase (const_iterator _Where_arg)
iterator	erase (const_iterator _First_arg, const_iterator _Last_arg)
void	clear () _NOEXCEPT
void	flip () _NOEXCEPT
void	swap (_Myt &_Right)
size_t	hash () const
iterator	_Insert_n (const_iterator _Where, size_type _Count, const bool &_Val)
size_type	_Insert_x (const_iterator _Where, size_type _Count)
void	_Orphan_range (size_type, size_type) const
void	_Trim (size_type _Size)
void	_Xlen () const
void	_Xran () const
Public Member Functions inherited from _Vb_val< _Alloc >
	_Vb_val (size_type _Count, const bool &_Val)
	_Vb_val (size_type _Count, const bool &_Val, const _Alloc &_Al)
	_Vb_val (const _Vb_val &_Right)
	_Vb_val (const _Vb_val &_Right, const _Alloc &_Al)
	_Vb_val (_Vb_val &&_Right)
	_Vb_val (_Vb_val &&_Right, const _Alloc &_Al)
	~_Vb_val () _NOEXCEPT
void	_Alloc_proxy ()
void	_Free_proxy ()
Public Member Functions inherited from _Container_base0
void	_Orphan_all ()
void	_Swap_all (_Container_base0 &)

Static Public Member Functions
static void	swap (reference _Left, reference _Right) _NOEXCEPT
Static Public Member Functions inherited from _Vb_val< _Alloc >
static size_type	_Nw (size_type _Count)

Static Public Attributes
static const int	_VBITS = _STD _VBITS

Additional Inherited Members
Public Attributes inherited from _Vb_val< _Alloc >
_Vectype	_Myvec
_Alty::size_type	_Mysize

Member Typedef Documentation

template<class _Alloc >

typedef _Mybase::_Alty vector< bool, _Alloc >::_Alty

template<class _Alloc >

typedef _Vb_val<_Alloc> vector< bool, _Alloc >::_Mybase

template<class _Alloc >

typedef vector<bool, _Alloc> vector< bool, _Alloc >::_Myt

template<class _Alloc >

typedef reference vector< bool, _Alloc >::_Reft

template<class _Alloc >

typedef bool vector< bool, _Alloc >::_Ty

template<class _Alloc >

typedef _Mybase::_Vectype vector< bool, _Alloc >::_Vectype

template<class _Alloc >

typedef _Alloc vector< bool, _Alloc >::allocator_type

template<class _Alloc >

typedef _Vb_const_iterator<_Alty> vector< bool, _Alloc >::const_iterator

template<class _Alloc >

typedef const_iterator vector< bool, _Alloc >::const_pointer

template<class _Alloc >

typedef bool vector< bool, _Alloc >::const_reference

template<class _Alloc >

typedef _STD reverse_iterator<const_iterator> vector< bool, _Alloc >::const_reverse_iterator

template<class _Alloc >

typedef _Alty::difference_type vector< bool, _Alloc >::difference_type

template<class _Alloc >

typedef _Vb_iterator<_Alty> vector< bool, _Alloc >::iterator

template<class _Alloc >

typedef iterator vector< bool, _Alloc >::pointer

template<class _Alloc >

typedef _Vb_reference<_Alty> vector< bool, _Alloc >::reference

template<class _Alloc >

typedef _STD reverse_iterator<iterator> vector< bool, _Alloc >::reverse_iterator

template<class _Alloc >

typedef _Alty::size_type vector< bool, _Alloc >::size_type

template<class _Alloc >

typedef bool vector< bool, _Alloc >::value_type

Member Enumeration Documentation

template<class _Alloc >

anonymous enum

Enumerator
_EEN_VBITS

{_EEN_VBITS = _VBITS};  // helper for expression evaluator

Constructor & Destructor Documentation

template<class _Alloc >

vector< bool, _Alloc >::vector ( )

inline

        : _Mybase(0, false)
        {   // construct empty vector
        }

template<class _Alloc >

vector< bool, _Alloc >::vector ( const _Alloc &  _Al )

inlineexplicit

        : _Mybase(0, false, _Al)
        {   // construct empty vector, allocator
        }

template<class _Alloc >

vector< bool, _Alloc >::vector ( size_type  _Count, const _Alloc &  _Al = _Alloc()  )

inlineexplicit

        : _Mybase(_Count, false, _Al)
        {   // construct from _Count * false, optional allocator
        _Trim(_Count);
        }

template<class _Alloc >

vector< bool, _Alloc >::vector ( size_type  _Count, const bool &  _Val, const _Alloc &  _Al = _Alloc()  )

inline

        : _Mybase(_Count, _Val, _Al)
        {   // construct from _Count * _Val, optional allocator
        _Trim(_Count);
        }

template<class _Alloc >

vector< bool, _Alloc >::vector ( const _Myt &  _Right )

inline

        : _Mybase(_Right)
        {   // construct by copying _Right
        }

template<class _Alloc >

vector< bool, _Alloc >::vector ( const _Myt &  _Right, const _Alloc &  _Al  )

inline

        : _Mybase(_Right, _Al)
        {   // construct by copying _Right, allocator
        }

template<class _Alloc >

template<class _Iter , class = typename enable_if<_Is_iterator<_Iter>::value, void>::type>

vector< bool, _Alloc >::vector ( _Iter  _First, _Iter  _Last, const _Alloc &  _Al = _Alloc()  )

inline

        : _Mybase(0, false, _Al)
        {   // construct from [_First, _Last), optional allocator
        _BConstruct(_First, _Last);
        }

template<class _Alloc >

vector< bool, _Alloc >::vector ( _Myt &&  _Right )

inline

        : _Mybase(_STD forward<_Myt>(_Right))
        {   // move construct by moving _Right
        }

template<class _Alloc >

vector< bool, _Alloc >::vector ( _Myt &&  _Right, const _Alloc &  _Al  )

inline

        : _Mybase(_STD forward<_Myt>(_Right), _Al)
        {   // move construct by moving _Right, allocator
        }

template<class _Alloc >

vector< bool, _Alloc >::vector ( _XSTD initializer_list< bool >  _Ilist, const _Alloc &  _Al = allocator_type()  )

inline

        : _Mybase(0, false, _Al)
        {   // construct from initializer_list
        insert(begin(), _Ilist.begin(), _Ilist.end());
        }

template<class _Alloc >

vector< bool, _Alloc >::~vector ( )

inline

        {   // destroy the object
        }

Member Function Documentation

template<class _Alloc >

template<class _Iter >

void vector< bool, _Alloc >::_BConstruct ( _Iter  _First, _Iter  _Last  )

inline

        {   // initialize from [_First, _Last), input iterators
        insert(begin(), _First, _Last);
        }

template<class _Alloc >

template<class _Iter >

void vector< bool, _Alloc >::_Insert ( const_iterator  _Where, _Iter  _First, _Iter  _Last, input_iterator_tag    )

inline

        {   // insert [_First, _Last) at _Where, input iterators
        size_type _Off = _Where - begin();

        for (; _First != _Last; ++_First, (void)++_Off)
            insert(begin() + _Off, *_First);
        }

template<class _Alloc >

template<class _Iter >

void vector< bool, _Alloc >::_Insert ( const_iterator  _Where, _Iter  _First, _Iter  _Last, forward_iterator_tag    )

inline

        {   // insert [_First, _Last) at _Where, forward iterators
        _DEBUG_RANGE(_First, _Last);
        size_type _Count = _STD distance(_First, _Last);
        size_type _Off = _Insert_x(_Where, _Count);
        _STD copy(_First, _Last, begin() + _Off);
        }

template<class _Alloc >

iterator vector< bool, _Alloc >::_Insert_n ( const_iterator  _Where, size_type  _Count, const bool &  _Val  )

inline

        {   // insert _Count * _Val at _Where
        size_type _Off = _Insert_x(_Where, _Count);
        _STD fill(begin() + _Off, begin() + (_Off + _Count), _Val);
        return (begin() + _Off);
        }

template<class _Alloc >

size_type vector< bool, _Alloc >::_Insert_x ( const_iterator  _Where, size_type  _Count  )

inline

        {   // make room to insert _Count elements at _Where
        size_type _Off = _Where - begin();

 #if _ITERATOR_DEBUG_LEVEL == 2
        if (end() < _Where)
            _DEBUG_ERROR("vector<bool> insert iterator outside range");
        bool _Realloc = capacity() - size() < _Count;
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        if (_Count == 0)
            ;
        else if (max_size() - size() < _Count)
            _Xlen();    // result too long
        else
            {   // worth doing
            this->_Myvec.resize(this->_Nw(size() + _Count), 0);
            if (empty())
                this->_Mysize += _Count;
            else
                {   // make room and copy down suffix
                iterator _Oldend = end();
                this->_Mysize += _Count;
                _STD copy_backward(begin() + _Off, _Oldend, end());
                }

 #if _ITERATOR_DEBUG_LEVEL == 2
            _Orphan_range(_Realloc ? 0 : _Off, this->_Mysize);
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
            }
        return (_Off);
        }

template<class _Alloc >

iterator vector< bool, _Alloc >::_Make_iter ( const_iterator  _Where )

inline

        {   // make iterator from const_iterator
        iterator _Tmp = begin();
        if (0 < this->_Mysize)
            _Tmp += _Where - begin();
        return (_Tmp);
        }

template<class _Alloc >

void vector< bool, _Alloc >::_Orphan_range ( size_type  , size_type    ) const

inline

        {   // orphan iterators within specified (inclusive) range
        }

template<class _Alloc >

void vector< bool, _Alloc >::_Trim ( size_type  _Size )

inline

        {   // trim base vector to exact length in bits
        if (max_size() < _Size)
            _Xlen();    // result too long
        size_type _Words = this->_Nw(_Size);

        if (_Words < this->_Myvec.size())
            this->_Myvec.erase(this->_Myvec.begin() + _Words,
                this->_Myvec.end());
        this->_Mysize = _Size;
        _Size %= _VBITS;
        if (0 < _Size)
            this->_Myvec[_Words - 1] &= ((_Vbase)(1) << _Size) - 1;
        }

template<class _Alloc >

void vector< bool, _Alloc >::_Xlen ( ) const

inline

        {   // report a length_error
        _Xlength_error("vector<bool> too long");
        }

template<class _Alloc >

void vector< bool, _Alloc >::_Xran ( ) const

inline

        {   // report an out_of_range error
        _Xout_of_range("invalid vector<bool> subscript");
        }

template<class _Alloc >

void vector< bool, _Alloc >::assign ( _XSTD initializer_list< bool >  _Ilist )

inline

        {   // assign initializer_list
        assign(_Ilist.begin(), _Ilist.end());
        }

template<class _Alloc >

template<class _Iter >

enable_if<_Is_iterator<_Iter>::value, void>::type vector< bool, _Alloc >::assign ( _Iter  _First, _Iter  _Last  )

inline

        {   // assign [_First, _Last), input iterators
        erase(begin(), end());
        insert(begin(), _First, _Last);
        }

template<class _Alloc >

void vector< bool, _Alloc >::assign ( size_type  _Count, const bool &  _Val  )

inline

        {   // assign _Count * _Val
        erase(begin(), end());
        _Insert_n(begin(), _Count, _Val);
        }

template<class _Alloc >

const_reference vector< bool, _Alloc >::at ( size_type  _Off ) const

inline

        {   // subscript nonmutable sequence with checking
        if (size() <= _Off)
            _Xran();
        return ((*this)[_Off]);
        }

template<class _Alloc >

reference vector< bool, _Alloc >::at ( size_type  _Off )

inline

        {   // subscript mutable sequence with checking
        if (size() <= _Off)
            _Xran();
        return ((*this)[_Off]);
        }

template<class _Alloc >

reference vector< bool, _Alloc >::back ( )

inline

        {   // return last element of mutable sequence
        return (*(end() - 1));
        }

template<class _Alloc >

const_reference vector< bool, _Alloc >::back ( ) const

inline

        {   // return last element of nonmutable sequence
        return (*(end() - 1));
        }

template<class _Alloc >

iterator vector< bool, _Alloc >::begin ( )

inline

        {   // return iterator for beginning of mutable sequence
        return (iterator(this->_Myvec.data(), this));
        }

template<class _Alloc >

const_iterator vector< bool, _Alloc >::begin ( ) const

inline

        {   // return iterator for beginning of nonmutable sequence
        return (const_iterator(this->_Myvec.data(), this));
        }

template<class _Alloc >

size_type vector< bool, _Alloc >::capacity ( ) const

inline

        {   // return current length of allocated storage
        return (this->_Myvec.capacity() * _VBITS);
        }

template<class _Alloc >

const_iterator vector< bool, _Alloc >::cbegin ( ) const

inline

        {   // return iterator for beginning of nonmutable sequence
        return (begin());
        }

template<class _Alloc >

const_iterator vector< bool, _Alloc >::cend ( ) const

inline

        {   // return iterator for end of nonmutable sequence
        return (end());
        }

template<class _Alloc >

void vector< bool, _Alloc >::clear ( )

inline

        {   // erase all elements
        erase(begin(), end());
        }

template<class _Alloc >

const_reverse_iterator vector< bool, _Alloc >::crbegin ( ) const

inline

        {   // return iterator for beginning of reversed nonmutable sequence
        return (rbegin());
        }

template<class _Alloc >

const_reverse_iterator vector< bool, _Alloc >::crend ( ) const

inline

        {   // return iterator for end of reversed nonmutable sequence
        return (rend());
        }

template<class _Alloc >

template<class... _Valty>

iterator vector< bool, _Alloc >::emplace ( const_iterator  _Where, _Valty &&...  _Val  )

inline

        {   // insert bool at _Where
        bool _Tmp(_STD forward<_Valty>(_Val)...);
        return (insert(_Where, _Tmp));
        }

template<class _Alloc >

template<class... _Valty>

void vector< bool, _Alloc >::emplace_back ( _Valty &&...  _Val )

inline

        {   // insert bool at end
        bool _Tmp(_STD forward<_Valty>(_Val)...);
        push_back(_Tmp);
        }

template<class _Alloc >

bool vector< bool, _Alloc >::empty ( ) const

inline

        {   // test if sequence is empty
        return (size() == 0);
        }

template<class _Alloc >

iterator vector< bool, _Alloc >::end ( )

inline

        {   // return iterator for end of mutable sequence
        iterator _Tmp = begin();
        if (0 < this->_Mysize)
            _Tmp += this->_Mysize;
        return (_Tmp);
        }

template<class _Alloc >

const_iterator vector< bool, _Alloc >::end ( ) const

inline

        {   // return iterator for end of nonmutable sequence
        const_iterator _Tmp = begin();
        if (0 < this->_Mysize)
            _Tmp += this->_Mysize;
        return (_Tmp);
        }

template<class _Alloc >

iterator vector< bool, _Alloc >::erase ( const_iterator  _Where_arg )

inline

        {   // erase element at _Where
        iterator _Where = _Make_iter(_Where_arg);
        size_type _Off = _Where - begin();

 #if _ITERATOR_DEBUG_LEVEL == 2
        if (end() <= _Where)
            _DEBUG_ERROR("vector<bool> erase iterator outside range");
        _STD copy(_Where + 1, end(), _Where);
        _Orphan_range(_Off, this->_Mysize);

 #else /* _ITERATOR_DEBUG_LEVEL == 2 */
        _STD copy(_Where + 1, end(), _Where);
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        _Trim(this->_Mysize - 1);
        return (begin() + _Off);
        }

template<class _Alloc >

iterator vector< bool, _Alloc >::erase ( const_iterator  _First_arg, const_iterator  _Last_arg  )

inline

        {   // erase [_First, _Last)
        iterator _First = _Make_iter(_First_arg);
        iterator _Last = _Make_iter(_Last_arg);
        size_type _Off = _First - begin();

        if (_First != _Last)
            {   // worth doing, copy down over hole
 #if _ITERATOR_DEBUG_LEVEL == 2
            if (_Last < _First || end() < _Last)
                _DEBUG_ERROR("vector<bool> erase iterator outside range");
            iterator _Next = _STD copy(_Last, end(), _First);
            size_type _Newsize = _Next - begin();
            _Orphan_range(_Newsize, this->_Mysize);
            _Trim(_Newsize);

 #else /* _ITERATOR_DEBUG_LEVEL == 2 */
            iterator _Next = _STD copy(_Last, end(), _First);
            _Trim(_Next - begin());
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
            }
        return (begin() + _Off);
        }

template<class _Alloc >

void vector< bool, _Alloc >::flip ( )

inline

        {   // toggle all elements
        for (typename _Vectype::iterator _Next = this->_Myvec.begin();
            _Next != this->_Myvec.end(); ++_Next)
            *_Next = (_Vbase)~*_Next;
        _Trim(this->_Mysize);
        }

template<class _Alloc >

reference vector< bool, _Alloc >::front ( )

inline

        {   // return first element of mutable sequence
        return (*begin());
        }

template<class _Alloc >

const_reference vector< bool, _Alloc >::front ( ) const

inline

        {   // return first element of nonmutable sequence
        return (*begin());
        }

template<class _Alloc >

_Alloc vector< bool, _Alloc >::get_allocator ( ) const

inline

        {   // return allocator object for values
        _Alloc _Ret(this->_Myvec.get_allocator());
        return (_Ret);
        }

template<class _Alloc >

size_t vector< bool, _Alloc >::hash ( ) const

inline

        {   // hash bits to size_t value by pseudorandomizing transform
        return (_Hash_seq((const unsigned char *)this->_Myvec.data(),
            this->_Myvec.size() * sizeof (_Vbase)));
        }

template<class _Alloc >

iterator vector< bool, _Alloc >::insert ( const_iterator  _Where, _XSTD initializer_list< bool >  _Ilist  )

inline

        {   // insert initializer_list
        return (insert(_Where, _Ilist.begin(), _Ilist.end()));
        }

template<class _Alloc >

iterator vector< bool, _Alloc >::insert ( const_iterator  _Where, const bool &  _Val  )

inline

        {   // insert _Val at _Where
        return (_Insert_n(_Where, (size_type)1, _Val));
        }

template<class _Alloc >

iterator vector< bool, _Alloc >::insert ( const_iterator  _Where, size_type  _Count, const bool &  _Val  )

inline

        {   // insert _Count * _Val at _Where
        return (_Insert_n(_Where, _Count, _Val));
        }

template<class _Alloc >

template<class _Iter >

enable_if<_Is_iterator<_Iter>::value, iterator>::type vector< bool, _Alloc >::insert ( const_iterator  _Where, _Iter  _First, _Iter  _Last  )

inline

        {   // insert [_First, _Last) at _Where
        size_type _Off = _Where - begin();
        _Insert(_Where, _First, _Last, _Iter_cat_t<_Iter>());
        return (begin() + _Off);
        }

template<class _Alloc >

size_type vector< bool, _Alloc >::max_size ( ) const

inline

        {   // return maximum possible length of sequence
        const size_type _Maxsize = this->_Myvec.max_size();
        return (_Maxsize < (size_type)(-1) / _VBITS
            ? _Maxsize * _VBITS : (size_type)(-1));
        }

template<class _Alloc >

_Myt& vector< bool, _Alloc >::operator= ( _Myt &&  _Right )

inline

        {   // assign by moving _Right
        if (this != &_Right)
            {   // different, assign it
            clear();

            if (_Alty::propagate_on_container_move_assignment::value
                && this->get_allocator() != _Right.get_allocator())
                {   // assign vector, dumping proxy
                this->_Free_proxy();
                this->_Myvec = _STD move(_Right._Myvec);
                this->_Alloc_proxy();
                }
            else
                this->_Myvec = _STD move(_Right._Myvec);


            this->_Mysize = _Right._Mysize;
            _Right._Mysize = 0;
            }
        return (*this);
        }

template<class _Alloc >

_Myt& vector< bool, _Alloc >::operator= ( _XSTD initializer_list< bool >  _Ilist )

inline

        {   // assign initializer_list
        assign(_Ilist.begin(), _Ilist.end());
        return (*this);
        }

template<class _Alloc >

_Myt& vector< bool, _Alloc >::operator= ( const _Myt &  _Right )

inline

        {   // assign from _Right
        this->_Mysize = _Right._Mysize;
        this->_Myvec = _Right._Myvec;
        return (*this);
        }

template<class _Alloc >

const_reference vector< bool, _Alloc >::operator[] ( size_type  _Off ) const

inline

        {   // subscript nonmutable sequence
        const_iterator _It = begin();
        _It._Advance(_Off);
        return (*_It);
        }

template<class _Alloc >

reference vector< bool, _Alloc >::operator[] ( size_type  _Off )

inline

        {   // subscript mutable sequence
        iterator _It = begin();
        _It._Advance(_Off);
        return (*_It);
        }

template<class _Alloc >

void vector< bool, _Alloc >::pop_back ( )

inline

        {   // erase element at end
        erase(end() - 1);
        }

template<class _Alloc >

void vector< bool, _Alloc >::push_back ( const bool &  _Val )

inline

        {   // insert element at end
        insert(end(), _Val);
        }

template<class _Alloc >

reverse_iterator vector< bool, _Alloc >::rbegin ( )

inline

        {   // return iterator for beginning of reversed mutable sequence
        return (reverse_iterator(end()));
        }

template<class _Alloc >

const_reverse_iterator vector< bool, _Alloc >::rbegin ( ) const

inline

        {   // return iterator for beginning of reversed nonmutable sequence
        return (const_reverse_iterator(end()));
        }

template<class _Alloc >

reverse_iterator vector< bool, _Alloc >::rend ( )

inline

        {   // return iterator for end of reversed mutable sequence
        return (reverse_iterator(begin()));
        }

template<class _Alloc >

const_reverse_iterator vector< bool, _Alloc >::rend ( ) const

inline

        {   // return iterator for end of reversed nonmutable sequence
        return (const_reverse_iterator(begin()));
        }

template<class _Alloc >

void vector< bool, _Alloc >::reserve ( size_type  _Count )

inline

        {   // determine new minimum length of allocated storage
        this->_Myvec.reserve(this->_Nw(_Count));
        }

template<class _Alloc >

void vector< bool, _Alloc >::resize ( size_type  _Newsize, bool  _Val = false  )

inline

        {   // determine new length, padding with _Val elements as needed
        if (size() < _Newsize)
            _Insert_n(end(), _Newsize - size(), _Val);
        else if (_Newsize < size())
            erase(begin() + _Newsize, end());
        }

template<class _Alloc >

void vector< bool, _Alloc >::shrink_to_fit ( )

inline

        {   // reduce capacity
        if (this->_Myvec._Has_unused_capacity())
            {   // worth shrinking, do it
            _Myt _Tmp(*this);
            swap(_Tmp);
            }
        }

template<class _Alloc >

size_type vector< bool, _Alloc >::size ( ) const

inline

        {   // return length of sequence
        return (this->_Mysize);
        }

template<class _Alloc >

void vector< bool, _Alloc >::swap ( _Myt &  _Right )

inline

        {   // exchange contents with _Right
        if (this != &_Right)
            {   // (maybe) swap allocators, swap control information
            this->_Swap_all(_Right);
            this->_Myvec.swap(_Right._Myvec);
            _STD swap(this->_Mysize, _Right._Mysize);
            }
        }

template<class _Alloc >

static void vector< bool, _Alloc >::swap ( reference  _Left, reference  _Right  )

inlinestatic

        {   // swap _Left and _Right vector<bool> elements
        bool _Val = _Left;  // NOT _STD swap

        _Left = _Right;
        _Right = _Val;
        }

Member Data Documentation

template<class _Alloc >

const int vector< bool, _Alloc >::_VBITS = _STD _VBITS

static

---

The documentation for this class was generated from the following file:

• VS2015/inc/vector