std Namespace Reference

Classes
struct	array
class	initializer_list
struct	_numeric_limits_helper
struct	_numeric_limits_helper< T, true >
class	numeric_limits
struct	nothrow_t
struct	conditional
struct	conditional< false, T, F >
struct	remove_cv
struct	remove_cv< const T >
struct	remove_cv< volatile T >
struct	remove_cv< const volatile T >
struct	add_cv
struct	add_const
struct	add_volatile
struct	remove_reference
struct	remove_reference< T & >
struct	remove_reference< T && >
struct	type_identity
struct	add_lvalue_reference
struct	add_rvalue_reference
struct	add_pointer
struct	remove_extent
struct	remove_extent< T[]>
struct	remove_extent< T[N]>
struct	remove_all_extents
struct	remove_all_extents< T[]>
struct	remove_all_extents< T[N]>
struct	remove_pointer
struct	remove_pointer< T * >
struct	remove_pointer< T *const >
struct	remove_pointer< T *volatile >
struct	remove_pointer< T *const volatile >
struct	__nat
struct	is_same
struct	is_void
struct	is_null_pointer
struct	is_array
struct	is_enum
struct	is_floating_point
struct	is_union
struct	is_class
struct	is_function
struct	is_pointer
struct	is_lvalue_reference
struct	is_rvalue_reference
struct	is_member_object_pointer
struct	is_member_function_pointer
struct	is_fundamental
struct	is_arithmetic
struct	is_scalar
struct	is_object
struct	is_compound
struct	is_reference
struct	is_member_pointer
struct	is_const
struct	is_volatile
struct	is_trivial
struct	is_trivially_copyable
struct	is_standard_layout
struct	has_unique_object_representations
struct	is_empty
struct	is_polymorphic
struct	is_abstract
struct	is_final
struct	is_aggregate
struct	is_signed
struct	is_unsigned
struct	is_constructible
struct	is_trivially_constructible
struct	is_nothrow_constructible
struct	is_default_constructible
struct	is_trivially_default_constructible
struct	is_nothrow_default_constructible
struct	is_copy_constructible
struct	is_trivially_copy_constructible
struct	is_nothrow_copy_constructible
struct	is_move_constructible
struct	is_trivially_move_constructible
struct	is_nothrow_move_constructible
struct	is_assignable
struct	is_trivially_assignable
struct	is_nothrow_assignable
struct	is_copy_assignable
struct	is_trivially_copy_assignable
struct	is_nothrow_copy_assignable
struct	is_move_assignable
struct	is_trivially_move_assignable
struct	is_nothrow_move_assignable
struct	__is_destructible_apply
struct	__two
struct	__is_destructor_wellformed
struct	__destructible_imp
struct	__destructible_imp< _Tp, false >
struct	__destructible_imp< _Tp, true >
struct	__destructible_nonfunction
struct	__destructible_nonfunction< _Tp, false >
struct	__destructible_nonfunction< _Tp, true >
struct	is_destructible
struct	is_destructible< _Tp[]>
struct	is_destructible< void >
struct	is_trivially_destructible
struct	__libcpp_is_nothrow_destructible
struct	__libcpp_is_nothrow_destructible< false, _Tp >
struct	__libcpp_is_nothrow_destructible< true, _Tp >
struct	is_nothrow_destructible
struct	is_nothrow_destructible< _Tp[_Ns]>
struct	is_nothrow_destructible< _Tp & >
struct	is_nothrow_destructible< _Tp && >
struct	has_virtual_destructor
struct	__is_swappable
struct	__is_nothrow_swappable
struct	__is_referenceable_impl
struct	__is_referenceable
struct	is_swappable_with
struct	is_swappable
struct	is_nothrow_swappable_with
struct	is_nothrow_swappable
struct	alignment_of
struct	rank
struct	rank< T[]>
struct	rank< T[N]>
struct	extent
struct	is_base_of
struct	is_convertible
struct	decay
struct	__member_pointer_class_type
struct	__member_pointer_class_type< _Ret _ClassType::* >
class	reference_wrapper
struct	__is_reference_wrapper_impl
struct	__is_reference_wrapper_impl< reference_wrapper< _Tp > >
struct	__is_reference_wrapper
struct	__any
struct	__invokable_r
struct	__nothrow_invokable_r_imp
struct	__nothrow_invokable_r_imp< true, false, _Ret, _Fp, _Args... >
struct	__nothrow_invokable_r_imp< true, true, _Ret, _Fp, _Args... >
struct	is_invocable
struct	is_invocable_r
struct	is_nothrow_invocable
struct	is_nothrow_invocable_r
struct	__type_list
class	type_info
struct	pair

Typedefs
using	size_t = ::size_t
using	ptrdiff_t = ::ptrdiff_t
using	max_align_t = ::max_align_t
using	nullptr_t = decltype(nullptr)
using	int8_t = ::int8_t
using	int16_t = ::int16_t
using	int32_t = ::int32_t
using	int64_t = ::int64_t
using	int_fast8_t = ::int_fast8_t
using	int_fast16_t = ::int_fast16_t
using	int_fast32_t = ::int_fast32_t
using	int_fast64_t = ::int_fast64_t
using	int_least8_t = ::int_least8_t
using	int_least16_t = ::int_least16_t
using	int_least32_t = ::int_least32_t
using	int_least64_t = ::int_least64_t
using	intmax_t = ::intmax_t
using	intptr_t = ::intptr_t
using	uint8_t = ::uint8_t
using	uint16_t = ::uint16_t
using	uint32_t = ::uint32_t
using	uint64_t = ::uint64_t
using	uint_fast8_t = ::uint_fast8_t
using	uint_fast16_t = ::uint_fast16_t
using	uint_fast32_t = ::uint_fast32_t
using	uint_fast64_t = ::uint_fast64_t
using	uint_least8_t = ::uint_least8_t
using	uint_least16_t = ::uint_least16_t
using	uint_least32_t = ::uint_least32_t
using	uint_least64_t = ::uint_least64_t
using	uintmax_t = ::uintmax_t
using	uintptr_t = ::uintptr_t
using	terminate_handler = void(*)()
typedef void(*	new_handler) ()
template<bool B>
using	bool_constant = integral_constant< bool, B >
typedef integral_constant< bool, true >	true_type
typedef integral_constant< bool, false >	false_type
template<bool B, class T , class F >
using	conditional_t = typename conditional< B, T, F >::type
template<class T >
using	remove_cv_t = typename remove_cv< T >::type
template<class T >
using	add_cv_t = typename add_cv< T >::type
template<class T >
using	add_const_t = typename add_const< T >::type
template<class T >
using	add_volatile_t = typename add_volatile< T >::type
template<class T >
using	remove_reference_t = typename remove_reference< T >::type
template<class T >
using	add_lvalue_reference_t = typename add_lvalue_reference< T >::type
template<class T >
using	add_rvalue_reference_t = typename add_rvalue_reference< T >::type
template<class T >
using	add_pointer_t = typename add_pointer< T >::type
template<class T >
using	remove_extent_t = typename remove_extent< T >::type
template<class T >
using	remove_all_extents_t = typename remove_all_extents< T >::type
template<class T >
using	remove_pointer_t = typename remove_pointer< T >::type
template<class T >
using	decay_t = typename decay< T >::type

Enumerations
enum class	byte : unsigned char
enum	float_round_style {   round_indeterminate = -1 , round_toward_zero = 0 , round_to_nearest = 1 , round_toward_infinity = 2 ,   round_toward_neg_infinity = 3 }
enum	float_denorm_style { denorm_indeterminate = -1 , denorm_absent = 0 , denorm_present = 1 }

Functions
template<class ForwardIt >
ForwardIt	min_element (ForwardIt first, ForwardIt last)
template<class ForwardIt , class Compare >
ForwardIt	min_element (ForwardIt first, ForwardIt last, Compare comp)
template<class ForwardIt >
ForwardIt	max_element (ForwardIt first, ForwardIt last)
template<class ForwardIt , class Compare >
ForwardIt	max_element (ForwardIt first, ForwardIt last, Compare comp)
constexpr byte	operator| (byte l, byte r) noexcept
constexpr byte	operator& (byte l, byte r) noexcept
constexpr byte	operator^ (byte l, byte r) noexcept
constexpr byte	operator~ (byte b) noexcept
constexpr byte &	operator|= (byte &l, byte r) noexcept
constexpr byte &	operator&= (byte &l, byte r) noexcept
constexpr byte &	operator^= (byte &l, byte r) noexcept
template<class IntegerType >
constexpr enable_if_t< is_integral< IntegerType >::value, IntegerType >	to_integer (byte b) noexcept
template<class IntegerType >
constexpr enable_if_t< is_integral< IntegerType >::value, byte >	operator<< (byte b, IntegerType shift) noexcept
template<class IntegerType >
constexpr enable_if_t< is_integral< IntegerType >::value, byte >	operator>> (byte b, IntegerType shift) noexcept
template<class IntegerType >
constexpr enable_if_t< is_integral< IntegerType >::value, byte & >	operator<<= (byte &b, IntegerType shift) noexcept
template<class IntegerType >
constexpr enable_if_t< is_integral< IntegerType >::value, byte & >	operator>>= (byte &b, IntegerType shift) noexcept
terminate_handler	get_terminate () noexcept
terminate_handler	set_terminate (terminate_handler f) noexcept
void	terminate () noexcept
template<class E >
constexpr const E *	begin (initializer_list< E > il) noexcept
template<class E >
constexpr const E *	end (initializer_list< E > il) noexcept
template<class C >
constexpr auto	begin (C &c) -> decltype(c.begin())
template<class C >
constexpr auto	begin (const C &c) -> decltype(c.begin())
template<class T , std::size_t _N>
constexpr T *	begin (T(&array)[_N]) noexcept
template<class C >
constexpr auto	cbegin (const C &c) noexcept(noexcept(std::begin(c))) -> decltype(c.begin())
template<class C >
constexpr auto	end (C &c) -> decltype(c.end())
template<class C >
constexpr auto	end (const C &c) -> decltype(c.end())
template<class T , std::size_t _N>
constexpr T *	end (T(&array)[_N]) noexcept
template<class C >
constexpr auto	cend (const C &c) noexcept(noexcept(std::end(c))) -> decltype(c.end())
new_handler	get_new_handler () noexcept
new_handler	set_new_handler (new_handler new_p) noexcept
template<class _Tp >
constexpr __swap_result_t< _Tp >	swap (_Tp &__x, _Tp &__y) noexcept(is_nothrow_move_constructible_v< _Tp > &&is_nothrow_move_assignable_v< _Tp >)
template<class _Tp , size_t _Np>
constexpr enable_if_t< __is_swappable< _Tp >::value >	swap (_Tp(&__a)[_Np], _Tp(&__b)[_Np]) noexcept(__is_nothrow_swappable< _Tp >::value)
template<class T >
constexpr T &&	forward (std::remove_reference_t< T > &t) noexcept
template<class T >
constexpr T &&	forward (std::remove_reference_t< T > &&t) noexcept
template<class T1 , class T2 >
std::pair< T1, T2 >	make_pair (T1 x, T2 y)

Variables
const nothrow_t	nothrow
template<class T , class U >
constexpr bool	is_same_v = is_same<T, U>::value
template<class T >
constexpr bool	is_void_v = is_void<T>::value
template<class T >
constexpr bool	is_null_pointer_v = is_null_pointer<T>::value
template<class T >
constexpr bool	is_array_v = is_array<T>::value
template<class T >
constexpr bool	is_enum_v = is_enum<T>::value
template<class T >
constexpr bool	is_floating_point_v = is_floating_point<T>::value
template<class T >
constexpr bool	is_union_v = is_union<T>::value
template<class T >
constexpr bool	is_class_v = is_class<T>::value
template<class T >
constexpr bool	is_function_v = is_function<T>::value
template<class T >
constexpr bool	is_pointer_v = is_pointer<T>::value
template<class T >
constexpr bool	is_lvalue_reference_v = is_lvalue_reference<T>::value
template<class T >
constexpr bool	is_rvalue_reference_v = is_rvalue_reference<T>::value
template<class T >
constexpr bool	is_member_object_pointer_v
template<class T >
constexpr bool	is_member_function_pointer_v
template<class T >
constexpr bool	is_fundamental_v = is_fundamental<T>::value
template<class T >
constexpr bool	is_arithmetic_v = is_arithmetic<T>::value
template<class T >
constexpr bool	is_scalar_v = is_scalar<T>::value
template<class T >
constexpr bool	is_object_v = is_object<T>::value
template<class T >
constexpr bool	is_compound_v = is_compound<T>::value
template<class T >
constexpr bool	is_reference_v = is_reference<T>::value
template<class T >
constexpr bool	is_member_pointer_v = is_member_pointer<T>::value
template<class T >
constexpr bool	is_const_v = is_const<T>::value
template<class T >
constexpr bool	is_volatile_v = is_volatile<T>::value
template<class T >
constexpr bool	is_trivial_v = is_trivial<T>::value
template<class T >
constexpr bool	is_trivially_copyable_v = is_trivially_copyable<T>::value
template<class T >
constexpr bool	is_standard_layout_v = is_standard_layout<T>::value
template<class T >
constexpr bool	has_unique_object_representations_v
template<class T >
constexpr bool	is_empty_v = is_empty<T>::value
template<class T >
constexpr bool	is_polymorphic_v = is_polymorphic<T>::value
template<class T >
constexpr bool	is_abstract_v = is_abstract<T>::value
template<class T >
constexpr bool	is_final_v = is_final<T>::value
template<class T >
constexpr bool	is_aggregate_v = is_aggregate<T>::value
template<class T >
constexpr bool	is_signed_v = is_signed<T>::value
template<class T >
constexpr bool	is_unsigned_v = is_unsigned<T>::value
template<class T , class... Args>
constexpr bool	is_constructible_v = is_constructible<T, Args...>::value
template<class T , class... Args>
constexpr bool	is_trivially_constructible_v
template<class T , class... Args>
constexpr bool	is_nothrow_constructible_v
template<class T >
constexpr bool	is_default_constructible_v
template<class T >
constexpr bool	is_trivially_default_constructible_v
template<class T >
constexpr bool	is_nothrow_default_constructible_v
template<class T >
constexpr bool	is_copy_constructible_v = is_copy_constructible<T>::value
template<class T >
constexpr bool	is_trivially_copy_constructible_v
template<class T >
constexpr bool	is_nothrow_copy_constructible_v
template<class T >
constexpr bool	is_move_constructible_v = is_move_constructible<T>::value
template<class T >
constexpr bool	is_trivially_move_constructible_v
template<class T >
constexpr bool	is_nothrow_move_constructible_v
template<class T , class... Args>
constexpr bool	is_assignable_v = is_assignable<T, Args...>::value
template<class T , class... Args>
constexpr bool	is_trivially_assignable_v
template<class T , class... Args>
constexpr bool	is_nothrow_assignable_v
template<class T >
constexpr bool	is_copy_assignable_v = is_copy_assignable<T>::value
template<class T >
constexpr bool	is_trivially_copy_assignable_v
template<class T >
constexpr bool	is_nothrow_copy_assignable_v
template<class T >
constexpr bool	is_move_assignable_v = is_move_assignable<T>::value
template<class T >
constexpr bool	is_trivially_move_assignable_v
template<class T >
constexpr bool	is_nothrow_move_assignable_v
template<class _Tp >
constexpr bool	is_destructible_v = is_destructible<_Tp>::value
template<class _Tp >
constexpr bool	is_trivially_destructible_v
template<class _Tp >
constexpr bool	is_nothrow_destructible_v
template<class _Tp >
constexpr bool	has_virtual_destructor_v
template<class _Tp , class _Up >
constexpr bool	is_swappable_with_v = is_swappable_with<_Tp, _Up>::value
template<class _Tp >
constexpr bool	is_swappable_v = is_swappable<_Tp>::value
template<class _Tp , class _Up >
constexpr bool	is_nothrow_swappable_with_v
template<class _Tp >
constexpr bool	is_nothrow_swappable_v = is_nothrow_swappable<_Tp>::value
template<class T >
constexpr size_t	alignment_of_v = alignment_of<T>::value
template<class T >
constexpr size_t	rank_v = rank<T>::value
template<class T , unsigned N = 0>
constexpr std::size_t	extent_v = extent<T, N>::value
template<class T , class U >
constexpr bool	is_base_of_v = is_base_of<T, U>::value
template<class T , class U >
constexpr bool	is_convertible_v = is_convertible<T, U>::value
template<class _Fn , class... _Args>
constexpr bool	is_invocable_v = is_invocable<_Fn, _Args...>::value
template<class _Ret , class _Fn , class... _Args>
constexpr bool	is_invocable_r_v
template<class _Fn , class... _Args>
constexpr bool	is_nothrow_invocable_v
template<class _Ret , class _Fn , class... _Args>
constexpr bool	is_nothrow_invocable_r_v

Typedef Documentation

add_const_t

template<class T >

using std::add_const_t = typedef typename add_const<T>::type

add_cv_t

template<class T >

using std::add_cv_t = typedef typename add_cv<T>::type

add_lvalue_reference_t

template<class T >

using std::add_lvalue_reference_t = typedef typename add_lvalue_reference<T>::type

add_pointer_t

template<class T >

using std::add_pointer_t = typedef typename add_pointer<T>::type

add_rvalue_reference_t

template<class T >

using std::add_rvalue_reference_t = typedef typename add_rvalue_reference<T>::type

add_volatile_t

template<class T >

using std::add_volatile_t = typedef typename add_volatile<T>::type

bool_constant

template<bool B>

using std::bool_constant = typedef integral_constant<bool, B>

conditional_t

template<bool B, class T , class F >

using std::conditional_t = typedef typename conditional<B, T, F>::type

decay_t

template<class T >

using std::decay_t = typedef typename decay<T>::type

false_type

typedef integral_constant<bool, false> std::false_type

int16_t

using std::int16_t = typedef ::int16_t

int32_t

using std::int32_t = typedef ::int32_t

int64_t

using std::int64_t = typedef ::int64_t

int8_t

using std::int8_t = typedef ::int8_t

int_fast16_t

using std::int_fast16_t = typedef ::int_fast16_t

int_fast32_t

using std::int_fast32_t = typedef ::int_fast32_t

int_fast64_t

using std::int_fast64_t = typedef ::int_fast64_t

int_fast8_t

using std::int_fast8_t = typedef ::int_fast8_t

int_least16_t

using std::int_least16_t = typedef ::int_least16_t

int_least32_t

using std::int_least32_t = typedef ::int_least32_t

int_least64_t

using std::int_least64_t = typedef ::int_least64_t

int_least8_t

using std::int_least8_t = typedef ::int_least8_t

intmax_t

using std::intmax_t = typedef ::intmax_t

intptr_t

using std::intptr_t = typedef ::intptr_t

max_align_t

using std::max_align_t = typedef ::max_align_t

new_handler

typedef void(* std::new_handler) ()

nullptr_t

using std::nullptr_t = typedef decltype(nullptr)

ptrdiff_t

using std::ptrdiff_t = typedef ::ptrdiff_t

remove_all_extents_t

template<class T >

using std::remove_all_extents_t = typedef typename remove_all_extents<T>::type

remove_cv_t

template<class T >

using std::remove_cv_t = typedef typename remove_cv<T>::type

remove_extent_t

template<class T >

using std::remove_extent_t = typedef typename remove_extent<T>::type

remove_pointer_t

template<class T >

using std::remove_pointer_t = typedef typename remove_pointer<T>::type

remove_reference_t

template<class T >

using std::remove_reference_t = typedef typename remove_reference<T>::type

size_t

using std::size_t = typedef ::size_t

terminate_handler

using std::terminate_handler = typedef void (*)()

true_type

typedef integral_constant<bool, true> std::true_type

uint16_t

using std::uint16_t = typedef ::uint16_t

uint32_t

using std::uint32_t = typedef ::uint32_t

uint64_t

using std::uint64_t = typedef ::uint64_t

uint8_t

using std::uint8_t = typedef ::uint8_t

uint_fast16_t

using std::uint_fast16_t = typedef ::uint_fast16_t

uint_fast32_t

using std::uint_fast32_t = typedef ::uint_fast32_t

uint_fast64_t

using std::uint_fast64_t = typedef ::uint_fast64_t

uint_fast8_t

using std::uint_fast8_t = typedef ::uint_fast8_t

uint_least16_t

using std::uint_least16_t = typedef ::uint_least16_t

uint_least32_t

using std::uint_least32_t = typedef ::uint_least32_t

uint_least64_t

using std::uint_least64_t = typedef ::uint_least64_t

uint_least8_t

using std::uint_least8_t = typedef ::uint_least8_t

uintmax_t

using std::uintmax_t = typedef ::uintmax_t

uintptr_t

using std::uintptr_t = typedef ::uintptr_t

Enumeration Type Documentation

byte

enum std::byte : unsigned char

strong

float_denorm_style

enum std::float_denorm_style

Enumerator
denorm_indeterminate
denorm_absent
denorm_present

float_round_style

enum std::float_round_style

Enumerator
round_indeterminate
round_toward_zero
round_to_nearest
round_toward_infinity
round_toward_neg_infinity

Function Documentation

begin() [1/4]

template<class C >

constexpr auto std::begin ( C &  c ) -> decltype(c.begin())

constexpr

begin() [2/4]

template<class C >

constexpr auto std::begin ( const C &  c ) -> decltype(c.begin())

constexpr

begin() [3/4]

template<class E >

constexpr const E* std::begin ( initializer_list< E >  il )

constexprnoexcept

begin() [4/4]

template<class T , std::size_t _N>

constexpr T* std::begin ( T(&)  array[_N] )

constexprnoexcept

cbegin()

template<class C >

constexpr auto std::cbegin ( const C &  c ) -> decltype(c.begin())

constexprnoexcept

cend()

template<class C >

constexpr auto std::cend ( const C &  c ) -> decltype(c.end())

constexprnoexcept

end() [1/4]

template<class C >

constexpr auto std::end ( C &  c ) -> decltype(c.end())

constexpr

end() [2/4]

template<class C >

constexpr auto std::end ( const C &  c ) -> decltype(c.end())

constexpr

end() [3/4]

template<class E >

constexpr const E* std::end ( initializer_list< E >  il )

constexprnoexcept

end() [4/4]

template<class T , std::size_t _N>

constexpr T* std::end ( T(&)  array[_N] )

constexprnoexcept

forward() [1/2]

template<class T >

constexpr T&& std::forward ( std::remove_reference_t< T > &&  t )

constexprnoexcept

forward() [2/2]

template<class T >

constexpr T&& std::forward ( std::remove_reference_t< T > &  t )

constexprnoexcept

get_new_handler()

new_handler std::get_new_handler ( )

noexcept

get_terminate()

terminate_handler std::get_terminate ( )

noexcept

make_pair()

template<class T1 , class T2 >

std::pair<T1, T2> std::make_pair	(	T1	x,
		T2	y
	)

max_element() [1/2]

template<class ForwardIt >

ForwardIt std::max_element	(	ForwardIt	first,
		ForwardIt	last
	)

max_element() [2/2]

template<class ForwardIt , class Compare >

ForwardIt std::max_element	(	ForwardIt	first,
		ForwardIt	last,
		Compare	comp
	)

min_element() [1/2]

template<class ForwardIt >

ForwardIt std::min_element	(	ForwardIt	first,
		ForwardIt	last
	)

min_element() [2/2]

template<class ForwardIt , class Compare >

ForwardIt std::min_element	(	ForwardIt	first,
		ForwardIt	last,
		Compare	comp
	)

operator&()

constexpr byte std::operator& ( byte  l, byte  r  )

constexprnoexcept

operator&=()

constexpr byte& std::operator&= ( byte &  l, byte  r  )

constexprnoexcept

operator<<()

template<class IntegerType >

constexpr enable_if_t<is_integral<IntegerType>::value, byte> std::operator<< ( byte  b, IntegerType  shift  )

constexprnoexcept

operator<<=()

template<class IntegerType >

constexpr enable_if_t<is_integral<IntegerType>::value, byte &> std::operator<<= ( byte &  b, IntegerType  shift  )

constexprnoexcept

operator>>()

template<class IntegerType >

constexpr enable_if_t<is_integral<IntegerType>::value, byte> std::operator>> ( byte  b, IntegerType  shift  )

constexprnoexcept

operator>>=()

template<class IntegerType >

constexpr enable_if_t<is_integral<IntegerType>::value, byte &> std::operator>>= ( byte &  b, IntegerType  shift  )

constexprnoexcept

operator^()

constexpr byte std::operator^ ( byte  l, byte  r  )

constexprnoexcept

operator^=()

constexpr byte& std::operator^= ( byte &  l, byte  r  )

constexprnoexcept

operator|()

constexpr byte std::operator| ( byte  l, byte  r  )

constexprnoexcept

operator|=()

constexpr byte& std::operator|= ( byte &  l, byte  r  )

constexprnoexcept

operator~()

constexpr byte std::operator~ ( byte  b )

constexprnoexcept

set_new_handler()

new_handler std::set_new_handler ( new_handler  new_p )

noexcept

set_terminate()

terminate_handler std::set_terminate ( terminate_handler  f )

noexcept

swap() [1/2]

template<class _Tp >

constexpr __swap_result_t<_Tp> std::swap ( _Tp &  __x, _Tp &  __y  ) const &&

inlineconstexprnoexcept

swap() [2/2]

template<class _Tp , size_t _Np>

constexpr enable_if_t<__is_swappable<_Tp>::value> std::swap ( _Tp(&)  __a[_Np], _Tp(&)  __b[_Np]  )

inlineconstexprnoexcept

terminate()

void std::terminate ( )

noexcept

to_integer()

template<class IntegerType >

constexpr enable_if_t<is_integral<IntegerType>::value, IntegerType> std::to_integer ( byte  b )

constexprnoexcept

Variable Documentation

alignment_of_v

template<class T >

constexpr size_t std::alignment_of_v = alignment_of<T>::value

inlineconstexpr

extent_v

template<class T , unsigned N = 0>

constexpr std::size_t std::extent_v = extent<T, N>::value

inlineconstexpr

has_unique_object_representations_v

template<class T >

constexpr bool std::has_unique_object_representations_v

inlineconstexpr

Initial value:

=
    has_unique_object_representations<T>::value

has_virtual_destructor_v

template<class _Tp >

constexpr bool std::has_virtual_destructor_v

inlineconstexpr

Initial value:

=
    has_virtual_destructor<_Tp>::value

is_abstract_v

template<class T >

constexpr bool std::is_abstract_v = is_abstract<T>::value

inlineconstexpr

is_aggregate_v

template<class T >

constexpr bool std::is_aggregate_v = is_aggregate<T>::value

inlineconstexpr

is_arithmetic_v

template<class T >

constexpr bool std::is_arithmetic_v = is_arithmetic<T>::value

inlineconstexpr

is_array_v

template<class T >

constexpr bool std::is_array_v = is_array<T>::value

inlineconstexpr

is_assignable_v

template<class T , class... Args>

constexpr bool std::is_assignable_v = is_assignable<T, Args...>::value

inlineconstexpr

is_base_of_v

template<class T , class U >

constexpr bool std::is_base_of_v = is_base_of<T, U>::value

inlineconstexpr

is_class_v

template<class T >

constexpr bool std::is_class_v = is_class<T>::value

inlineconstexpr

is_compound_v

template<class T >

constexpr bool std::is_compound_v = is_compound<T>::value

inlineconstexpr

is_const_v

template<class T >

constexpr bool std::is_const_v = is_const<T>::value

inlineconstexpr

is_constructible_v

template<class T , class... Args>

constexpr bool std::is_constructible_v = is_constructible<T, Args...>::value

inlineconstexpr

is_convertible_v

template<class T , class U >

constexpr bool std::is_convertible_v = is_convertible<T, U>::value

inlineconstexpr

is_copy_assignable_v

template<class T >

constexpr bool std::is_copy_assignable_v = is_copy_assignable<T>::value

inlineconstexpr

is_copy_constructible_v

template<class T >

constexpr bool std::is_copy_constructible_v = is_copy_constructible<T>::value

inlineconstexpr

is_default_constructible_v

template<class T >

constexpr bool std::is_default_constructible_v

inlineconstexpr

Initial value:

=
    is_default_constructible<T>::value

is_destructible_v

template<class _Tp >

constexpr bool std::is_destructible_v = is_destructible<_Tp>::value

inlineconstexpr

is_empty_v

template<class T >

constexpr bool std::is_empty_v = is_empty<T>::value

inlineconstexpr

is_enum_v

template<class T >

constexpr bool std::is_enum_v = is_enum<T>::value

inlineconstexpr

is_final_v

template<class T >

constexpr bool std::is_final_v = is_final<T>::value

inlineconstexpr

is_floating_point_v

template<class T >

constexpr bool std::is_floating_point_v = is_floating_point<T>::value

inlineconstexpr

is_function_v

template<class T >

constexpr bool std::is_function_v = is_function<T>::value

inlineconstexpr

is_fundamental_v

template<class T >

constexpr bool std::is_fundamental_v = is_fundamental<T>::value

inlineconstexpr

is_invocable_r_v

template<class _Ret , class _Fn , class... _Args>

constexpr bool std::is_invocable_r_v

inlineconstexpr

Initial value:

=
    is_invocable_r<_Ret, _Fn, _Args...>::value

is_invocable_v

template<class _Fn , class... _Args>

constexpr bool std::is_invocable_v = is_invocable<_Fn, _Args...>::value

inlineconstexpr

is_lvalue_reference_v

template<class T >

constexpr bool std::is_lvalue_reference_v = is_lvalue_reference<T>::value

inlineconstexpr

is_member_function_pointer_v

template<class T >

constexpr bool std::is_member_function_pointer_v

inlineconstexpr

Initial value:

=
    is_member_function_pointer<T>::value

is_member_object_pointer_v

template<class T >

constexpr bool std::is_member_object_pointer_v

inlineconstexpr

Initial value:

=
    is_member_object_pointer<T>::value

is_member_pointer_v

template<class T >

constexpr bool std::is_member_pointer_v = is_member_pointer<T>::value

inlineconstexpr

is_move_assignable_v

template<class T >

constexpr bool std::is_move_assignable_v = is_move_assignable<T>::value

inlineconstexpr

is_move_constructible_v

template<class T >

constexpr bool std::is_move_constructible_v = is_move_constructible<T>::value

inlineconstexpr

is_nothrow_assignable_v

template<class T , class... Args>

constexpr bool std::is_nothrow_assignable_v

inlineconstexpr

Initial value:

=
    is_nothrow_assignable<T, Args...>::value

is_nothrow_constructible_v

template<class T , class... Args>

constexpr bool std::is_nothrow_constructible_v

inlineconstexpr

Initial value:

=
    is_nothrow_constructible<T, Args...>::value

is_nothrow_copy_assignable_v

template<class T >

constexpr bool std::is_nothrow_copy_assignable_v

inlineconstexpr

Initial value:

=
    is_nothrow_copy_assignable<T>::value

is_nothrow_copy_constructible_v

template<class T >

constexpr bool std::is_nothrow_copy_constructible_v

inlineconstexpr

Initial value:

=
    is_nothrow_copy_constructible<T>::value

is_nothrow_default_constructible_v

template<class T >

constexpr bool std::is_nothrow_default_constructible_v

inlineconstexpr

Initial value:

=
    is_nothrow_default_constructible<T>::value

is_nothrow_destructible_v

template<class _Tp >

constexpr bool std::is_nothrow_destructible_v

inlineconstexpr

Initial value:

=
    is_nothrow_destructible<_Tp>::value

is_nothrow_invocable_r_v

template<class _Ret , class _Fn , class... _Args>

constexpr bool std::is_nothrow_invocable_r_v

inlineconstexpr

Initial value:

=
    is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value

is_nothrow_invocable_v

template<class _Fn , class... _Args>

constexpr bool std::is_nothrow_invocable_v

inlineconstexpr

Initial value:

=
    is_nothrow_invocable<_Fn, _Args...>::value

is_nothrow_move_assignable_v

template<class T >

constexpr bool std::is_nothrow_move_assignable_v

inlineconstexpr

Initial value:

=
    is_nothrow_move_assignable<T>::value

is_nothrow_move_constructible_v

template<class T >

constexpr bool std::is_nothrow_move_constructible_v

inlineconstexpr

Initial value:

=
    is_nothrow_move_constructible<T>::value

is_nothrow_swappable_v

template<class _Tp >

constexpr bool std::is_nothrow_swappable_v = is_nothrow_swappable<_Tp>::value

inlineconstexpr

is_nothrow_swappable_with_v

template<class _Tp , class _Up >

constexpr bool std::is_nothrow_swappable_with_v

inlineconstexpr

Initial value:

=
    is_nothrow_swappable_with<_Tp, _Up>::value

is_null_pointer_v

template<class T >

constexpr bool std::is_null_pointer_v = is_null_pointer<T>::value

inlineconstexpr

is_object_v

template<class T >

constexpr bool std::is_object_v = is_object<T>::value

inlineconstexpr

is_pointer_v

template<class T >

constexpr bool std::is_pointer_v = is_pointer<T>::value

inlineconstexpr

is_polymorphic_v

template<class T >

constexpr bool std::is_polymorphic_v = is_polymorphic<T>::value

inlineconstexpr

is_reference_v

template<class T >

constexpr bool std::is_reference_v = is_reference<T>::value

inlineconstexpr

is_rvalue_reference_v

template<class T >

constexpr bool std::is_rvalue_reference_v = is_rvalue_reference<T>::value

inlineconstexpr

is_same_v

template<class T , class U >

constexpr bool std::is_same_v = is_same<T, U>::value

inlineconstexpr

is_scalar_v

template<class T >

constexpr bool std::is_scalar_v = is_scalar<T>::value

inlineconstexpr

is_signed_v

template<class T >

constexpr bool std::is_signed_v = is_signed<T>::value

inlineconstexpr

is_standard_layout_v

template<class T >

constexpr bool std::is_standard_layout_v = is_standard_layout<T>::value

inlineconstexpr

is_swappable_v

template<class _Tp >

constexpr bool std::is_swappable_v = is_swappable<_Tp>::value

inlineconstexpr

is_swappable_with_v

template<class _Tp , class _Up >

constexpr bool std::is_swappable_with_v = is_swappable_with<_Tp, _Up>::value

inlineconstexpr

is_trivial_v

template<class T >

constexpr bool std::is_trivial_v = is_trivial<T>::value

inlineconstexpr

is_trivially_assignable_v

template<class T , class... Args>

constexpr bool std::is_trivially_assignable_v

inlineconstexpr

Initial value:

=
    is_trivially_assignable<T, Args...>::value

is_trivially_constructible_v

template<class T , class... Args>

constexpr bool std::is_trivially_constructible_v

inlineconstexpr

Initial value:

=
    is_trivially_constructible<T, Args...>::value

is_trivially_copy_assignable_v

template<class T >

constexpr bool std::is_trivially_copy_assignable_v

inlineconstexpr

Initial value:

=
    is_trivially_copy_assignable<T>::value

is_trivially_copy_constructible_v

template<class T >

constexpr bool std::is_trivially_copy_constructible_v

inlineconstexpr

Initial value:

=
    is_trivially_copy_constructible<T>::value

is_trivially_copyable_v

template<class T >

constexpr bool std::is_trivially_copyable_v = is_trivially_copyable<T>::value

inlineconstexpr

is_trivially_default_constructible_v

template<class T >

constexpr bool std::is_trivially_default_constructible_v

inlineconstexpr

Initial value:

=
    is_trivially_default_constructible<T>::value

is_trivially_destructible_v

template<class _Tp >

constexpr bool std::is_trivially_destructible_v

inlineconstexpr

Initial value:

=
    is_trivially_destructible<_Tp>::value

is_trivially_move_assignable_v

template<class T >

constexpr bool std::is_trivially_move_assignable_v

inlineconstexpr

Initial value:

=
    is_trivially_move_assignable<T>::value

is_trivially_move_constructible_v

template<class T >

constexpr bool std::is_trivially_move_constructible_v

inlineconstexpr

Initial value:

=
    is_trivially_move_constructible<T>::value

is_union_v

template<class T >

constexpr bool std::is_union_v = is_union<T>::value

inlineconstexpr

is_unsigned_v

template<class T >

constexpr bool std::is_unsigned_v = is_unsigned<T>::value

inlineconstexpr

is_void_v

template<class T >

constexpr bool std::is_void_v = is_void<T>::value

inlineconstexpr

is_volatile_v

template<class T >

constexpr bool std::is_volatile_v = is_volatile<T>::value

inlineconstexpr

nothrow

const nothrow_t std::nothrow

extern

rank_v

template<class T >

constexpr size_t std::rank_v = rank<T>::value

inlineconstexpr