Inheritance diagram for _Vector_const_iterator< _Myvec >:

Public Types
typedef _Vector_const_iterator< _Myvec >	_Myiter

typedef random_access_iterator_tag	iterator_category

typedef _Myvec::value_type	value_type

typedef _Myvec::difference_type	difference_type

typedef _Myvec::const_pointer	pointer

typedef _Myvec::const_reference	reference

typedef _Myvec::pointer	_Tptr

typedef pointer	_Unchecked_type

Public Types inherited from _Iterator012< random_access_iterator_tag, _Myvec::value_type, _Myvec::difference_type, _Myvec::const_pointer, _Myvec::const_reference, _Iterator_base >
typedef random_access_iterator_tag	iterator_category

typedef _Myvec::value_type	value_type

typedef _Myvec::difference_type	difference_type

typedef _Myvec::const_pointer	pointer

typedef _Myvec::const_reference	reference

Public Member Functions
	_Vector_const_iterator ()

	_Vector_const_iterator (_Tptr _Parg, const _Container_base *_Pvector)

_Myiter &	_Rechecked (_Unchecked_type _Right)

_Unchecked_type	_Unchecked () const

reference	operator* () const

pointer	operator-> () const

_Myiter &	operator++ ()

_Myiter	operator++ (int)

_Myiter &	operator-- ()

_Myiter	operator-- (int)

_Myiter &	operator+= (difference_type _Off)

_Myiter	operator+ (difference_type _Off) const

_Myiter &	operator-= (difference_type _Off)

_Myiter	operator- (difference_type _Off) const

difference_type	operator- (const _Myiter &_Right) const

reference	operator[] (difference_type _Off) const

bool	operator== (const _Myiter &_Right) const

bool	operator!= (const _Myiter &_Right) const

bool	operator< (const _Myiter &_Right) const

bool	operator> (const _Myiter &_Right) const

bool	operator<= (const _Myiter &_Right) const

bool	operator>= (const _Myiter &_Right) const

void	_Compat (const _Myiter &) const

Public Member Functions inherited from _Iterator_base0
void	_Adopt (const void *)

const _Container_base0 *	_Getcont () const

Public Attributes
_Tptr	_Ptr

Member Typedef Documentation

template<class _Myvec>

typedef _Vector_const_iterator<_Myvec> _Vector_const_iterator< _Myvec >::_Myiter

template<class _Myvec>

typedef _Myvec::pointer _Vector_const_iterator< _Myvec >::_Tptr

template<class _Myvec>

typedef pointer _Vector_const_iterator< _Myvec >::_Unchecked_type

template<class _Myvec>

typedef _Myvec::difference_type _Vector_const_iterator< _Myvec >::difference_type

template<class _Myvec>

typedef random_access_iterator_tag _Vector_const_iterator< _Myvec >::iterator_category

template<class _Myvec>

typedef _Myvec::const_pointer _Vector_const_iterator< _Myvec >::pointer

template<class _Myvec>

typedef _Myvec::const_reference _Vector_const_iterator< _Myvec >::reference

template<class _Myvec>

typedef _Myvec::value_type _Vector_const_iterator< _Myvec >::value_type

Constructor & Destructor Documentation

template<class _Myvec>

_Vector_const_iterator< _Myvec >::_Vector_const_iterator ( )

inline

         : _Ptr()
         {   // construct with null pointer
         }

template<class _Myvec>

_Vector_const_iterator< _Myvec >::_Vector_const_iterator	(	_Tptr	_Parg,
		const _Container_base *	_Pvector
	)

inline

         : _Ptr(_Parg)
         {   // construct with pointer _Parg
         this->_Adopt(_Pvector);
         }

Member Function Documentation

template<class _Myvec>

void _Vector_const_iterator< _Myvec >::_Compat ( const _Myiter & ) const

inline

261 { // test for compatible iterator pair

262 }

template<class _Myvec>

_Myiter& _Vector_const_iterator< _Myvec >::_Rechecked ( _Unchecked_type _Right )

inline

         {   // reset from unchecked iterator
         _Ptr = _Const_cast(_Right);
         return (*this);
         }

template<class _Myvec>

_Unchecked_type _Vector_const_iterator< _Myvec >::_Unchecked ( ) const

inline

         {   // make an unchecked iterator
         return (_Ptr);
         }

template<class _Myvec>

bool _Vector_const_iterator< _Myvec >::operator!= ( const _Myiter & _Right ) const

inline

         {   // test for iterator inequality
         return (!(*this == _Right));
         }

template<class _Myvec>

reference _Vector_const_iterator< _Myvec >::operator* ( ) const

inline

         {   // return designated object
  #if _ITERATOR_DEBUG_LEVEL == 2
         const auto _Mycont = static_cast<const _Myvec *>(this->_Getcont());
         if (_Mycont == 0
             || _Ptr == _Tptr()
             || _Ptr < _Mycont->_Myfirst
             || _Mycont->_Mylast <= _Ptr)
             {   // report error
             _DEBUG_ERROR("vector iterator not dereferencable");
             _SCL_SECURE_OUT_OF_RANGE;
             }
 
  #elif _ITERATOR_DEBUG_LEVEL == 1
         _SCL_SECURE_VALIDATE(_Ptr != _Tptr());
         const auto _Mycont = static_cast<const _Myvec *>(this->_Getcont());
         _SCL_SECURE_VALIDATE(_Mycont != 0);
         _SCL_SECURE_VALIDATE_RANGE(_Mycont->_Myfirst <= _Ptr && _Ptr < _Mycont->_Mylast);
  #endif /* _ITERATOR_DEBUG_LEVEL */
 
         _Analysis_assume_(_Ptr != _Tptr());
 
         return (*_Ptr);
         }

template<class _Myvec>

_Myiter _Vector_const_iterator< _Myvec >::operator+ ( difference_type _Off ) const

inline

         {   // return this + integer
         _Myiter _Tmp = *this;
         return (_Tmp += _Off);
         }

template<class _Myvec>

_Myiter& _Vector_const_iterator< _Myvec >::operator++ ( )

inline

         {   // preincrement
  #if _ITERATOR_DEBUG_LEVEL == 2
         const auto _Mycont = static_cast<const _Myvec *>(this->_Getcont());
         if (_Mycont == 0
             || _Ptr == nullptr_t{}
             || _Mycont->_Mylast <= _Ptr)
             {   // report error
             _DEBUG_ERROR("vector iterator not incrementable");
             _SCL_SECURE_OUT_OF_RANGE;
             }
 
  #elif _ITERATOR_DEBUG_LEVEL == 1
         _SCL_SECURE_VALIDATE(_Ptr != _Tptr());
         const auto _Mycont = static_cast<const _Myvec *>(this->_Getcont());
         _SCL_SECURE_VALIDATE(_Mycont != 0);
         _SCL_SECURE_VALIDATE_RANGE(_Ptr < _Mycont->_Mylast);
  #endif /* _ITERATOR_DEBUG_LEVEL */
 
         ++_Ptr;
         return (*this);
         }

template<class _Myvec>

_Myiter _Vector_const_iterator< _Myvec >::operator++ ( int )

inline

         {   // postincrement
         _Myiter _Tmp = *this;
         ++*this;
         return (_Tmp);
         }

template<class _Myvec>

_Myiter& _Vector_const_iterator< _Myvec >::operator+= ( difference_type _Off )

inline

         {   // increment by integer
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (_Off != 0)
             {
             const auto _Mycont = static_cast<const _Myvec *>(this->_Getcont());
             if (_Mycont == 0
                 || _Ptr + _Off < _Mycont->_Myfirst
                 || _Mycont->_Mylast < _Ptr + _Off)
                 {
                 _DEBUG_ERROR("vector iterator + offset out of range");
                 _SCL_SECURE_OUT_OF_RANGE;
                 }
             }
 
  #elif _ITERATOR_DEBUG_LEVEL == 1
         if (_Off != 0)
             {
             const auto _Mycont = static_cast<const _Myvec *>(this->_Getcont());
             _SCL_SECURE_VALIDATE(_Mycont != 0);
             _SCL_SECURE_VALIDATE_RANGE(_Mycont->_Myfirst <= _Ptr + _Off
                 && _Ptr + _Off <= _Mycont->_Mylast);
             }
  #endif /* _ITERATOR_DEBUG_LEVEL */
 
         _Ptr += _Off;
         return (*this);
         }

template<class _Myvec>

_Myiter _Vector_const_iterator< _Myvec >::operator- ( difference_type _Off ) const

inline

         {   // return this - integer
         _Myiter _Tmp = *this;
         return (_Tmp -= _Off);
         }

template<class _Myvec>

difference_type _Vector_const_iterator< _Myvec >::operator- ( const _Myiter & _Right ) const

inline

         {   // return difference of iterators
         _Compat(_Right);
         return (_Ptr - _Right._Ptr);
         }

template<class _Myvec>

_Myiter& _Vector_const_iterator< _Myvec >::operator-- ( )

inline

         {   // predecrement
  #if _ITERATOR_DEBUG_LEVEL == 2
         const auto _Mycont = static_cast<const _Myvec *>(this->_Getcont());
         if (_Mycont == 0
             || _Ptr == nullptr_t{}
             || _Ptr <= _Mycont->_Myfirst)
             {   // report error
             _DEBUG_ERROR("vector iterator not decrementable");
             _SCL_SECURE_OUT_OF_RANGE;
             }
 
  #elif _ITERATOR_DEBUG_LEVEL == 1
         _SCL_SECURE_VALIDATE(_Ptr != _Tptr());
         const auto _Mycont = static_cast<const _Myvec *>(this->_Getcont());
         _SCL_SECURE_VALIDATE(_Mycont != 0);
         _SCL_SECURE_VALIDATE_RANGE(_Mycont->_Myfirst < _Ptr);
  #endif /* _ITERATOR_DEBUG_LEVEL */
 
         --_Ptr;
         return (*this);
         }

template<class _Myvec>

_Myiter _Vector_const_iterator< _Myvec >::operator-- ( int )

inline

         {   // postdecrement
         _Myiter _Tmp = *this;
         --*this;
         return (_Tmp);
         }

template<class _Myvec>

_Myiter& _Vector_const_iterator< _Myvec >::operator-= ( difference_type _Off )

inline

         {   // decrement by integer
         return (*this += -_Off);
         }

template<class _Myvec>

pointer _Vector_const_iterator< _Myvec >::operator-> ( ) const

inline

         {   // return pointer to class object
         return (pointer_traits<pointer>::pointer_to(**this));
         }

template<class _Myvec>

bool _Vector_const_iterator< _Myvec >::operator< ( const _Myiter & _Right ) const

inline

         {   // test if this < _Right
         _Compat(_Right);
         return (_Ptr < _Right._Ptr);
         }

template<class _Myvec>

bool _Vector_const_iterator< _Myvec >::operator<= ( const _Myiter & _Right ) const

inline

         {   // test if this <= _Right
         return (!(_Right < *this));
         }

template<class _Myvec>

bool _Vector_const_iterator< _Myvec >::operator== ( const _Myiter & _Right ) const

inline

         {   // test for iterator equality
         _Compat(_Right);
         return (_Ptr == _Right._Ptr);
         }

template<class _Myvec>

bool _Vector_const_iterator< _Myvec >::operator> ( const _Myiter & _Right ) const

inline

         {   // test if this > _Right
         return (_Right < *this);
         }

template<class _Myvec>

bool _Vector_const_iterator< _Myvec >::operator>= ( const _Myiter & _Right ) const

inline

         {   // test if this >= _Right
         return (!(*this < _Right));
         }

template<class _Myvec>

reference _Vector_const_iterator< _Myvec >::operator[] ( difference_type _Off ) const

inline

         {   // subscript
         return (*(*this + _Off));
         }

Member Data Documentation

template<class _Myvec>

_Tptr _Vector_const_iterator< _Myvec >::_Ptr

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

VS2015/inc/vector

Public Types

Public Member Functions

Public Attributes

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation