Concepts for integer types, not integral types

Each value $x$ of an unsigned integer type with width $N$ has a unique representation $x=x_0{2}^0+x_1{2}^1+\dots +x_{N-1}{2}^{N-1}$, where each coefficient $x_i$ is either 0 or 1; this is called the base-2 representation of $x$. The base-2 representation of a value of signed integer type is the base-2 representation of the congruent value of the corresponding unsigned integer type. The standard signed integer types and standard unsigned integer types are collectively called the standard integer types, and the extended signed integer types and extended unsigned integer types are collectively called the extended integer types. The standard integer types and extended integer types are collectively called integer types.
[Note: The set of integer types is equal to the set of signed and unsigned integer types. — end note]

A fundamental type specified to have a signed or unsigned an integer type as its underlying type has the same object representation, value representation, alignment requirements ([basic.align]), and range of representable values as the underlying type. Further, each value has the same representation in both types.

Type wchar_t is a distinct type that has an implementation-defined signed or unsigned integer type as its underlying type.

The types char, wchar_t, char8_t, char16_t, and char32_t are collectively called character types. The character types, integer types, bool, the signed and unsigned integer types, and cv-qualified versions ([basic.type.qualifier]) thereof, are collectively termed called integral types. A synonym for integral type is integer type.

Every integer type integral type has an integer integral conversion rank defined as follows:

• […]
• The rank of any extended signed integer type relative to another extended signed integer type with the same width is implementation-defined, but still subject to the other rules for determining the integer integral conversion rank.
• For all integer integral types T1, T2, and T3, if T1 has greater rank than T2, and T2 has greater rank than T3, then T1 has greater rank than T3.

[Note: The integer integral conversion rank is used in the definition of the integral promotion ([conv.prom]) and the usual arithmetic conversions ([expr.arith.conv]). — end note]

Otherwise, the object indicated by the glvalue is read ([defns.access]). Let V be the value contained in the object. If T is an integer integral type, the prvalue result is the value of type T congruent ([basic.fundamental]) to V, and V otherwise.

A prvalue that is not a converted bit-field and has an integer integral type other than bool, char8_t, char16_t, char32_t, or wchar_t whose integer integral conversion rank ([conv.rank]) is less than the rank of int can be converted to a prvalue of type int if int can represent all the values of the source type; otherwise, the source prvalue can be converted to a prvalue of type unsigned int.

A prvalue of an unscoped enumeration type whose underlying type is not fixed can be converted to a prvalue of the first of the following types that can represent all the values of the enumeration ([dcl.enum]): int, unsigned int, long int, unsigned long int, long long int, or unsigned long long int. If none of the types in that list can represent all the values of the enumeration, a prvalue of an unscoped enumeration type can be converted to a prvalue of the extended integer type with lowest integer integral conversion rank ([conv.rank]) greater than the rank of long long in which all the values of the enumeration can be represented. If there are two such extended types, the signed one is chosen.

A prvalue of an integer integral type can be converted to a prvalue of another integer integral type. A prvalue of an unscoped enumeration type can be converted to a prvalue of an integer integral type.

A prvalue of a floating-point type can be converted to a prvalue of an integer integral type. The conversion truncates; that is, the fractional part is discarded. The behavior is undefined if the truncated value cannot be represented in the destination type.

A prvalue of an integer integral type or of an unscoped enumeration type can be converted to a prvalue of a floating-point type. […]

A value of integral type or enumeration type can be explicitly converted to a pointer. A pointer converted to an integer integral type of sufficient size (if any such exists on the implementation) and back to the same pointer type will have its original value ([basic.compound]); mappings between pointers and integers integral types are otherwise implementation-defined.

In simple assignment (=), let V be the result of the right operand; the object referred to by the left operand is modified ([defns.access]) by replacing its value with V or, if the object is of integer integral type, with the value congruent ([basic.fundamental]) to V.

A narrowing conversion is an implicit conversion

• from a floating-point type to an integer integral type, or
• […]
• from an integer integral type or unscoped enumeration type to a floating-point type, except where the source is a constant expression and the actual value after conversion will fit into the target type and will produce the original value when converted back to the original type, or
• from an integer integral type or unscoped enumeration type to an integer integral type that cannot represent all the values of the original type, except where […]
• […]

The value of an enumerator or an object of an unscoped enumeration type is converted to an integer integral type by integral promotion ([conv.prom]).

If a value of integral type (other than bool) is stored into a bit-field of width $N$ and the value would be representable in a hypothetical signed or unsigned integer type with width $N$ and the same signedness as the bit-field's type, the original value and the value of the bit-field compare equal. […]

Several types defined in [support] through [exec] and [depr] are bitmask types. Each bitmask type can be implemented as an enumerated type that overloads certain operators, as an integer integral type, or as a bitset.

Recommended practice: An implementation should choose types for ptrdiff_t and size_t whose integer integral conversion ranks ([conv.rank]) are no greater than that of signed long int unless a larger size is necessary to contain all the possible values.

Specializations shall be provided for each arithmetic type, both floating-point and integer integral, including bool. The member is_specialized shall be true for all such specializations of numeric_limits.

For integer integral types, the number of non-sign bits in the representation.

true if the type is integer integral.

true if the type uses an exact representation. All integer integral types are exact, but not all exact types are integer integral. For example, rational and fixed-exponent representations are exact but not integer integral.

For integer integral types, specifies the base of the representation.¹⁶⁷

Meaningful for all floating-point types. Specializations for integer integral types shall return round_toward_zero.

[Note: Except for CHAR_BIT and MB_LEN_MAX, a macro referring to an integer integral type T defines a constant whose type is the promoted type of T ([conv.prom]). — end note]

The header <cstdint> supplies integer integral types having specified widths, and macros that specify limits of integer integral types.

All types that use the placeholder N are optional when N is not 8, 16, 32, or 64. The exact-width types intN_t and uintN_t for N = 8, 16, 32, and 64 are also optional; however, if an implementation defines integer integral types with the corresponding width and no padding bits, it defines the corresponding typedef-names. Each of the macros listed in this subclause is defined if and only if the implementation defines the corresponding typedef-name.
[Note: The macros INTN_C and UINTN_C correspond to the typedef-names int_leastN_t and uint_leastN_t, respectively. — end note]

Mandates: T is an integer type models integral.

Mandates: Both T and U are standard integer types or extended integer types ([basic.fundamental]) model integer.

Mandates: Both T and R are standard integer types or extended integer types ([basic.fundamental]) model integer.

In this subclause, arguments for a template parameter named Predicate or BinaryPredicate shall meet the corresponding requirements in [algorithms.requirements]. The semantics of i + n, where i is an iterator into the list and n is an integer of integral type, are the same as those of next(i, n). The expression i - n, where i is an iterator into the list and n is an integer, means an iterator j such that j + n == i is true. For merge and sort, the definitions and requirements in [alg.sorting] apply.

In this subclause, arguments for a template parameter named Predicate or BinaryPredicate shall meet the corresponding requirements in [algorithms.requirements]. The semantics of i + n and i - n, where i is an iterator into the hive and n is an integer of integral type, are the same as those of next(i, n) and prev(i, n), respectively. For sort, the definitions and requirements in [alg.sorting] apply.

In this subclause, arguments for a template parameter named Predicate or BinaryPredicate shall meet the corresponding requirements in [algorithms.requirements]. The semantics of i + n, where i is an iterator into the list and n is an integer of integral type, are the same as those of next(i, n). The expression i - n, where i is an iterator into the list and n is an integer, means an iterator j such that j + n == i is true. For merge and sort, the definitions and requirements in [alg.sorting] apply.

Mandates:

• IndexType is a signed or unsigned integer type models integer, and
• each element of Extents is either equal to dynamic_extent, or is representable as a value of type IndexType.

Mandates: Each of the types OffsetType, ExtentType, and StrideType are signed or unsigned integer types, or models integer or integral-constant-like.

Mandates: IndexType is a signed or unsigned integer type models integer.

Within this Clause, for an integer-like type X ([iterator.concept.winc]), make-unsigned-like-t<X> denotes make_unsigned_t<X> if X is an integer integral type; otherwise, it denotes a corresponding unspecified unsigned-integer-like type of the same width as X. For an expression x of type X, to-unsigned-like(x) is x explicitly converted to make-unsigned-like-t<X>.

Also within this Clause, make-signed-like-t<X> for an integer-like type X denotes make_signed_t<X> if X is an integer integral type; otherwise, it denotes a corresponding unspecified signed-integer-like type of the same width as X.

Mandates: M and N both are integer integral types other than bool.

Returns: Half the sum of a and b. If T is an integer integral type and the sum is odd, the result is rounded towards a.

Constraints: T is a signed or unsigned integer type ([basic.fundamental]) models integer.

Constraints: R and T are signed or unsigned integer types ([basic.fundamental]) model integer.

When a function is specified with a type placeholder of integer-type, the implementation provides overloads for char and all cv-unqualified signed and unsigned integer integer types in lieu of integer-type. When a function is specified with a type placeholder of floating-point-type, the implementation provides overloads for all cv-unqualified floating-point types ([basic.fundamental]) in lieu of floating-point-type.

If { arg-id_opt } is used in a width or precision option, the value of the corresponding formatting argument is used as the value of the option. The option is valid only if the corresponding formatting argument is of signed or unsigned integer type. If its value is negative, an exception of type format_error is thrown.

Otherwise, if the argument has integer integral type, then it is effectively cast to complex<double>.

Function template pow has additional constexpr overloads sufficient to ensure, for a call with one argument of type complex<T1> and the other argument of type T2 or complex<T2>, both arguments are effectively cast to complex<common_type_t<T1, T3>>, where T3 is double if T2 is an integer integral type and T2 otherwise. If common_type_t<T1, T3> is not well-formed, then the program is ill-formed.

Constraints: T is an integer type models integral.

Mandates: iterator_traits<InputIterator>::value_type is an integer type models integral.

Mandates: Each of the types type1, type2, and type3 is a cv-unqualified signed or unsigned integer type models integer.

For each function with at least one parameter of type floating-point-type other than abs, the implementation also provides additional overloads sufficient to ensure that, if every argument corresponding to a floating-point-type parameter has arithmetic type, then every such argument is effectively cast to the floating-point type with the greatest floating-point conversion rank and greatest floating-point conversion subrank among the types of all such arguments, where arguments of integer integral type are considered to have the same floating-point conversion rank as double. If no such floating-point type with the greatest rank and subrank exists, then overload resolution does not result in a usable candidate ([over.match.general]) from the overloads provided by the implementation.

both U and value_type are integral types and the integer integral conversion rank ([conv.rank]) of U is greater than the integer integral conversion rank of value_type, or

Specializations for integers integral types