array File Reference

#include <algorithm>
#include <iterator>
#include <tuple>

Classes
class	array< _Ty, _Size >
class	array< _Ty, 0 >

Macros
#define	_ARRAY_

Functions
template<class _Ty , size_t _Size, class = enable_if_t<_Size == 0 || _Is_swappable<_Ty>::value>>
void	swap (array< _Ty, _Size > &_Left, array< _Ty, _Size > &_Right) _NOEXCEPT_OP(_NOEXCEPT_OP(_Left.swap(_Right)))
template<class _Ty , size_t _Size>
bool	operator== (const array< _Ty, _Size > &_Left, const array< _Ty, _Size > &_Right)
template<class _Ty , size_t _Size>
bool	operator!= (const array< _Ty, _Size > &_Left, const array< _Ty, _Size > &_Right)
template<class _Ty , size_t _Size>
bool	operator< (const array< _Ty, _Size > &_Left, const array< _Ty, _Size > &_Right)
template<class _Ty , size_t _Size>
bool	operator> (const array< _Ty, _Size > &_Left, const array< _Ty, _Size > &_Right)
template<class _Ty , size_t _Size>
bool	operator<= (const array< _Ty, _Size > &_Left, const array< _Ty, _Size > &_Right)
template<class _Ty , size_t _Size>
bool	operator>= (const array< _Ty, _Size > &_Left, const array< _Ty, _Size > &_Right)
template<size_t _Idx, class _Ty , size_t _Size>
constexpr _Ty &	get (array< _Ty, _Size > &_Arr) _NOEXCEPT
template<size_t _Idx, class _Ty , size_t _Size>
constexpr const _Ty &	get (const array< _Ty, _Size > &_Arr) _NOEXCEPT
template<size_t _Idx, class _Ty , size_t _Size>
constexpr _Ty &&	get (array< _Ty, _Size > &&_Arr) _NOEXCEPT

Macro Definition Documentation

#define _ARRAY_

Function Documentation

template<size_t _Idx, class _Ty , size_t _Size>

constexpr _Ty& get

(

array< _Ty, _Size > &

_Arr

)

    {   // return element at _Idx in array _Arr
    static_assert(_Idx < _Size, "array index out of bounds");
    return (_Arr._Elems[_Idx]);
    }

template<size_t _Idx, class _Ty , size_t _Size>

constexpr const _Ty& get

(

const array< _Ty, _Size > &

_Arr

)

    {   // return element at _Idx in array _Arr
    static_assert(_Idx < _Size, "array index out of bounds");
    return (_Arr._Elems[_Idx]);
    }

template<size_t _Idx, class _Ty , size_t _Size>

constexpr _Ty&& get

(

array< _Ty, _Size > &&

_Arr

)

    {   // return element at _Idx in array _Arr
    static_assert(_Idx < _Size, "array index out of bounds");
    return (_STD move(_Arr._Elems[_Idx]));
    }

template<class _Ty , size_t _Size>

bool operator!=	(	const array< _Ty, _Size > &	_Left,
		const array< _Ty, _Size > &	_Right
	)

    {   // test for array inequality
    return (!(_Left == _Right));
    }

template<class _Ty , size_t _Size>

bool operator<	(	const array< _Ty, _Size > &	_Left,
		const array< _Ty, _Size > &	_Right
	)

    {   // test if _Left < _Right for arrays
    return (_STD lexicographical_compare(_Left.begin(), _Left.end(),
        _Right.begin(), _Right.end()));
    }

template<class _Ty , size_t _Size>

bool operator<=	(	const array< _Ty, _Size > &	_Left,
		const array< _Ty, _Size > &	_Right
	)

    {   // test if _Left <= _Right for arrays
    return (!(_Right < _Left));
    }

template<class _Ty , size_t _Size>

bool operator==	(	const array< _Ty, _Size > &	_Left,
		const array< _Ty, _Size > &	_Right
	)

    {   // test for array equality
    return (_STD equal(_Left.begin(), _Left.end(), _Right.begin()));
    }

template<class _Ty , size_t _Size>

bool operator>	(	const array< _Ty, _Size > &	_Left,
		const array< _Ty, _Size > &	_Right
	)

    {   // test if _Left > _Right for arrays
    return (_Right < _Left);
    }

template<class _Ty , size_t _Size>

bool operator>=	(	const array< _Ty, _Size > &	_Left,
		const array< _Ty, _Size > &	_Right
	)

    {   // test if _Left >= _Right for arrays
    return (!(_Left < _Right));
    }

template<class _Ty , size_t _Size, class = enable_if_t<_Size == 0 || _Is_swappable<_Ty>::value>>

void swap	(	array< _Ty, _Size > &	_Left,
		array< _Ty, _Size > &	_Right
	)

    {   // swap arrays
    return (_Left.swap(_Right));
    }