14882: Tables (original) (raw)

Tables [tab]

Table 1 — Basic character set [tab:lex.charset.basic]

🔗character	glyph
🔗U+0009	character tabulation
🔗U+000b	line tabulation
🔗U+000c	form feed
🔗U+0020	space
🔗U+000a	line feed	new-line
🔗U+0021	exclamation mark	!
🔗U+0022	quotation mark	"
🔗U+0023	number sign	#
🔗U+0024	dollar sign	$
🔗U+0025	percent sign	%
🔗U+0026	ampersand	&
🔗U+0027	apostrophe	'
🔗U+0028	left parenthesis	(
🔗U+0029	right parenthesis	)
🔗U+002a	asterisk	*
🔗U+002b	plus sign	+
🔗U+002c	comma	,
🔗U+002d	hyphen-minus	-
🔗U+002e	full stop	.
🔗U+002f	solidus	/
🔗U+0030 .. U+0039	digit zero .. nine	0 1 2 3 4 5 6 7 8 9
🔗U+003a	colon	:
🔗U+003b	semicolon	;
🔗U+003c	less-than sign	<
🔗U+003d	equals sign	=
🔗U+003e	greater-than sign	>
🔗U+003f	question mark	?
🔗U+0040	commercial at	@
🔗U+0041 .. U+005a	latin capital letter a .. z	A B C D E F G H I J K L M
🔗	N O P Q R S T U V W X Y Z
🔗U+005b	left square bracket	[
🔗U+005c	reverse solidus	\
🔗U+005d	right square bracket	]
🔗U+005e	circumflex accent	^
🔗U+005f	low line	_
🔗U+0060	grave accent	`
🔗U+0061 .. U+007a	latin small letter a .. z	a b c d e f g h i j k l m
🔗	n o p q r s t u v w x y z
🔗U+007b	left curly bracket	{
🔗U+007c	vertical line	\|
🔗U+007d	right curly bracket	}
🔗U+007e	tilde	~

Table 2 — Additional control characters in the basic literal character set [tab:lex.charset.literal]

U+0000	null
U+0007	alert
U+0008	backspace
U+000d	carriage return

Table 3 — Alternative tokens [tab:lex.digraph]

🔗Alternative	Primary	Alternative	Primary	Alternative	Primary
🔗<%	{	and	&&	and_eq	&=
🔗%>	}	bitor	\|	or_eq	\|=
🔗<:	[	or	\|		xor_eq
🔗:>	]	xor	^	not	!
🔗%:	#	compl	~	not_eq	!=
🔗%:%:	##	bitand	&

Table 5 — Keywords [tab:lex.key]

🔗alignas	constinit	extern	protected	throw
🔗alignof	const_cast	false	public	true
🔗asm	continue	float	register	try
🔗auto	contract_assert	for	reinterpret_cast	typedef
🔗bool	co_await	friend	requires	typeid
🔗break	co_return	goto	return	typename
🔗case	co_yield	if	short	union
🔗catch	decltype	inline	signed	unsigned
🔗char	default	int	sizeof	using
🔗char8_t	delete	long	static	virtual
🔗char16_t	do	mutable	static_assert	void
🔗char32_t	double	namespace	static_cast	volatile
🔗class	dynamic_cast	new	struct	wchar_t
🔗concept	else	noexcept	switch	while
🔗const	enum	nullptr	template
🔗consteval	explicit	operator	this
🔗constexpr	export	private	thread_local

Table 6 — Alternative representations [tab:lex.key.digraph]

🔗and	and_eq	bitand	bitor	compl	not
🔗not_eq	or	or_eq	xor	xor_eq

Table 8 — Types of integer-literals [tab:lex.icon.type]

🔗*integer-suffix*	*decimal-literal*	**integer-literal other than decimal-literal**
🔗none	int	int
🔗	long int	unsigned int
🔗	long long int	long int
🔗	unsigned long int
🔗	long long int
🔗	unsigned long long int
🔗u or U	unsigned int	unsigned int
🔗	unsigned long int	unsigned long int
🔗	unsigned long long int	unsigned long long int
🔗l or L	long int	long int
🔗	long long int	unsigned long int
🔗	long long int
🔗	unsigned long long int
🔗Both u or U	unsigned long int	unsigned long int
🔗and l or L	unsigned long long int	unsigned long long int
🔗ll or LL	long long int	long long int
🔗	unsigned long long int
🔗Both u or U	unsigned long long int	unsigned long long int
🔗and ll or LL
🔗z or Z	the signed integer type corresponding	the signed integer type
🔗	to std::size_t ([support.types.layout])	corresponding to std::size_t
🔗	std::size_t
🔗Both u or U	std::size_t	std::size_t
🔗and z or Z

Table 10 — Simple escape sequences [tab:lex.ccon.esc]

🔗character	*simple-escape-sequence*
🔗U+000a	line feed	\n
🔗U+0009	character tabulation	\t
🔗U+000b	line tabulation	\v
🔗U+0008	backspace	\b
🔗U+000d	carriage return	\r
🔗U+000c	form feed	\f
🔗U+0007	alert	\a
🔗U+005c	reverse solidus	\\
🔗U+003f	question mark	\?
🔗U+0027	apostrophe	\'
🔗U+0022	quotation mark	\"

Table 13 — String literal concatenations [tab:lex.string.concat]

🔗Source	Means	Source	Means	Source	Means
🔗u"a"	u"b"	u"ab"	U"a"	U"b"	U"ab"	L"a"	L"b"	L"ab"
🔗u"a"	"b"	u"ab"	U"a"	"b"	U"ab"	L"a"	"b"	L"ab"
🔗"a"	u"b"	u"ab"	"a"	U"b"	U"ab"	"a"	L"b"	L"ab"

Table 15 — Properties of named extended floating-point types [tab:basic.extended.fp]

🔗Parameter	float16_t	float32_t	float64_t	float128_t	bfloat16_t
🔗ISO/IEC 60559 name	binary16	binary32	binary64	binary128
🔗k, storage width in bits	16	32	64	128	16
🔗p, precision in bits	11	24	53	113	8
🔗emax, maximum exponent	15	127	1023	16383	127
🔗w, exponent field width in bits	5	8	11	15	8

Table 16 — Relations on const and volatile [tab:basic.type.qualifier.rel]

🔗no cv-qualifier	<	const
🔗no cv-qualifier	<	volatile
🔗no cv-qualifier	<	const volatile
🔗const	<	const volatile
🔗volatile	<	const volatile

Table 21 — __has_cpp_attribute values [tab:cpp.cond.ha]

🔗Attribute	Value
🔗assume	202207L
🔗deprecated	201309L
🔗fallthrough	201603L
🔗likely	201803L
🔗maybe_unused	201603L
🔗no_unique_address	201803L
🔗nodiscard	201907L
🔗noreturn	200809L
🔗unlikely	201803L

Table 22 — Feature-test macros [tab:cpp.predefined.ft]

🔗Macro name	Value
🔗__cpp_aggregate_bases	201603L
🔗__cpp_aggregate_nsdmi	201304L
🔗__cpp_aggregate_paren_init	201902L
🔗__cpp_alias_templates	200704L
🔗__cpp_aligned_new	201606L
🔗__cpp_attributes	200809L
🔗__cpp_auto_cast	202110L
🔗__cpp_binary_literals	201304L
🔗__cpp_capture_star_this	201603L
🔗__cpp_char8_t	202207L
🔗__cpp_concepts	202002L
🔗__cpp_conditional_explicit	201806L
🔗__cpp_constexpr	202406L
🔗__cpp_constexpr_dynamic_alloc	201907L
🔗__cpp_constexpr_exceptions	202411L
🔗__cpp_constexpr_in_decltype	201711L
🔗__cpp_consteval	202211L
🔗__cpp_constinit	201907L
🔗__cpp_contracts	202502L
🔗__cpp_decltype	200707L
🔗__cpp_decltype_auto	201304L
🔗__cpp_deduction_guides	201907L
🔗__cpp_delegating_constructors	200604L
🔗__cpp_deleted_function	202403L
🔗__cpp_designated_initializers	201707L
🔗__cpp_enumerator_attributes	201411L
🔗__cpp_explicit_this_parameter	202110L
🔗__cpp_fold_expressions	201603L
🔗__cpp_generic_lambdas	201707L
🔗__cpp_guaranteed_copy_elision	201606L
🔗__cpp_hex_float	201603L
🔗__cpp_if_consteval	202106L
🔗__cpp_if_constexpr	201606L
🔗__cpp_impl_coroutine	201902L
🔗__cpp_impl_destroying_delete	201806L
🔗__cpp_impl_three_way_comparison	201907L
🔗__cpp_implicit_move	202207L
🔗__cpp_inheriting_constructors	201511L
🔗__cpp_init_captures	201803L
🔗__cpp_initializer_lists	200806L
🔗__cpp_inline_variables	201606L
🔗__cpp_lambdas	200907L
🔗__cpp_modules	201907L
🔗__cpp_multidimensional_subscript	202211L
🔗__cpp_named_character_escapes	202207L
🔗__cpp_namespace_attributes	201411L
🔗__cpp_noexcept_function_type	201510L
🔗__cpp_nontype_template_args	201911L
🔗__cpp_nontype_template_parameter_auto	201606L
🔗__cpp_nsdmi	200809L
🔗__cpp_pack_indexing	202311L
🔗__cpp_placeholder_variables	202306L
🔗__cpp_pp_embed	202502L
🔗__cpp_range_based_for	202211L
🔗__cpp_raw_strings	200710L
🔗__cpp_ref_qualifiers	200710L
🔗__cpp_return_type_deduction	201304L
🔗__cpp_rvalue_references	200610L
🔗__cpp_size_t_suffix	202011L
🔗__cpp_sized_deallocation	201309L
🔗__cpp_static_assert	202306L
🔗__cpp_static_call_operator	202207L
🔗__cpp_structured_bindings	202411L
🔗__cpp_template_parameters	202502L
🔗__cpp_template_template_args	201611L
🔗__cpp_threadsafe_static_init	200806L
🔗__cpp_trivial_relocatability	202502L
🔗__cpp_trivial_union	202502L
🔗__cpp_unicode_characters	200704L
🔗__cpp_unicode_literals	200710L
🔗__cpp_user_defined_literals	200809L
🔗__cpp_using_enum	201907L
🔗__cpp_variable_templates	201304L
🔗__cpp_variadic_friend	202403L
🔗__cpp_variadic_templates	200704L
🔗__cpp_variadic_using	201611L

Table 26 — Names from ISO/IEC 9899:2018, Annex K [tab:c.annex.k.names]

🔗abort_handler_s	mbstowcs_s	strncat_s	vswscanf_s
🔗asctime_s	memcpy_s	strncpy_s	vwprintf_s
🔗bsearch_s	memmove_s	strtok_s	vwscanf_s
🔗constraint_handler_t	memset_s	swprintf_s	wcrtomb_s
🔗ctime_s	printf_s	swscanf_s	wcscat_s
🔗errno_t	qsort_s	tmpfile_s	wcscpy_s
🔗fopen_s	RSIZE_MAX	TMP_MAX_S	wcsncat_s
🔗fprintf_s	rsize_t	tmpnam_s	wcsncpy_s
🔗freopen_s	scanf_s	vfprintf_s	wcsnlen_s
🔗fscanf_s	set_constraint_handler_s	vfscanf_s	wcsrtombs_s
🔗fwprintf_s	snprintf_s	vfwprintf_s	wcstok_s
🔗fwscanf_s	snwprintf_s	vfwscanf_s	wcstombs_s
🔗getenv_s	sprintf_s	vprintf_s	wctomb_s
🔗gets_s	sscanf_s	vscanf_s	wmemcpy_s
🔗gmtime_s	strcat_s	vsnprintf_s	wmemmove_s
🔗ignore_handler_s	strcpy_s	vsnwprintf_s	wprintf_s
🔗localtime_s	strerrorlen_s	vsprintf_s	wscanf_s
🔗L_tmpnam_s	strerror_s	vsscanf_s
🔗mbsrtowcs_s	strlen_s	vswprintf_s

Table 28 — Cpp17EqualityComparable requirements [tab:cpp17.equalitycomparable]

decltype(a == b) models boolean-testable	== is an equivalence relation, that is, it has the following properties:If a == b and b == c, then a == c.

Table 30 — Cpp17DefaultConstructible requirements [tab:cpp17.defaultconstructible]

object t is default-initialized
object u is value-initialized or aggregate-initialized
an object of type T is value-initialized or aggregate-initialized

Table 31 — Cpp17MoveConstructible requirements [tab:cpp17.moveconstructible]

u is equivalent to the value of rv before the construction
T(rv) is equivalent to the value of rv before the construction
rv's state is unspecified[Note 1: rv must still meet the requirements of the library component that is using it. The operations listed in those requirements must work as specified whether rv has been moved from or not. — _end note_]

Table 33 — Cpp17MoveAssignable requirements [tab:cpp17.moveassignable]

🔗Expression	Return type	Return value	Post-condition
🔗t = rv	T&	t	If t and rv do not refer to the same object,t is equivalent to the value of rv before the assignment
🔗rv's state is unspecified. [Note 2: rv must still meet the requirements of the library component that is using it, whether or not t and rv refer to the same object. The operations listed in those requirements must work as specified whether rv has been moved from or not. — _end note_]

Table 35 — Cpp17Destructible requirements [tab:cpp17.destructible]

All resources owned by u are reclaimed, no exception is propagated.

Table 36 — Cpp17NullablePointer requirements [tab:cpp17.nullablepointer]

🔗Expression	Return type	Operational semantics
🔗P u(np);	Postconditions: u == nullptr
🔗P u = np;
🔗P(np)	Postconditions: P(np) == nullptr
🔗t = np	P&	Postconditions: t == nullptr
🔗a != b	decltype(a != b) models boolean-testable	!(a == b)
🔗a == np	decltype(a == np) and decltype(np == a) each model boolean-testable	a == P()
🔗np == a
🔗a != np	decltype(a != np) and decltype(np != a) each model boolean-testable	!(a == np)
🔗np != a

Table 37 — Cpp17Hash requirements [tab:cpp17.hash]

The value returned shall depend only on the argument k for the duration of the program. [Note 1: Thus all evaluations of the expression h(k) with the same value for k yield the same result for a given execution of the program. — _end note_] For two different values t1 and t2, the probability that h(t1) and h(t2) compare equal should be very small, approaching 1.0 / numeric_limits<size_t>::max().

Table 38 — Zombie names in namespace std [tab:zombie.names.std]

🔗 auto_ptr	generate_header	pointer_to_binary_function
🔗 auto_ptr_ref	get_pointer_safety	pointer_to_unary_function
🔗 binary_function	get_temporary_buffer	ptr_fun
🔗 binary_negate	get_unexpected	random_shuffle
🔗 bind1st	gets	raw_storage_iterator
🔗 bind2nd	is_literal_type	result_of
🔗 binder1st	is_literal_type_v	result_of_t
🔗 binder2nd	istrstream	return_temporary_buffer
🔗 codecvt_mode	little_endian	set_unexpected
🔗 codecvt_utf16	mem_fun1_ref_t	strstream
🔗 codecvt_utf8	mem_fun1_t	strstreambuf
🔗 codecvt_utf8_utf16	mem_fun_ref_t	unary_function
🔗 const_mem_fun1_ref_t	mem_fun_ref	unary_negate
🔗 const_mem_fun1_t	mem_fun_t	uncaught_exception
🔗 const_mem_fun_ref_t	mem_fun	undeclare_no_pointers
🔗 const_mem_fun_t	not1	undeclare_reachable
🔗 consume_header	not2	unexpected_handler
🔗 declare_no_pointers	ostrstream	wbuffer_convert
🔗 declare_reachable	pointer_safety	wstring_convert

Table 43 — Value of object returned by current [tab:support.srcloc.current]

Line numbers are presumed to be 1-indexed; however, an implementation is encouraged to use 0 when the line number is unknown.
An implementation-defined value denoting some offset from the start of the line denoted by line_. Column numbers are presumed to be 1-indexed; however, an implementation is encouraged to use 0 when the column number is unknown.
A name of the current function such as in __func__ ([dcl.fct.def.general]) if any, an empty string otherwise.

Table 45 — Enum evaluation_semantic [tab:support.contract.enum.semantic]

🔗Name	Meaning
🔗ignore	Ignore evaluation semantic
🔗observe	Observe evaluation semantic
🔗enforce	Enforce evaluation semantic
🔗quick_enforce	Quick-enforce evaluation semantic
🔗

Table 46 — Enum detection_mode [tab:support.contract.enum.detection]

The predicate of the contract assertion evaluated to false or would have evaluated to false.
An uncaught exception occurred during evaluation of the contract assertion.

Table 63 — Expressions used to perform ratio arithmetic [tab:ratio.arithmetic]

🔗Type	Value of X	Value of Y
🔗ratio_add<R1, R2>	R1::num * R2::den +	R1::den * R2::den
🔗	R2::num * R1::den
🔗ratio_subtract<R1, R2>	R1::num * R2::den -	R1::den * R2::den
🔗	R2::num * R1::den
🔗ratio_multiply<R1, R2>	R1::num * R2::num	R1::den * R2::den
🔗ratio_divide<R1, R2>	R1::num * R2::den	R1::den * R2::num

Table 65 — optional::operator=(const optional&) effects [tab:optional.assign.copy]

🔗	*this contains a value	*this does not contain a value
🔗rhs contains a value	assigns *rhs to the contained value	direct-non-list-initializes the contained value with *rhs
🔗rhs does not contain a value	destroys the contained value by calling val->T::~T()	no effect

Table 66 — optional::operator=(optional&&) effects [tab:optional.assign.move]

🔗	*this contains a value	*this does not contain a value
🔗rhs contains a value	assigns std::move(*rhs) to the contained value	direct-non-list-initializes the contained value with std::move(*rhs)
🔗rhs does not contain a value	destroys the contained value by calling val->T::~T()	no effect

Table 67 — optional::operator=(const optional<U>&) effects [tab:optional.assign.copy.templ]

🔗	*this contains a value	*this does not contain a value
🔗rhs contains a value	assigns *rhs to the contained value	direct-non-list-initializes the contained value with *rhs
🔗rhs does not contain a value	destroys the contained value by calling val->T::~T()	no effect

Table 68 — optional::operator=(optional<U>&&) effects [tab:optional.assign.move.templ]

🔗	*this contains a value	*this does not contain a value
🔗rhs contains a value	assigns std::move(*rhs) to the contained value	direct-non-list-initializes the contained value with std::move(*rhs)
🔗rhs does not contain a value	destroys the contained value by calling val->T::~T()	no effect

Table 69 — optional::swap(optional&) effects [tab:optional.swap]

🔗	*this contains a value	*this does not contain a value
🔗rhs contains a value	calls swap((this), *rhs)	direct-non-list-initializes the contained value of thiswith std::move(rhs), followed by rhs.val->T::~T(); postcondition is that *this contains a value and rhs does not contain a value
🔗rhs does not contain a value	direct-non-list-initializes the contained value of rhswith std::move((this)), followed by val->T::~T(); postcondition is that *this does not contain a value and rhs contains a value	no effect

Table 70 — swap(expected&) effects [tab:expected.object.swap]

equivalent to: using std::swap; swap(val, rhs.val);
equivalent to: using std::swap; swap(unex, rhs.unex);

Table 72 — Containers library summary [tab:containers.summary]

🔗	Subclause	Header
🔗[container.requirements]	Requirements
🔗[sequences]	Sequence containers	<array>, <deque>, <forward_list>,<hive>,
🔗	<inplace_vector>, <list>, <vector>
🔗[associative]	Associative containers	<map>, <set>
🔗[unord]	Unordered associative containers	<unordered_map>, <unordered_set>
🔗[container.adaptors]	Container adaptors	<queue>, <stack>, <flat_map>, <flat_set>
🔗[views]	Views	<span>, <mdspan>

Table 73 — Container types with compatible nodes [tab:container.node.compat]

🔗map<K, T, C1, A>	map<K, T, C2, A>
🔗map<K, T, C1, A>	multimap<K, T, C2, A>
🔗set<K, C1, A>	set<K, C2, A>
🔗set<K, C1, A>	multiset<K, C2, A>
🔗unordered_map<K, T, H1, E1, A>	unordered_map<K, T, H2, E2, A>
🔗unordered_map<K, T, H1, E1, A>	unordered_multimap<K, T, H2, E2, A>
🔗unordered_set<K, H1, E1, A>	unordered_set<K, H2, E2, A>
🔗unordered_set<K, H1, E1, A>	unordered_multiset<K, H2, E2, A>

Table 75 — Relations among iterator categories [tab:iterators.relations]

🔗Contiguous	→ Random Access	→ Bidirectional	→ Forward	→ Input
🔗	→ Output

Table 76 — Cpp17Iterator requirements [tab:iterator]

🔗Expression	Return type	Operational
🔗	semantics	pre-/post-condition
🔗*r	unspecified	Preconditions: r is dereferenceable.
🔗++r	X&

Table 77 — Cpp17InputIterator requirements (in addition to Cpp17Iterator) [tab:inputiterator]

🔗Expression	Return type	Operational	Assertion/note
🔗	semantics	pre-/post-condition
🔗a != b	decltype(a != b) models boolean-testable	!(a == b)	Preconditions: (a, b) is in the domain of ==.
🔗*a	reference, convertible to T	Preconditions: a is dereferenceable. The expression(void)a, a is equivalent to a. If a == b and (a, b) is in the domain of == then a is equivalent to *b.
🔗a->m	(*a).m	Preconditions: a is dereferenceable.
🔗++r	X&	Preconditions: r is dereferenceable. Postconditions: r is dereferenceable or r is past-the-end;any copies of the previous value of r are no longer required to be dereferenceable nor to be in the domain of ==.
🔗(void)r++	equivalent to (void)++r
🔗*r++	convertible to T	{ T tmp = *r;++r;return tmp; }

Table 78 — Cpp17OutputIterator requirements (in addition to Cpp17Iterator) [tab:outputiterator]

🔗Expression	Return type	Operational	Assertion/note
🔗	semantics	pre-/post-condition
🔗*r = o	result is not used	Remarks: After this operation r is not required to be dereferenceable. Postconditions: r is incrementable.
🔗++r	X&	addressof(r) == addressof(++r). Remarks: After this operation r is not required to be dereferenceable. Postconditions: r is incrementable.
🔗r++	convertible to const X&	{ X tmp = r; ++r; return tmp; }	Remarks: After this operation r is not required to be dereferenceable. Postconditions: r is incrementable.
🔗*r++ = o	result is not used	Remarks: After this operation r is not required to be dereferenceable. Postconditions: r is incrementable.

Table 79 — Cpp17ForwardIterator requirements (in addition to Cpp17InputIterator) [tab:forwarditerator]

🔗Expression	Return type	Operational
🔗	semantics	pre-/post-condition
🔗r++	convertible to const X&	{ X tmp = r; ++r; return tmp; }
🔗*r++	reference

Table 80 — Cpp17BidirectionalIterator requirements (in addition to Cpp17ForwardIterator) [tab:bidirectionaliterator]

🔗Expression	Return type	Operational
🔗	semantics	pre-/post-condition
🔗--r	X&	Preconditions: there exists s such that r == ++s. Postconditions: r is dereferenceable. --(++r) == r. --r == --s implies r == s. addressof(r) == addressof(--r).
🔗r--	convertible to const X&	{ X tmp = r; --r; return tmp; }
🔗*r--	reference

Table 81 — Cpp17RandomAccessIterator requirements (in addition to Cpp17BidirectionalIterator) [tab:randomaccessiterator]

🔗Expression	Return type	Operational	Assertion/note
🔗	semantics	pre-/post-condition
🔗r += n	X&	{ difference_type m = n; if (m >= 0) while (m--) ++r; else while (m++) --r; return r; }
🔗a + nn + a	X	{ X tmp = a; return tmp += n; }	a + n == n + a.
🔗r -= n	X&	return r += -n;	Preconditions: the absolute value of n is in the range of representable values of difference_type.
🔗a - n	X	{ X tmp = a; return tmp -= n; }
🔗b - a	difference_type	return n;	Preconditions: there exists a value n of type difference_type such that a + n == b. b == a + (b - a).
🔗a[n]	convertible to reference	*(a + n)
🔗a < b	decltype(a < b) models boolean-testable	Effects: Equivalent to: return b - a > 0;	< is a total ordering relation
🔗a > b	decltype(a > b) models boolean-testable	b < a	> is a total ordering relation opposite to <.
🔗a >= b	decltype(a >= b) models boolean-testable	!(a < b)
🔗a <= b	decltype(a <= b) models boolean-testable	!(a > b)

Table 85 — Character traits requirements [tab:char.traits.req]

🔗Expression	Return type	Assertion/note	Complexity
🔗	pre-/post-condition
🔗X::char_type	C
🔗X::int_type	(described in [char.traits.typedefs])
🔗X::off_type	(described in [iostreams.limits.pos] and [iostream.forward])
🔗X::pos_type	(described in [iostreams.limits.pos] and [iostream.forward])
🔗X::state_type	(described in [char.traits.typedefs])
🔗X::eq(c,d)	bool	Returns: whether c is to be treated as equal to d.	constant
🔗X::lt(c,d)	bool	Returns: whether c is to be treated as less than d.	constant
🔗X::compare(p,q,n)	int	Returns: 0 if for each i in [0, n), X::eq(p[i],q[i])is true; else, a negative value if, for some j in [0, n),X::lt(p[j],q[j]) is true and for each i in [0, j)X::eq(p[i],q[i]) is true; else a positive value.	linear
🔗X::length(p)	size_t	Returns: the smallest i such that X::eq(p[i],charT()) is true.	linear
🔗X::find(p,n,c)	const X::char_type*	Returns: the smallest q in [p, p+n) such thatX::eq(*q,c) is true, nullptr otherwise.	linear
🔗X::move(s,p,n)	X::char_type*	for each i in [0, n), performs X::assign(s[i],p[i]). Copies correctly even where the ranges [p, p+n) and [s, s+n) overlap. Returns: s.	linear
🔗X::copy(s,p,n)	X::char_type*	Preconditions: The ranges [p, p+n) and [s, s+n) do not overlap. Returns: s. for each i in [0, n), performs X::assign(s[i],p[i]).	linear
🔗X::assign(r,d)	(not used)	assigns r=d.	constant
🔗X::assign(s,n,c)	X::char_type*	for each i in [0, n), performsX::assign(s[i],c). Returns: s.	linear
🔗X::not_eof(e)	int_type	Returns: e if X::eq_int_type(e,X::eof()) is false, otherwise a value f such thatX::eq_int_type(f,X::eof()) is false.	constant
🔗X::to_char_type(e)	X::char_type	Returns: if for some c, X::eq_int_type(e,X::to_int_type(c))is true, c; else some unspecified value.	constant
🔗X::to_int_type(c)	X::int_type	Returns: some value e, constrained by the definitions ofto_char_type and eq_int_type.	constant
🔗X::eq_int_type(e,f)	bool	Returns: for all c and d, X::eq(c,d) is equal toX::eq_int_type(X::to_int_type(c), X::to_int_type(d)); otherwise, yields trueif e and f are both copies of X::eof(); otherwise, yields false if one of e and f is a copy of X::eof() and the other is not; otherwise the value is unspecified.	constant
🔗X::eof()	X::int_type	Returns: a value e such that X::eq_int_type(e,X::to_int_type(c))is false for all values c.	constant

Table 87 — Text library summary [tab:text.summary]

🔗	Subclause	Header
🔗[charconv]	Primitive numeric conversions	<charconv>
🔗[localization]	Localization library	<locale>, <clocale>
🔗[format]	Formatting	<format>
🔗[text.encoding]	Text encodings identification	<text_encoding>
🔗[re]	Regular expressions library	<regex>
🔗[text.c.strings]	Null-terminated sequence utilities	<cctype>, <cstdlib>, <cuchar>, <cwchar>, <cwctype>

Table 89 — Locale category facets [tab:locale.category.facets]

🔗Category	Includes facets
🔗collate	collate<char>, collate<wchar_t>
🔗ctype	ctype<char>, ctype<wchar_t>
🔗	codecvt<char, char, mbstate_t>
🔗	codecvt<wchar_t, char, mbstate_t>
🔗monetary	moneypunct<char>, moneypunct<wchar_t>
🔗	moneypunct<char, true>, moneypunct<wchar_t, true>
🔗	money_get<char>, money_get<wchar_t>
🔗	money_put<char>, money_put<wchar_t>
🔗numeric	numpunct<char>, numpunct<wchar_t>
🔗	num_get<char>, num_get<wchar_t>
🔗	num_put<char>, num_put<wchar_t>
🔗time	time_get<char>, time_get<wchar_t>
🔗	time_put<char>, time_put<wchar_t>
🔗messages	messages<char>, messages<wchar_t>

Table 90 — Required specializations [tab:locale.spec]

🔗Category	Includes facets
🔗collate	collate_byname<char>, collate_byname<wchar_t>
🔗ctype	ctype_byname<char>, ctype_byname<wchar_t>
🔗	codecvt_byname<char, char, mbstate_t>
🔗	codecvt_byname<wchar_t, char, mbstate_t>
🔗monetary	moneypunct_byname<char, International>
🔗	moneypunct_byname<wchar_t, International>
🔗	money_get<C, InputIterator>
🔗	money_put<C, OutputIterator>
🔗numeric	numpunct_byname<char>, numpunct_byname<wchar_t>
🔗	num_get<C, InputIterator>, num_put<C, OutputIterator>
🔗time	time_get<char, InputIterator>
🔗	time_get_byname<char, InputIterator>
🔗	time_get<wchar_t, InputIterator>
🔗	time_get_byname<wchar_t, InputIterator>
🔗	time_put<char, OutputIterator>
🔗	time_put_byname<char, OutputIterator>
🔗	time_put<wchar_t, OutputIterator>
🔗	time_put_byname<wchar_t, OutputIterator>
🔗messages	messages_byname<char>, messages_byname<wchar_t>

Table 91 — do_in/do_out result values [tab:locale.codecvt.inout]

not all source characters converted
encountered a character in [from, from_end) that cannot be converted
internT and externT are the same type, and input sequence is identical to converted sequence

Table 92 — do_unshift result values [tab:locale.codecvt.unshift]

space for more than to_end - to destination elements was needed to terminate a sequence given the value of state
an unspecified error has occurred
no termination is needed for this state_type

Table 93 — Integer conversions [tab:facet.num.get.int]

🔗State	stdio equivalent
🔗basefield == oct	%o
🔗basefield == hex	%X
🔗basefield == 0	%i
🔗signed integral type	%d
🔗unsigned integral type	%u

Table 94 — Length modifier [tab:facet.num.get.length]

🔗Type	Length modifier
🔗short	h
🔗unsigned short	h
🔗long	l
🔗unsigned long	l
🔗long long	ll
🔗unsigned long long	ll
🔗double	l
🔗long double	L

Table 95 — Integer conversions [tab:facet.num.put.int]

🔗State	stdio equivalent
🔗basefield == ios_base::oct	%o
🔗(basefield == ios_base::hex) && !uppercase	%x
🔗(basefield == ios_base::hex)	%X
🔗for a signed integral type	%d
🔗for an unsigned integral type	%u

Table 96 — Floating-point conversions [tab:facet.num.put.fp]

🔗State	stdio equivalent
🔗floatfield == ios_base::fixed && !uppercase	%f
🔗floatfield == ios_base::fixed	%F
🔗floatfield == ios_base::scientific && !uppercase	%e
🔗floatfield == ios_base::scientific	%E
🔗floatfield == (ios_base::fixed \| ios_base::scientific) && !uppercase	%a
🔗floatfield == (ios_base::fixed \| ios_base::scientific)	%A
🔗!uppercase	%g
🔗otherwise	%G

Table 97 — Length modifier [tab:facet.num.put.length]

🔗Type	Length modifier
🔗long	l
🔗long long	ll
🔗unsigned long	l
🔗unsigned long long	ll
🔗long double	L
🔗otherwise	none

Table 98 — Numeric conversions [tab:facet.num.put.conv]

🔗Type(s)	State	stdio equivalent
🔗an integral type	showpos	+
🔗	showbase	#
🔗a floating-point type	showpos	+
🔗	showpoint	#

Table 99 — Fill padding [tab:facet.num.put.fill]

🔗State	Location
🔗adjustfield == ios_base::left	pad after
🔗adjustfield == ios_base::right	pad before
🔗adjustfield == internal and a sign occurs in the representation	pad after the sign
🔗adjustfield == internal and representation after stage 1 began with 0x or 0X	pad after x or X
🔗otherwise	pad before

Table 101 — Potential setlocale data races [tab:setlocale.data.races]

🔗fprintf	isprint	iswdigit	localeconv	tolower
🔗fscanf	ispunct	iswgraph	mblen	toupper
🔗isalnum	isspace	iswlower	mbstowcs	towlower
🔗isalpha	isupper	iswprint	mbtowc	towupper
🔗isblank	iswalnum	iswpunct	setlocale	wcscoll
🔗iscntrl	iswalpha	iswspace	strcoll	wcstod
🔗isdigit	iswblank	iswupper	strerror	wcstombs
🔗isgraph	iswcntrl	iswxdigit	strtod	wcsxfrm
🔗islower	iswctype	isxdigit	strxfrm	wctomb

Table 102 — Meaning of align options [tab:format.align]

Forces the formatted argument to be aligned to the start of the field by inserting n fill characters after the formatted argument where n is the padding width. This is the default for non-arithmetic non-pointer types, charT, and bool, unless an integer presentation type is specified.
Forces the formatted argument to be aligned to the end of the field by inserting n fill characters before the formatted argument where n is the padding width. This is the default for arithmetic types other than charT and bool, pointer types, or when an integer presentation type is specified.
Forces the formatted argument to be centered within the field by insertingfill characters before andfill characters after the formatted argument, wheren is the padding width.

Table 103 — Meaning of sign options [tab:format.sign]

Indicates that a sign should be used for both non-negative and negative numbers. The + sign is inserted before the output of to_chars for non-negative numbers other than negative zero. [Note 5: For negative numbers and negative zero the output of to_chars will already contain the sign so no additional transformation is performed. — _end note_]
Indicates that a sign should be used for negative numbers and negative zero only (this is the default behavior).
Indicates that a leading space should be used for non-negative numbers other than negative zero, and a minus sign for negative numbers and negative zero.

Table 105 — Meaning of type options for integer types [tab:format.type.int]

🔗Type	Meaning
🔗b	to_chars(first, last, value, 2);the base prefix is 0b.
🔗B	The same as b, except thatthe base prefix is 0B.
🔗c	Copies the character static_cast<charT>(value) to the output. Throws format_error if value is not in the range of representable values for charT.
🔗d	to_chars(first, last, value).
🔗o	to_chars(first, last, value, 8);the base prefix is 0 if value is nonzero and is empty otherwise.
🔗x	to_chars(first, last, value, 16);the base prefix is 0x.
🔗X	The same as x, except that it uses uppercase letters for digits above 9 andthe base prefix is 0X.
🔗none	The same as d. [Note 8: If the formatting argument type is charT or bool, the default is instead c or s, respectively. — _end note_]

Table 106 — Meaning of type options for charT [tab:format.type.char]

Copies the character to the output.
As specified in Table 105with value converted to the unsigned version of the underlying type.

Table 107 — Meaning of type options for bool [tab:format.type.bool]

Copies textual representation, either true or false, to the output.
As specified in Table 105for the valuestatic_cast<unsigned char>(value).

Table 108 — Meaning of type options for floating-point types [tab:format.type.float]

🔗Type	Meaning
🔗a	If precision is specified, equivalent toto_chars(first, last, value, chars_format::hex, precision) where precision is the specified formatting precision; equivalent toto_chars(first, last, value, chars_format::hex) otherwise.
🔗A	The same as a, except that it uses uppercase letters for digits above 9 andP to indicate the exponent.
🔗e	Equivalent toto_chars(first, last, value, chars_format::scientific, precision) where precision is the specified formatting precision, or 6 if precision is not specified.
🔗E	The same as e, except that it uses E to indicate exponent.
🔗f, F	Equivalent toto_chars(first, last, value, chars_format::fixed, precision) where precision is the specified formatting precision, or 6 if precision is not specified.
🔗g	Equivalent toto_chars(first, last, value, chars_format::general, precision) where precision is the specified formatting precision, or 6 if precision is not specified.
🔗G	The same as g, except that it uses E to indicate exponent.
🔗none	If precision is specified, equivalent toto_chars(first, last, value, chars_format::general, precision) where precision is the specified formatting precision; equivalent toto_chars(first, last, value) otherwise.

Table 109 — Meaning of type options for pointer types [tab:format.type.ptr]

If uintptr_t is defined,to_chars(first, last, reinterpret_cast<uintptr_t>(value), 16) with the prefix 0x inserted immediately before the output of to_chars; otherwise, implementation-defined.
The same as p, except that it uses uppercase letters for digits above 9 and the base prefix is 0X.

Table 110 — BasicFormatter requirements [tab:formatter.basic]

Parses format-spec ([format.string]) for type Tin the range [pc.begin(), pc.end()) until the first unmatched character. Throws format_error unless the whole range is parsed or the unmatched character is }. [Note 1: This allows formatters to emit meaningful error messages. — _end note_] Stores the parsed format specifiers in *this and returns an iterator past the end of the parsed range.
Formats u according to the specifiers stored in *this, writes the output to fc.out(), and returns an iterator past the end of the output range. The output shall only depend onu,fc.locale(),fc.arg(n) for any value n of type size_t, and the range [pc.begin(), pc.end()) from the last call to f.parse(pc).

Table 111 — Formatter requirements [tab:formatter]

Formats t according to the specifiers stored in *this, writes the output to fc.out(), and returns an iterator past the end of the output range. The output shall only depend ont,fc.locale(),fc.arg(n) for any value n of type size_t, and the range [pc.begin(), pc.end()) from the last call to f.parse(pc).
As above, but does not modify u.

Table 112 — Mapping of characters to escape sequences [tab:format.escape.sequences]

🔗Character	Escape sequence
🔗U+0009 character tabulation	\t
🔗U+000a line feed	\n
🔗U+000d carriage return	\r
🔗U+0022 quotation mark	\"
🔗U+005c reverse solidus	\\

Table 113 — Meaning of range-type options [tab:formatter.range.type]

🔗Option	Requirements	Meaning
🔗m	T shall be either a specialization of pair or a specialization of tuplesuch that tuple_size_v<T> is 2.	Indicates that the opening bracket should be "{", the closing bracket should be "}", the separator should be ", ", and each range element should be formatted as ifm were specified for its tuple-type. [Note 2: If the n option is provided in addition to the m option, both the opening and closing brackets are still empty. — _end note_]
🔗s	T shall be charT.	Indicates that the range should be formatted as a string.
🔗?s	T shall be charT.	Indicates that the range should be formatted as an escaped string ([format.string.escaped]).

Table 114 — Meaning of tuple-type options [tab:formatter.tuple.type]

🔗Option	Requirements	Meaning
🔗m	sizeof...(Ts) == 2	Equivalent to:set_separator(STATICALLY-WIDEN<charT>(": ")); set_brackets({}, {});
🔗n	none	Equivalent to: set_brackets({}, {});
🔗none	none	No effects

Table 116 — syntax_option_type effects [tab:re.synopt]

🔗Element	Effect(s) if set
🔗icase	Specifies that matching of regular expressions against a character container sequence shall be performed without regard to case.
🔗nosubs	Specifies that no sub-expressions shall be considered to be marked, so that when a regular expression is matched against a character container sequence, no sub-expression matches shall be stored in the supplied match_results object.
🔗optimize	Specifies that the regular expression engine should pay more attention to the speed with which regular expressions are matched, and less to the speed with which regular expression objects are constructed. Otherwise it has no detectable effect on the program output.
🔗collate	Specifies that character ranges of the form "[a-b]" shall be locale sensitive.
🔗ECMAScript	Specifies that the grammar recognized by the regular expression engine shall be that used by ECMAScript in ECMA-262, as modified in [re.grammar]. See also: ECMA-262 15.10
🔗basic	Specifies that the grammar recognized by the regular expression engine shall be that used by basic regular expressions in POSIX.See also: POSIX, Base Definitions and Headers, Section 9.3
🔗extended	Specifies that the grammar recognized by the regular expression engine shall be that used by extended regular expressions in POSIX.See also: POSIX, Base Definitions and Headers, Section 9.4
🔗awk	Specifies that the grammar recognized by the regular expression engine shall be that used by the utility awk in POSIX.
🔗grep	Specifies that the grammar recognized by the regular expression engine shall be that used by the utility grep in POSIX.
🔗egrep	Specifies that the grammar recognized by the regular expression engine shall be that used by the utility grep when given the -E option in POSIX.
🔗multiline	Specifies that ^ shall match the beginning of a line and$ shall match the end of a line, if the ECMAScript engine is selected.

Table 117 — regex_constants::match_flag_type effects [tab:re.matchflag]

🔗Element	Effect(s) if set
🔗match_not_bol	The first character in the sequence [first, last) shall be treated as though it is not at the beginning of a line, so the character^ in the regular expression shall not match [first, first).
🔗match_not_eol	The last character in the sequence [first, last) shall be treated as though it is not at the end of a line, so the character"$" in the regular expression shall not match [last, last).
🔗match_not_bow	The expression "\\b" shall not match the sub-sequence [first, first).
🔗match_not_eow	The expression "\\b" shall not match the sub-sequence [last, last).
🔗match_any	If more than one match is possible then any match is an acceptable result.
🔗match_not_null	The expression shall not match an empty sequence.
🔗match_continuous	The expression shall only match a sub-sequence that begins atfirst.
🔗match_prev_avail	--first is a valid iterator position. When this flag is set the flags match_not_bol and match_not_bow shall be ignored by the regular expression algorithms ([re.alg]) and iterators ([re.iter]).
🔗format_default	When a regular expression match is to be replaced by a new string, the new string shall be constructed using the rules used by the ECMAScript replace function in ECMA-262, part 15.5.4.11 String.prototype.replace. In addition, during search and replace operations all non-overlapping occurrences of the regular expression shall be located and replaced, and sections of the input that did not match the expression shall be copied unchanged to the output string.
🔗format_sed	When a regular expression match is to be replaced by a new string, the new string shall be constructed using the rules used by the sed utility in POSIX.
🔗format_no_copy	During a search and replace operation, sections of the character container sequence being searched that do not match the regular expression shall not be copied to the output string.
🔗format_first_only	When specified during a search and replace operation, only the first occurrence of the regular expression shall be replaced.

Table 118 — error_type values in the C locale [tab:re.err]

🔗Value	Error condition
🔗error_collate	The expression contains an invalid collating element name.
🔗error_ctype	The expression contains an invalid character class name.
🔗error_escape	The expression contains an invalid escaped character, or a trailing escape.
🔗error_backref	The expression contains an invalid back reference.
🔗error_brack	The expression contains mismatched [ and ].
🔗error_paren	The expression contains mismatched ( and ).
🔗error_brace	The expression contains mismatched { and }.
🔗error_badbrace	The expression contains an invalid range in a {} expression.
🔗error_range	The expression contains an invalid character range, such as[b-a] in most encodings.
🔗error_space	There is insufficient memory to convert the expression into a finite state machine.
🔗error_badrepeat	One of *?+{ is not preceded by a valid regular expression.
🔗error_complexity	The complexity of an attempted match against a regular expression exceeds a pre-set level.
🔗error_stack	There is insufficient memory to determine whether the regular expression matches the specified character sequence.

Table 119 — Character class names and corresponding ctype masks [tab:re.traits.classnames]

🔗Narrow character name	Wide character name	Corresponding ctype_base::mask value
🔗"alnum"	L"alnum"	ctype_base::alnum
🔗"alpha"	L"alpha"	ctype_base::alpha
🔗"blank"	L"blank"	ctype_base::blank
🔗"cntrl"	L"cntrl"	ctype_base::cntrl
🔗"digit"	L"digit"	ctype_base::digit
🔗"d"	L"d"	ctype_base::digit
🔗"graph"	L"graph"	ctype_base::graph
🔗"lower"	L"lower"	ctype_base::lower
🔗"print"	L"print"	ctype_base::print
🔗"punct"	L"punct"	ctype_base::punct
🔗"space"	L"space"	ctype_base::space
🔗"s"	L"s"	ctype_base::space
🔗"upper"	L"upper"	ctype_base::upper
🔗"w"	L"w"	ctype_base::alnum
🔗"xdigit"	L"xdigit"	ctype_base::xdigit

Table 120 — match_results copy/move operation postconditions [tab:re.results.const]

🔗Element	Value
🔗ready()	m.ready()
🔗size()	m.size()
🔗str(n)	m.str(n) for all non-negative integers n < m.size()
🔗prefix()	m.prefix()
🔗suffix()	m.suffix()
🔗(*this)[n]	m[n] for all non-negative integers n < m.size()
🔗length(n)	m.length(n) for all non-negative integers n < m.size()
🔗position(n)	m.position(n) for all non-negative integers n < m.size()

Table 121 — Effects of regex_match algorithm [tab:re.alg.match]

🔗Element	Value
🔗m.size()	1 + e.mark_count()
🔗m.empty()	false
🔗m.prefix().first	first
🔗m.prefix().second	first
🔗m.prefix().matched	false
🔗m.suffix().first	last
🔗m.suffix().second	last
🔗m.suffix().matched	false
🔗m[0].first	first
🔗m[0].second	last
🔗m[0].matched	true
🔗m[n].first	For all integers 0 < n < m.size(), the start of the sequence that matched sub-expression n. Alternatively, if sub-expression n did not participate in the match, then last.
🔗m[n].second	For all integers 0 < n < m.size(), the end of the sequence that matched sub-expression n. Alternatively, if sub-expression n did not participate in the match, then last.
🔗m[n].matched	For all integers 0 < n < m.size(), true if sub-expression n participated in the match, false otherwise.

Table 122 — Effects of regex_search algorithm [tab:re.alg.search]

🔗Element	Value
🔗m.size()	1 + e.mark_count()
🔗m.empty()	false
🔗m.prefix().first	first
🔗m.prefix().second	m[0].first
🔗m.prefix().matched	m.prefix().first != m.prefix().second
🔗m.suffix().first	m[0].second
🔗m.suffix().second	last
🔗m.suffix().matched	m.suffix().first != m.suffix().second
🔗m[0].first	The start of the sequence of characters that matched the regular expression
🔗m[0].second	The end of the sequence of characters that matched the regular expression
🔗m[0].matched	true
🔗m[n].first	For all integers 0 < n < m.size(), the start of the sequence that matched sub-expression n. Alternatively, if sub-expression ndid not participate in the match, then last.
🔗m[n].second	For all integers 0 < n < m.size(), the end of the sequence that matched sub-expression n. Alternatively, if sub-expression n did not participate in the match, then last.
🔗m[n].matched	For all integers 0 < n < m.size(), true if sub-expression nparticipated in the match, false otherwise.

Table 124 — Seed sequence requirements [tab:rand.req.seedseq]

🔗Expression	Return type	Pre/post-condition	Complexity
🔗S::result_type	T	T is an unsigned integer type of at least 32 bits.
🔗S()	Creates a seed sequence with the same initial state as all other default-constructed seed sequences of type S.	constant
🔗S(ib,ie)	Creates a seed sequence having internal state that depends on some or all of the bits of the supplied sequence [ib,ie).
🔗S(il)	Same as S(il.begin(), il.end()).	same as S(il.begin(), il.end())
🔗q.generate(rb,re)	void	Does nothing if rb == re. Otherwise, fills the supplied sequence [rb,re) with 32-bit quantities that depend on the sequence supplied to the constructor and possibly also depend on the history of generate's previous invocations.
🔗r.size()	size_t	The number of 32-bit units that would be copied by a call to r.param.	constant
🔗r.param(ob)	void	Copies to the given destination a sequence of 32-bit units that can be provided to the constructor of a second object of type S, and that would reproduce in that second object a state indistinguishable from the state of the first object.

Table 125 — Random number engine requirements [tab:rand.req.eng]

🔗Expression	Return type	Pre/post-condition	Complexity
🔗E()	Creates an engine with the same initial state as all other default-constructed engines of type E.
🔗E(x)	Creates an engine that compares equal to x.
🔗E(s)	Creates an engine with initial state determined by s.
🔗E(q)241	Creates an engine with an initial state that depends on a sequence produced by one call to q.generate.	same as complexity of q.generate called on a sequence whose length is size of state
🔗e.seed()	void	Postconditions: e == E().	same as E()
🔗e.seed(s)	void	Postconditions: e == E(s).	same as E(s)
🔗e.seed(q)	void	Postconditions: e == E(q).	same as E(q)
🔗e()	T	Advances e's state e toe e) and returnsGA(e).	per [rand.req.urng]
🔗e.discard(z)242	void	Advances e's state e to by any means equivalent to z consecutive calls e().	no worse than the complexity of z consecutive calls e()
🔗x == y	bool	This operator is an equivalence relation. With and as the infinite sequences of values that would be generated by repeated future calls to x() and y(), respectively, returns true if ; else returns false.
🔗x != y	bool	!(x == y).

Table 126 — Random number distribution requirements [tab:rand.req.dist]

🔗Expression	Return type	Pre/post-condition	Complexity
🔗D::result_type	T	T is an arithmetic type .
🔗D::param_type	P
🔗D()	Creates a distribution whose behavior is indistinguishable from that of any other newly default-constructed distribution of type D.	constant
🔗D(p)	Creates a distribution whose behavior is indistinguishable from that of a distribution newly constructed directly from the values used to construct p.	same as p's construction
🔗d.reset()	void	Subsequent uses of d do not depend on values produced by any engine prior to invoking reset.	constant
🔗x.param()	P	Returns a valuep such that D(p).param() == p.	no worse than the complexity of D(p)
🔗d.param(p)	void	Postconditions: d.param() == p.	no worse than the complexity of D(p)
🔗d(g)	T	With , the sequence of numbers returned by successive invocations with the same object g is randomly distributed according to the associatedp(z \|{p}) or function.	amortized constant number of invocations of g
🔗d(g,p)	T	The sequence of numbers returned by successive invocations with the same objects g and p is randomly distributed according to the associatedp(z \|{p}) or function.	amortized constant number of invocations of g
🔗x.min()	T	Returns glb.	constant
🔗x.max()	T	Returns lub.	constant
🔗x == y	bool	This operator is an equivalence relation. Returns true if x.param() == y.param() and , where and are the infinite sequences of values that would be generated, respectively, by repeated future calls to x(g1) and y(g2) whenever g1 == g2. Otherwise returns false.	constant
🔗x != y	bool	!(x == y).	same as x == y.

Table 129 — Cpp17Clock requirements [tab:time.clock]

🔗Expression	Return type	Operational semantics
🔗C1::rep	An arithmetic type or a class emulating an arithmetic type	The representation type of C1::duration.
🔗C1::period	a specialization of ratio	The tick period of the clock in seconds.
🔗C1::duration	chrono::duration<C1::rep, C1::period>	The duration type of the clock.
🔗C1::time_point	chrono::time_point<C1> or chrono::time_point<C2, C1::duration>	The time_point type of the clock. C1 and C2 shall refer to the same epoch.
🔗C1::is_steady	const bool	true if t1 <= t2 is always true and the time between clock ticks is constant, otherwise false.
🔗C1::now()	C1::time_point	Returns a time_point object representing the current point in time.

Table 130 — Examples for fractional_width [tab:time.hms.width]

🔗Duration	fractional_width	Formatted fractional second output
🔗hours, minutes, and seconds	0
🔗milliseconds	3	0.001
🔗microseconds	6	0.000001
🔗nanoseconds	9	0.000000001
🔗duration<int, ratio<1, 2>>	1	0.5
🔗duration<int, ratio<1, 3>>	6	0.333333
🔗duration<int, ratio<1, 4>>	2	0.25
🔗duration<int, ratio<1, 5>>	1	0.2
🔗duration<int, ratio<1, 6>>	6	0.166666
🔗duration<int, ratio<1, 7>>	6	0.142857
🔗duration<int, ratio<1, 8>>	3	0.125
🔗duration<int, ratio<1, 9>>	6	0.111111
🔗duration<int, ratio<1, 10>>	1	0.1
🔗duration<int, ratio<756, 625>>	4	0.2096

Table 131 — Meaning of conversion specifiers [tab:time.format.spec]

🔗Specifier	Replacement
🔗%a	The locale's abbreviated weekday name. If the value does not contain a valid weekday, an exception of type format_error is thrown.
🔗%A	The locale's full weekday name. If the value does not contain a valid weekday, an exception of type format_error is thrown.
🔗%b	The locale's abbreviated month name. If the value does not contain a valid month, an exception of type format_error is thrown.
🔗%B	The locale's full month name. If the value does not contain a valid month, an exception of type format_error is thrown.
🔗%c	The locale's date and time representation. The modified command %Ec produces the locale's alternate date and time representation.
🔗%C	The year divided by 100 using floored division. If the result is a single decimal digit, it is prefixed with 0. The modified command %EC produces the locale's alternative representation of the century.
🔗%d	The day of month as a decimal number. If the result is a single decimal digit, it is prefixed with 0. The modified command %Od produces the locale's alternative representation.
🔗%D	Equivalent to %m/%d/%y.
🔗%e	The day of month as a decimal number. If the result is a single decimal digit, it is prefixed with a space. The modified command %Oe produces the locale's alternative representation.
🔗%F	Equivalent to %Y-%m-%d.
🔗%g	The last two decimal digits of the calendar year as specified in ISO 8601-1:2019 for the week calendar. If the result is a single digit it is prefixed by 0.
🔗%G	The calendar year as a decimal number, as specified in ISO 8601-1:2019 for the week calendar. If the result is less than four digits it is left-padded with 0 to four digits.
🔗%h	Equivalent to %b.
🔗%H	The hour (24-hour clock) as a decimal number. If the result is a single digit, it is prefixed with 0. The modified command %OH produces the locale's alternative representation.
🔗%I	The hour (12-hour clock) as a decimal number. If the result is a single digit, it is prefixed with 0. The modified command %OI produces the locale's alternative representation.
🔗%j	If the type being formatted is a specialization of duration, the decimal number of days without padding. Otherwise, the day of the year as a decimal number. January 1 is 001. If the result is less than three digits, it is left-padded with 0 to three digits.
🔗%m	The month as a decimal number. Jan is 01. If the result is a single digit, it is prefixed with 0. The modified command %Om produces the locale's alternative representation.
🔗%M	The minute as a decimal number. If the result is a single digit, it is prefixed with 0. The modified command %OM produces the locale's alternative representation.
🔗%n	A new-line character.
🔗%p	The locale's equivalent of the AM/PM designations associated with a 12-hour clock.
🔗%q	The duration's unit suffix as specified in [time.duration.io].
🔗%Q	The duration's numeric value (as if extracted via .count()).
🔗%r	The locale's 12-hour clock time.
🔗%R	Equivalent to %H:%M.
🔗%S	Seconds as a decimal number. If the number of seconds is less than 10, the result is prefixed with 0. If the precision of the input cannot be exactly represented with seconds, then the format is a decimal floating-point number with a fixed format and a precision matching that of the precision of the input (or to a microseconds precision if the conversion to floating-point decimal seconds cannot be made within 18 fractional digits). The character for the decimal point is localized according to the locale. The modified command %OS produces the locale's alternative representation.
🔗%t	A horizontal-tab character.
🔗%T	Equivalent to %H:%M:%S.
🔗%u	The calendar day of week as a decimal number (1-7), as specified in ISO 8601-1:2019, where Monday is 1. The modified command %Ou produces the locale's alternative representation.
🔗%U	The week number of the year as a decimal number. The first Sunday of the year is the first day of week 01. Days of the same year prior to that are in week 00. If the result is a single digit, it is prefixed with 0. The modified command %OU produces the locale's alternative representation.
🔗%V	The calendar week of year as a decimal number, as specified in ISO 8601-1:2019 for the week calendar. If the result is a single digit, it is prefixed with 0. The modified command %OV produces the locale's alternative representation.
🔗%w	The weekday as a decimal number (0-6), where Sunday is 0. The modified command %Ow produces the locale's alternative representation.
🔗%W	The week number of the year as a decimal number. The first Monday of the year is the first day of week 01. Days of the same year prior to that are in week 00. If the result is a single digit, it is prefixed with 0. The modified command %OW produces the locale's alternative representation.
🔗%x	The locale's date representation. The modified command %Ex produces the locale's alternate date representation.
🔗%X	The locale's time representation. The modified command %EX produces the locale's alternate time representation.
🔗%y	The last two decimal digits of the year. If the result is a single digit it is prefixed by 0. The modified command %Oy produces the locale's alternative representation. The modified command %Ey produces the locale's alternative representation of offset from %EC (year only).
🔗%Y	The year as a decimal number. If the result is less than four digits it is left-padded with 0 to four digits. The modified command %EY produces the locale's alternative full year representation.
🔗%z	The offset from UTC as specified in ISO 8601-1:2019, 5.3.4.1. For example -0430 refers to 4 hours 30 minutes behind UTC. If the offset is zero, +0000 is used. The modified commands %Ez and %Ozinsert a : between the hours and minutes: -04:30. If the offset information is not available, an exception of type format_error is thrown.
🔗%Z	The time zone abbreviation. If the time zone abbreviation is not available, an exception of type format_error is thrown.
🔗%%	A % character.

Table 132 — Meaning of parse flags [tab:time.parse.spec]

🔗Flag	Parsed value
🔗%a	The locale's full or abbreviated case-insensitive weekday name.
🔗%A	Equivalent to %a.
🔗%b	The locale's full or abbreviated case-insensitive month name.
🔗%B	Equivalent to %b.
🔗%c	The locale's date and time representation. The modified command %Ec interprets the locale's alternate date and time representation.
🔗%C	The century as a decimal number. The modified command %_N_C specifies the maximum number of characters to read. If N is not specified, the default is 2. Leading zeroes are permitted but not required. The modified command %EC interprets the locale's alternative representation of the century.
🔗%d	The day of the month as a decimal number. The modified command %_N_d specifies the maximum number of characters to read. If N is not specified, the default is 2. Leading zeroes are permitted but not required. The modified command %Od interprets the locale's alternative representation of the day of the month.
🔗%D	Equivalent to %m/%d/%y.
🔗%e	Equivalent to %d and can be modified like %d.
🔗%F	Equivalent to %Y-%m-%d. If modified with a width N, the width is applied to only %Y.
🔗%g	The last two decimal digits of the calendar year, as specified in ISO 8601-1:2019 for the week calendar. The modified command %_N_g specifies the maximum number of characters to read. If N is not specified, the default is 2. Leading zeroes are permitted but not required.
🔗%G	The calendar year as a decimal number, as specified in ISO 8601-1:2019 for the week calendar. The modified command %_N_G specifies the maximum number of characters to read. If N is not specified, the default is 4. Leading zeroes are permitted but not required.
🔗%h	Equivalent to %b.
🔗%H	The hour (24-hour clock) as a decimal number. The modified command %_N_H specifies the maximum number of characters to read. If N is not specified, the default is 2. Leading zeroes are permitted but not required. The modified command %OH interprets the locale's alternative representation.
🔗%I	The hour (12-hour clock) as a decimal number. The modified command %_N_I specifies the maximum number of characters to read. If N is not specified, the default is 2. Leading zeroes are permitted but not required. The modified command %OIinterprets the locale's alternative representation.
🔗%j	If the type being parsed is a specialization of duration, a decimal number of days. Otherwise, the day of the year as a decimal number. January 1 is 1. In either case, the modified command %_N_j specifies the maximum number of characters to read. If N is not specified, the default is 3. Leading zeroes are permitted but not required.
🔗%m	The month as a decimal number. January is 1. The modified command %_N_m specifies the maximum number of characters to read. If N is not specified, the default is 2. Leading zeroes are permitted but not required. The modified command %Om interprets the locale's alternative representation.
🔗%M	The minutes as a decimal number. The modified command %_N_M specifies the maximum number of characters to read. If N is not specified, the default is 2. Leading zeroes are permitted but not required. The modified command %OM interprets the locale's alternative representation.
🔗%n	Matches one whitespace character. [Note 1: %n, %t, and a space can be combined to match a wide range of whitespace patterns. For example,"%n " matches one or more whitespace characters, and"%n%t%t" matches one to three whitespace characters. — _end note_]
🔗%p	The locale's equivalent of the AM/PM designations associated with a 12-hour clock.
🔗%r	The locale's 12-hour clock time.
🔗%R	Equivalent to %H:%M.
🔗%S	The seconds as a decimal number. The modified command %_N_S specifies the maximum number of characters to read. If N is not specified, the default is 2 if the input time has a precision convertible to seconds. Otherwise the default width is determined by the decimal precision of the input and the field is interpreted as a long double in a fixed format. If encountered, the locale determines the decimal point character. Leading zeroes are permitted but not required. The modified command %OS interprets the locale's alternative representation.
🔗%t	Matches zero or one whitespace characters.
🔗%T	Equivalent to %H:%M:%S.
🔗%u	The calendar day of week as a decimal number (1-7), as specified in ISO 8601-1:2019, where Monday is 1. The modified command %_N_u specifies the maximum number of characters to read. If N is not specified, the default is 1. Leading zeroes are permitted but not required.
🔗%U	The week number of the year as a decimal number. The first Sunday of the year is the first day of week 01. Days of the same year prior to that are in week 00. The modified command %_N_U specifies the maximum number of characters to read. If N is not specified, the default is 2. Leading zeroes are permitted but not required. The modified command %OU interprets the locale's alternative representation.
🔗%V	The calendar week of year as a decimal number, as specified in ISO 8601-1:2019 for the week calendar. The modified command %_N_V specifies the maximum number of characters to read. If N is not specified, the default is 2. Leading zeroes are permitted but not required.
🔗%w	The weekday as a decimal number (0-6), where Sunday is 0. The modified command %_N_w specifies the maximum number of characters to read. If N is not specified, the default is 1. Leading zeroes are permitted but not required. The modified command %Ow interprets the locale's alternative representation.
🔗%W	The week number of the year as a decimal number. The first Monday of the year is the first day of week 01. Days of the same year prior to that are in week 00. The modified command %_N_W specifies the maximum number of characters to read. If N is not specified, the default is 2. Leading zeroes are permitted but not required. The modified command %OW interprets the locale's alternative representation.
🔗%x	The locale's date representation. The modified command %Ex interprets the locale's alternate date representation.
🔗%X	The locale's time representation. The modified command %EX interprets the locale's alternate time representation.
🔗%y	The last two decimal digits of the year. If the century is not otherwise specified (e.g., with %C), values in the range [69, 99] are presumed to refer to the years 1969 to 1999, and values in the range [00, 68] are presumed to refer to the years 2000 to 2068. The modified command %_N_y specifies the maximum number of characters to read. If N is not specified, the default is 2. Leading zeroes are permitted but not required. The modified commands %Ey and %Oy interpret the locale's alternative representation.
🔗%Y	The year as a decimal number. The modified command %_N_Y specifies the maximum number of characters to read. If N is not specified, the default is 4. Leading zeroes are permitted but not required. The modified command %EY interprets the locale's alternative representation.
🔗%z	The offset from UTC in the format [+\|-]hh[mm]. For example -0430 refers to 4 hours 30 minutes behind UTC, and 04 refers to 4 hours ahead of UTC. The modified commands %Ez and %Ozparse a : between the hours and minutes and render leading zeroes on the hour field optional:[+
🔗%Z	The time zone abbreviation or name. A single word is parsed. This word can only contain characters from the basic character set ([lex.charset]) that are alphanumeric, or one of'_', '/', '-', or '+'.
🔗%%	A % character is extracted.

Table 134 — fmtflags effects [tab:ios.fmtflags]

🔗Element	Effect(s) if set
🔗boolalpha	insert and extract bool type in alphabetic format
🔗dec	converts integer input or generates integer output in decimal base
🔗fixed	generate floating-point output in fixed-point notation
🔗hex	converts integer input or generates integer output in hexadecimal base
🔗internal	adds fill characters at a designated internal point in certain generated output, or identical to right if no such point is designated
🔗left	adds fill characters on the right (final positions) of certain generated output
🔗oct	converts integer input or generates integer output in octal base
🔗right	adds fill characters on the left (initial positions) of certain generated output
🔗scientific	generates floating-point output in scientific notation
🔗showbase	generates a prefix indicating the numeric base of generated integer output
🔗showpoint	generates a decimal-point character unconditionally in generated floating-point output
🔗showpos	generates a + sign in non-negative generated numeric output
🔗skipws	skips leading whitespace before certain input operations
🔗unitbuf	flushes output after each output operation
🔗uppercase	replaces certain lowercase letters with their uppercase equivalents in generated output

Table 136 — iostate effects [tab:ios.iostate]

indicates a loss of integrity in an input or output sequence (such as an irrecoverable read error from a file);
indicates that an input operation reached the end of an input sequence;
indicates that an input operation failed to read the expected characters, or that an output operation failed to generate the desired characters.

Table 137 — openmode effects [tab:ios.openmode]

🔗Element	Effect(s) if set
🔗app	seek to end before each write
🔗ate	open and seek to end immediately after opening
🔗binary	perform input and output in binary mode (as opposed to text mode)
🔗in	open for input
🔗noreplace	open in exclusive mode
🔗out	open for output
🔗trunc	truncate an existing stream when opening

Table 138 — seekdir effects [tab:ios.seekdir]

request a seek (for subsequent input or output) relative to the beginning of the stream
request a seek relative to the current position within the sequence
request a seek relative to the current end of the sequence

Table 139 — Position type requirements [tab:fpos.operations]

🔗Expression	Return type	Operational	Assertion/note
🔗	semantics	pre-/post-condition
🔗P(o)	P	converts from offset	Effects: Value-initializes the state object.
🔗P p(o);P p = o;	Effects: Value-initializes the state object. Postconditions: p == P(o) is true.
🔗P()	P	P(0)
🔗P p;	P p(0);
🔗O(p)	streamoff	converts to offset	P(O(p)) == p
🔗p == q	bool	Remarks: For any two values o and o2, if p is obtained from o converted to P or from a copy of such P value and if q is obtained from o2 converted to P or from a copy of such P value, then p == q is true only if o == o2 is true.
🔗p != q	bool	!(p == q)
🔗p + o	P	+ offset	Remarks: With ql = p + o;, then: ql - o == p
🔗pl += o	P&	+= offset	Remarks: With ql = pl; before the +=, then:pl - o == ql
🔗p - o	P	- offset	Remarks: With ql = p - o;, then: ql + o == p
🔗pl -= o	P&	-= offset	Remarks: With ql = pl; before the -=, then:pl + o == ql
🔗o + p	convertible to P	p + o	P(o + p) == p + o
🔗p - q	streamoff	distance	p == q + (p - q)

Table 140 — basic_ios::init() effects [tab:basic.ios.cons]

🔗Element	Value
🔗rdbuf()	sb
🔗tie()	0
🔗rdstate()	goodbit if sb is not a null pointer, otherwise badbit.
🔗exceptions()	goodbit
🔗flags()	skipws \| dec
🔗width()	0
🔗precision()	6
🔗fill()	widen(' ')
🔗getloc()	a copy of the value returned by locale()
🔗iarray	a null pointer
🔗parray	a null pointer

Table 141 — basic_ios::copyfmt() effects [tab:basic.ios.copyfmt]

🔗Element	Value
🔗rdbuf()	unchanged
🔗tie()	rhs.tie()
🔗rdstate()	unchanged
🔗exceptions()	rhs.exceptions()
🔗flags()	rhs.flags()
🔗width()	rhs.width()
🔗precision()	rhs.precision()
🔗fill()	rhs.fill()
🔗getloc()	rhs.getloc()

Table 142 — seekoff positioning [tab:stringbuf.seekoff.pos]

ios_base::in is set in which	positions the input sequence
ios_base::out is set in which	positions the output sequence
both ios_base::in and ios_base::out are set in which and eitherway == ios_base::beg orway == ios_base::end	positions both the input and the output sequences
the positioning operation fails.

Table 143 — newoff values [tab:stringbuf.seekoff.newoff]

the next pointer minus the beginning pointer (xnext - xbeg).
the high mark pointer minus the beginning pointer (high_mark - xbeg).

Table 144 — File open modes [tab:filebuf.open.modes]

🔗ios_base flag combination	stdio equivalent
🔗binary	in	out	trunc	app	noreplace
🔗	+	"w"
🔗	+	+	"wx"
🔗	+	+	"w"
🔗	+	+	+	"wx"
🔗	+	+	"a"
🔗	+	"a"
🔗	+	"r"
🔗	+	+	"r+"
🔗	+	+	+	"w+"
🔗	+	+	+	+	"w+x"
🔗	+	+	+	"a+"
🔗	+	+	"a+"
🔗+	+	"wb"
🔗+	+	+	"wbx"
🔗+	+	+	"wb"
🔗+	+	+	+	"wbx"
🔗+	+	+	"ab"
🔗+	+	"ab"
🔗+	+	"rb"
🔗+	+	+	"r+b"
🔗+	+	+	+	"w+b"
🔗+	+	+	+	+	"w+bx"
🔗+	+	+	+	"a+b"
🔗+	+	+	"a+b"

Table 146 — Enum path::format [tab:fs.enum.path.format]

The native pathname format.
The generic pathname format.
The interpretation of the format of the character sequence isimplementation-defined. The implementation may inspect the content of the character sequence to determine the format.Recommended practice: For POSIX-based systems, native and generic formats are equivalent and the character sequence should always be interpreted in the same way.

Table 147 — Enum class file_type [tab:fs.enum.file.type]

🔗Constant	Meaning
🔗none	The type of the file has not been determined or an error occurred while trying to determine the type.
🔗not_found	Pseudo-type indicating the file was not found. [Note 1: The file not being found is not considered an error while determining the type of a file. — _end note_]
🔗regular	Regular file
🔗directory	Directory file
🔗symlink	Symbolic link file
🔗block	Block special file
🔗character	Character special file
🔗fifo	FIFO or pipe file
🔗socket	Socket file
🔗implementation-defined	Implementations that support file systems having file types in addition to the above file_type types shall supplyimplementation-definedfile_type constants to separately identify each of those additional file types
🔗unknown	The file exists but the type cannot be determined

Table 148 — Enum class copy_options [tab:fs.enum.copy.opts]

🔗Option group controlling copy_file function effects for existing target files
🔗Constant	Meaning
🔗none	(Default) Error; file already exists.
🔗skip_existing	Do not overwrite existing file, do not report an error.
🔗overwrite_existing	Overwrite the existing file.
🔗update_existing	Overwrite the existing file if it is older than the replacement file.
🔗Option group controlling copy function effects for subdirectories
🔗Constant	Meaning
🔗none	(Default) Do not copy subdirectories.
🔗recursive	Recursively copy subdirectories and their contents.
🔗Option group controlling copy function effects for symbolic links
🔗Constant	Meaning
🔗none	(Default) Follow symbolic links.
🔗copy_symlinks	Copy symbolic links as symbolic links rather than copying the files that they point to.
🔗skip_symlinks	Ignore symbolic links.
🔗Option group controlling copy function effects for choosing the form of copying
🔗Constant	Meaning
🔗none	(Default) Copy content.
🔗directories_only	Copy directory structure only, do not copy non-directory files.
🔗create_symlinks	Make symbolic links instead of copies of files. The source path shall be an absolute path unless the destination path is in the current directory.
🔗create_hard_links	Make hard links instead of copies of files.

Table 149 — Enum class perms [tab:fs.enum.perms]

🔗Name	Value	POSIX	Definition or notes
🔗	(octal)	macro
🔗none	0	There are no permissions set for the file.
🔗owner_read	0400	S_IRUSR	Read permission, owner
🔗owner_write	0200	S_IWUSR	Write permission, owner
🔗owner_exec	0100	S_IXUSR	Execute/search permission, owner
🔗owner_all	0700	S_IRWXU	Read, write, execute/search by owner;owner_read \| owner_write	owner_exec
🔗group_read	040	S_IRGRP	Read permission, group
🔗group_write	020	S_IWGRP	Write permission, group
🔗group_exec	010	S_IXGRP	Execute/search permission, group
🔗group_all	070	S_IRWXG	Read, write, execute/search by group;group_read \| group_write	group_exec
🔗others_read	04	S_IROTH	Read permission, others
🔗others_write	02	S_IWOTH	Write permission, others
🔗others_exec	01	S_IXOTH	Execute/search permission, others
🔗others_all	07	S_IRWXO	Read, write, execute/search by others;others_read \| others_write	others_exec
🔗all	0777	owner_all \| group_all	others_all
🔗set_uid	04000	S_ISUID	Set-user-ID on execution
🔗set_gid	02000	S_ISGID	Set-group-ID on execution
🔗sticky_bit	01000	S_ISVTX	Operating system dependent.
🔗mask	07777	all \| set_uid	set_gid	sticky_bit
🔗unknown	0xFFFF	The permissions are not known, such as when a file_status object is created without specifying the permissions

Table 150 — Enum class perm_options [tab:fs.enum.perm.opts]

permissions shall replace the file's permission bits with perm
permissions shall replace the file's permission bits with the bitwise or of perm and the file's current permission bits.
permissions shall replace the file's permission bits with the bitwise and of the complement of perm and the file's current permission bits.
permissions shall change the permissions of a symbolic link itself rather than the permissions of the file the link resolves to.

Table 153 — Atomic arithmetic computations [tab:atomic.types.int.comp]

🔗*key*	Op	Computation	*key*	Op	Computation
🔗add	+	addition	and	&	bitwise and
🔗sub	-	subtraction	or	\|	bitwise inclusive or
🔗max	maximum	xor	^	bitwise exclusive or
🔗min	minimum

Table 156 — Types of customization point objects in the execution control library [tab:exec.pos]

🔗Customization point	Purpose	Examples
🔗object type
🔗core	provide core execution functionality, and connection between core components	e.g., connect, start
🔗completion functions	called by senders to announce the completion of the work (success, error, or cancellation)	set_value, set_error, set_stopped
🔗senders	allow the specialization of the provided sender algorithms	sender factories (e.g., schedule, just, read_env)sender adaptors (e.g., continues_on, then, let_value)sender consumers (e.g., sync_wait)
🔗queries	allow querying different properties of objects	general queries (e.g., get_allocator, get_stop_token)environment queries (e.g., get_scheduler, get_delegation_scheduler)scheduler queries (e.g., get_forward_progress_guarantee)sender attribute queries (e.g., get_completion_scheduler)