Public Types
enum	{ _EEN_SIZE = _Size }

typedef array< _Ty, _Size >	_Myt

typedef _Ty	value_type

typedef size_t	size_type

typedef ptrdiff_t	difference_type

typedef _Ty *	pointer

typedef const _Ty *	const_pointer

typedef _Ty &	reference

typedef const _Ty &	const_reference

typedef _Array_iterator< _Ty, _Size >	iterator

typedef _Array_const_iterator< _Ty, _Size >	const_iterator

typedef _STD reverse_iterator< iterator >	reverse_iterator

typedef _STD reverse_iterator< const_iterator >	const_reverse_iterator

Public Member Functions
void	assign (const _Ty &_Value)

void	fill (const _Ty &_Value)

void	swap (_Myt &_Other) _NOEXCEPT_OP(_NOEXCEPT_OP(_Swap_adl(_Elems[0]

void _Elems[0]	_Swap_ranges (_STD addressof(_Elems[0]), _STD addressof(_Elems[0])+_Size, _STD addressof(_Other._Elems[0]))

iterator	begin () _NOEXCEPT

const_iterator	begin () const _NOEXCEPT

iterator	end () _NOEXCEPT

const_iterator	end () const _NOEXCEPT

reverse_iterator	rbegin () _NOEXCEPT

const_reverse_iterator	rbegin () const _NOEXCEPT

reverse_iterator	rend () _NOEXCEPT

const_reverse_iterator	rend () const _NOEXCEPT

const_iterator	cbegin () const _NOEXCEPT

const_iterator	cend () const _NOEXCEPT

const_reverse_iterator	crbegin () const _NOEXCEPT

const_reverse_iterator	crend () const _NOEXCEPT

size_type	size () const _NOEXCEPT

size_type	max_size () const _NOEXCEPT

bool	empty () const _NOEXCEPT

reference	at (size_type _Pos)

const_reference	at (size_type _Pos) const

reference	operator[] (size_type _Pos)

const_reference	operator[] (size_type _Pos) const

reference	front ()

const_reference	front () const

reference	back ()

const_reference	back () const

_Ty *	data () _NOEXCEPT

const _Ty *	data () const _NOEXCEPT

	__declspec (noreturn) void _Xran() const

Public Attributes
_Ty	_Elems [_Size==0?1:_Size]

Member Typedef Documentation

template<class _Ty, size_t _Size>

typedef array<_Ty, _Size> array< _Ty, _Size >::_Myt

template<class _Ty, size_t _Size>

typedef _Array_const_iterator<_Ty, _Size> array< _Ty, _Size >::const_iterator

template<class _Ty, size_t _Size>

typedef const _Ty* array< _Ty, _Size >::const_pointer

template<class _Ty, size_t _Size>

typedef const _Ty& array< _Ty, _Size >::const_reference

template<class _Ty, size_t _Size>

typedef _STD reverse_iterator<const_iterator> array< _Ty, _Size >::const_reverse_iterator

template<class _Ty, size_t _Size>

typedef ptrdiff_t array< _Ty, _Size >::difference_type

template<class _Ty, size_t _Size>

typedef _Array_iterator<_Ty, _Size> array< _Ty, _Size >::iterator

template<class _Ty, size_t _Size>

typedef _Ty* array< _Ty, _Size >::pointer

template<class _Ty, size_t _Size>

typedef _Ty& array< _Ty, _Size >::reference

template<class _Ty, size_t _Size>

typedef _STD reverse_iterator<iterator> array< _Ty, _Size >::reverse_iterator

template<class _Ty, size_t _Size>

typedef size_t array< _Ty, _Size >::size_type

template<class _Ty, size_t _Size>

typedef _Ty array< _Ty, _Size >::value_type

Member Enumeration Documentation

template<class _Ty, size_t _Size>

anonymous enum

Enumerator
_EEN_SIZE

22 {_EEN_SIZE = _Size}; // helper for expression evaluator

array::_EEN_SIZE

Definition: array:22

_Size

_Check_return_ _In_ long _Size

Definition: io.h:325

Member Function Documentation

template<class _Ty, size_t _Size>

array< _Ty, _Size >::__declspec ( noreturn ) const

inline

         {   // report an out_of_range error
         _Xout_of_range("invalid array<T, N> subscript");
         }

template<class _Ty, size_t _Size>

void _Elems [0] array< _Ty, _Size >::_Swap_ranges	(	_STD	addressof_Elems[0],
		_STD addressof(_Elems[0])+	_Size,
		_STD	addressof_Other._Elems[0]
	)

template<class _Ty, size_t _Size>

void array< _Ty, _Size >::assign ( const _Ty & _Value )

inline

         {   // assign value to all elements
         _Fill_n(_Elems, _Size, _Value);
         }

template<class _Ty, size_t _Size>

reference array< _Ty, _Size >::at ( size_type _Pos )

inline

         {   // subscript mutable sequence with checking
         if (_Size <= _Pos)
             _Xran();
         return (_Elems[_Pos]);
         }

template<class _Ty, size_t _Size>

const_reference array< _Ty, _Size >::at ( size_type _Pos ) const

inline

         {   // subscript nonmutable sequence with checking
         if (_Size <= _Pos)
             _Xran();
         return (_Elems[_Pos]);
         }

template<class _Ty, size_t _Size>

reference array< _Ty, _Size >::back ( )

inline

         {   // return last element of mutable sequence
         return (_Elems[_Size - 1]);
         }

template<class _Ty, size_t _Size>

const_reference array< _Ty, _Size >::back ( ) const

inline

         {   // return last element of nonmutable sequence
         return (_Elems[_Size - 1]);
         }

template<class _Ty, size_t _Size>

iterator array< _Ty, _Size >::begin ( )

inline

         {   // return iterator for beginning of mutable sequence
         return (iterator(_STD addressof(_Elems[0]), 0));
         }

template<class _Ty, size_t _Size>

const_iterator array< _Ty, _Size >::begin ( ) const

inline

         {   // return iterator for beginning of nonmutable sequence
         return (const_iterator(_STD addressof(_Elems[0]), 0));
         }

template<class _Ty, size_t _Size>

const_iterator array< _Ty, _Size >::cbegin ( ) const

inline

         {   // return iterator for beginning of nonmutable sequence
         return (((const _Myt *)this)->begin());
         }

template<class _Ty, size_t _Size>

const_iterator array< _Ty, _Size >::cend ( ) const

inline

         {   // return iterator for end of nonmutable sequence
         return (((const _Myt *)this)->end());
         }

template<class _Ty, size_t _Size>

const_reverse_iterator array< _Ty, _Size >::crbegin ( ) const

inline

         {   // return iterator for beginning of reversed nonmutable sequence
         return (((const _Myt *)this)->rbegin());
         }

template<class _Ty, size_t _Size>

const_reverse_iterator array< _Ty, _Size >::crend ( ) const

inline

         {   // return iterator for end of reversed nonmutable sequence
         return (((const _Myt *)this)->rend());
         }

template<class _Ty, size_t _Size>

_Ty* array< _Ty, _Size >::data ( )

inline

         {   // return pointer to mutable data array
         return (_Elems);
         }

template<class _Ty, size_t _Size>

const _Ty* array< _Ty, _Size >::data ( ) const

inline

         {   // return pointer to nonmutable data array
         return (_Elems);
         }

template<class _Ty, size_t _Size>

bool array< _Ty, _Size >::empty ( ) const

inline

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

template<class _Ty, size_t _Size>

iterator array< _Ty, _Size >::end ( )

inline

         {   // return iterator for end of mutable sequence
         return (iterator(_STD addressof(_Elems[0]), _Size));
         }

template<class _Ty, size_t _Size>

const_iterator array< _Ty, _Size >::end ( ) const

inline

         {   // return iterator for beginning of nonmutable sequence
         return (const_iterator(_STD addressof(_Elems[0]), _Size));
         }

template<class _Ty, size_t _Size>

void array< _Ty, _Size >::fill ( const _Ty & _Value )

inline

         {   // assign value to all elements
         _Fill_n(_Elems, _Size, _Value);
         }

template<class _Ty, size_t _Size>

reference array< _Ty, _Size >::front ( )

inline

         {   // return first element of mutable sequence
         return (_Elems[0]);
         }

template<class _Ty, size_t _Size>

const_reference array< _Ty, _Size >::front ( ) const

inline

         {   // return first element of nonmutable sequence
         return (_Elems[0]);
         }

template<class _Ty, size_t _Size>

size_type array< _Ty, _Size >::max_size ( ) const

inline

         {   // return maximum possible length of sequence
         return (_Size);
         }

template<class _Ty, size_t _Size>

reference array< _Ty, _Size >::operator[] ( size_type _Pos )

inline

         {   // subscript mutable sequence
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (_Size <= _Pos)
             _DEBUG_ERROR("array subscript out of range");
 
  #elif _ITERATOR_DEBUG_LEVEL == 1
         _SCL_SECURE_VALIDATE_RANGE(_Pos < _Size);
  #endif /* _ITERATOR_DEBUG_LEVEL */
 
         _Analysis_assume_(_Pos < _Size);
 
         return (_Elems[_Pos]);
         }

template<class _Ty, size_t _Size>

const_reference array< _Ty, _Size >::operator[] ( size_type _Pos ) const

inline

         {   // subscript nonmutable sequence
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (_Size <= _Pos)
             _DEBUG_ERROR("array subscript out of range");
 
  #elif _ITERATOR_DEBUG_LEVEL == 1
         _SCL_SECURE_VALIDATE_RANGE(_Pos < _Size);
  #endif /* _ITERATOR_DEBUG_LEVEL */
 
         _Analysis_assume_(_Pos < _Size);
 
         return (_Elems[_Pos]);
         }

template<class _Ty, size_t _Size>

reverse_iterator array< _Ty, _Size >::rbegin ( )

inline

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

template<class _Ty, size_t _Size>

const_reverse_iterator array< _Ty, _Size >::rbegin ( ) const

inline

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

template<class _Ty, size_t _Size>

reverse_iterator array< _Ty, _Size >::rend ( )

inline

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

template<class _Ty, size_t _Size>

const_reverse_iterator array< _Ty, _Size >::rend ( ) const

inline

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

template<class _Ty, size_t _Size>

size_type array< _Ty, _Size >::size ( ) const

inline

         {   // return length of sequence
         return (_Size);
         }

template<class _Ty, size_t _Size>

void array< _Ty, _Size >::swap ( _Myt & _Other )

Member Data Documentation

template<class _Ty, size_t _Size>

_Ty array< _Ty, _Size >::_Elems[_Size==0?1:_Size]

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

VS2013/inc/array

Public Types

Public Member Functions

Public Attributes

Member Typedef Documentation

Member Enumeration Documentation

Member Function Documentation

Member Data Documentation