array< _Ty, 0 > Class Template Reference

Public Types
enum	{ _EEN_SIZE = 0 }
typedef array< _Ty, 0 >	_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, 0 >	iterator
typedef _Array_const_iterator< _Ty, 0 >	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 &)
void	fill (const _Ty &)
void	swap (_Myt &) _NOEXCEPT
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
reverse_iterator	rbegin ()
const_reverse_iterator	rbegin () const
reverse_iterator	rend ()
const_reverse_iterator	rend () const
const_iterator	cbegin () const
const_iterator	cend () const
const_reverse_iterator	crbegin () const
const_reverse_iterator	crend () const
size_type	size () const
size_type	max_size () const
bool	empty () const
reference	at (size_type)
const_reference	at (size_type) const
reference	operator[] (size_type)
const_reference	operator[] (size_type) const
reference	front ()
const_reference	front () const
reference	back ()
const_reference	back () const
_Ty *	data ()
const _Ty *	data () const
	__declspec (noreturn) void _Xran() const

Public Attributes
_Ty	_Elems [1]

Member Typedef Documentation

template<class _Ty >

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

template<class _Ty >

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

template<class _Ty >

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

template<class _Ty >

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

template<class _Ty >

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

template<class _Ty >

typedef ptrdiff_t array< _Ty, 0 >::difference_type

template<class _Ty >

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

template<class _Ty >

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

template<class _Ty >

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

template<class _Ty >

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

template<class _Ty >

typedef size_t array< _Ty, 0 >::size_type

template<class _Ty >

typedef _Ty array< _Ty, 0 >::value_type

Member Enumeration Documentation

template<class _Ty >

anonymous enum

Enumerator
_EEN_SIZE

{_EEN_SIZE = 0};    // helper for expression evaluator

Member Function Documentation

template<class _Ty >

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

inline

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

template<class _Ty >

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

inline

        {   // assign value to all elements
        }

template<class _Ty >

reference array< _Ty, 0 >::at ( size_type  )

inline

        {   // subscript mutable sequence with checking
        static int _Zero = 0;

        if (_Zero == 0) // to quiet diagnostics
            _Xran();
        return (_Elems[0]);
        }

template<class _Ty >

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

inline

        {   // subscript nonmutable sequence with checking
        static int _Zero = 0;

        if (_Zero == 0) // to quiet diagnostics
            _Xran();
        return (_Elems[0]);
        }

template<class _Ty >

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

inline

        {   // return last element of mutable sequence
 #if _ITERATOR_DEBUG_LEVEL == 2
        _DEBUG_ERROR("array<T, 0>::back() invalid");

 #elif _ITERATOR_DEBUG_LEVEL == 1
        _SCL_SECURE_VALIDATE_RANGE(false);
 #endif /* _ITERATOR_DEBUG_LEVEL */

        return (_Elems[0]);
        }

template<class _Ty >

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

inline

        {   // return last element of nonmutable sequence
 #if _ITERATOR_DEBUG_LEVEL == 2
        _DEBUG_ERROR("array<T, 0>::back() invalid");

 #elif _ITERATOR_DEBUG_LEVEL == 1
        _SCL_SECURE_VALIDATE_RANGE(false);
 #endif /* _ITERATOR_DEBUG_LEVEL */

        return (_Elems[0]);
        }

template<class _Ty >

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

inline

        {   // return iterator for beginning of mutable sequence
        return (iterator(0, 0));
        }

template<class _Ty >

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

inline

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

template<class _Ty >

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

inline

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

template<class _Ty >

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

inline

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

template<class _Ty >

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

inline

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

template<class _Ty >

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

inline

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

template<class _Ty >

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

inline

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

template<class _Ty >

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

inline

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

template<class _Ty >

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

inline

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

template<class _Ty >

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

inline

        {   // return iterator for end of mutable sequence
        return (iterator(0, 0));
        }

template<class _Ty >

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

inline

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

template<class _Ty >

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

inline

        {   // assign value to all elements
        }

template<class _Ty >

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

inline

        {   // return first element of mutable sequence
 #if _ITERATOR_DEBUG_LEVEL == 2
        _DEBUG_ERROR("array<T, 0>::front() invalid");

 #elif _ITERATOR_DEBUG_LEVEL == 1
        _SCL_SECURE_VALIDATE_RANGE(false);
 #endif /* _ITERATOR_DEBUG_LEVEL */

        return (_Elems[0]);
        }

template<class _Ty >

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

inline

        {   // return first element of nonmutable sequence
 #if _ITERATOR_DEBUG_LEVEL == 2
        _DEBUG_ERROR("array<T, 0>::front() invalid");

 #elif _ITERATOR_DEBUG_LEVEL == 1
        _SCL_SECURE_VALIDATE_RANGE(false);
 #endif /* _ITERATOR_DEBUG_LEVEL */

        return (_Elems[0]);
        }

template<class _Ty >

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

inline

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

template<class _Ty >

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

inline

        {   // subscript mutable sequence
 #if _ITERATOR_DEBUG_LEVEL == 2
        _DEBUG_ERROR("array subscript out of range");

 #elif _ITERATOR_DEBUG_LEVEL == 1
        _SCL_SECURE_VALIDATE_RANGE(false);
 #endif /* _ITERATOR_DEBUG_LEVEL */

        return (_Elems[0]);
        }

template<class _Ty >

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

inline

        {   // subscript nonmutable sequence
 #if _ITERATOR_DEBUG_LEVEL == 2
        _DEBUG_ERROR("array subscript out of range");

 #elif _ITERATOR_DEBUG_LEVEL == 1
        _SCL_SECURE_VALIDATE_RANGE(false);
 #endif /* _ITERATOR_DEBUG_LEVEL */

        return (_Elems[0]);
        }

template<class _Ty >

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

inline

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

template<class _Ty >

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

inline

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

template<class _Ty >

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

inline

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

template<class _Ty >

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

inline

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

template<class _Ty >

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

inline

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

template<class _Ty >

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

inline

        {   // swap contents with _Other
        }

Member Data Documentation

template<class _Ty >

_Ty array< _Ty, 0 >::_Elems[1]

---

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

• VS2013/inc/array