array< _Ty, _Size > Class Template Reference

Public Types
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	fill (const _Ty &_Value)
void	swap (_Myt &_Other) _NOEXCEPT_OP(_Is_nothrow_swappable< _Ty >
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
constexpr size_type	size () const _NOEXCEPT
constexpr size_type	max_size () const _NOEXCEPT
constexpr bool	empty () const _NOEXCEPT
reference	at (size_type _Pos)
constexpr const_reference	at (size_type _Pos) const
reference	operator[] (_In_range_(0, _Size-1) size_type _Pos)
constexpr const_reference	operator[] (_In_range_(0, _Size-1) size_type _Pos) const
reference	front ()
constexpr const_reference	front () const
reference	back ()
constexpr const_reference	back () const
_Ty *	data () _NOEXCEPT
const _Ty *	data () const _NOEXCEPT
void	_Xran () const

Public Attributes
_Ty	_Elems [_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 Function Documentation

template<class _Ty, size_t _Size>

void array< _Ty, _Size >::_Xran ( ) const

inline

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

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>

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

inline

        {   // subscript nonmutable sequence with checking
        return (_Size <= _Pos
            ? (_Xran(), _Elems[_Pos])   // TRANSITION, _HAS_CONSTEXPR14
            : _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>

constexpr 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 (begin());
        }

template<class _Ty, size_t _Size>

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

inline

        {   // return iterator for end of nonmutable sequence
        return (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 (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 (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>

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

inline

        {   // test if sequence is empty
        return (false);
        }

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_unchecked(_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>

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

inline

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

template<class _Ty, size_t _Size>

constexpr 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[] ( _In_range_(0, _Size-1) 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 */

        return (_Elems[_Pos]);
        }

template<class _Ty, size_t _Size>

constexpr const_reference array< _Ty, _Size >::operator[] ( _In_range_(0, _Size-1) size_type  _Pos ) const

inline

        {   // subscript nonmutable sequence
 #if _ITERATOR_DEBUG_LEVEL == 0
        return (_Elems[_Pos]);

 #else /* _ITERATOR_DEBUG_LEVEL == 0 */
        return (_Size <= _Pos
            ? (_Bad_subscript(), _Elems[_Pos])  // TRANSITION, _HAS_CONSTEXPR14
            : _Elems[_Pos]);
 #endif /* _ITERATOR_DEBUG_LEVEL == 0 */
        }

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>

constexpr 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 )

inline

        {   // swap contents with _Other
        _Swap_ranges_unchecked(_STD addressof(_Elems[0]),
            _STD addressof(_Elems[0]) + _Size,
            _STD addressof(_Other._Elems[0]));
        }

Member Data Documentation

template<class _Ty, size_t _Size>

_Ty array< _Ty, _Size >::_Elems[_Size]

---

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

• VS2017/inc/array