is-integer-like , is-signed-integer-like

template< class T > constexpr bool /is-integer-like/ = /* see description */;	(1)	(начиная с C++20) (только для иллюстрации*)
template< class T > constexpr bool /is-signed-integer-like/ = /* see description */;	(2)	(начиная с C++20) (только для иллюстрации*)

1) /*is-integer-like*/<T> является true тогда и только тогда, когда T — целочисленный тип.

2) /*is-signed-integer-like*/<T> является true тогда и только тогда, когда T — знаковый целочисленный-подобный тип.

Целочисленный тип-класс

Тип T является целочисленным типом-классом, если он входит в набор типов, определяемый реализацией и ведущих себя как целочисленные типы, как описано ниже. Целочисленный тип-класс не обязательно является типом-классом.

Целочисленный тип-класс может представлять \(\scriptsize 2^N \)2^N последовательных целых чисел, где N — положительное целое число, называемое шириной целочисленного типа-класса.

Целочисленный тип-класс бывает знаковым или беззнаковым:

Знаковый целочисленный тип-класс может представлять все целые числа в диапазоне [\(\scriptsize -2^{N-1} \)-2^N-1, \(\scriptsize 2^{N-1}-1 \)2^N-1-1], где N больше ширины любого знакового целочисленного типа.
Беззнаковый целочисленный тип-класс может представлять все целые числа в диапазоне [\(\scriptsize 0 \)0, \(\scriptsize 2^N-1 \)2^N-1], где N больше ширины любого беззнакового целочисленного типа.

Все целочисленные типы-классы моделируют regular и three_way_comparable<std::strong_ordering>.

Объект целочисленного типа-класса, инициализированный значением, имеет значение 0.

Выражение E целочисленного типа-класса T контекстно преобразуемо к bool, как если бы применялось bool(E != T(0)).

Целочисленный-подобный тип

Тип, отличный от (возможно, cv-квалифицированного) bool, является целочисленным-подобным, если он моделирует integral или является целочисленным типом-классом.

Целочисленный-подобный тип является знаковым целочисленным-подобным, если он моделирует signed_integral или является знаковым целочисленным типом-классом.
Целочисленный-подобный тип является беззнаковым целочисленным-подобным, если он моделирует unsigned_integral или является беззнаковым целочисленным типом-классом.

Требуемое поведение

Выражения целочисленного типа-класса явно преобразуемы к любому целочисленному-подобному типу и неявно преобразуемы к любому целочисленному типу-классу той же знаковости и равной или большей ширины. Выражения целочисленного типа как неявно, так и явно преобразуемы к любому целочисленному типу-классу. Преобразования между целочисленными и целочисленными типами-классами, а также между двумя целочисленными типами-классами не завершаются выбрасыванием исключения. Результатом такого преобразования является единственное значение типа назначения, сравнимое по модулю \(\scriptsize 2^N \)2^N с исходным значением, где N — ширина типа назначения.

Обозначим Int<T> следующий тип:

Если T — целочисленный тип-класс, то Int<T> — уникальный гипотетический расширенный целочисленный тип той же знаковости и той же ширины, что и T.
Если T — целочисленный тип, то Int<T> — тот же тип, что и T.

Для следующих типов, значений и операторов:

Тип	Определение
`IC`	целочисленный тип-класс
`IL`	целочисленный-подобный тип
Значение	Определение
`a`	объект типа `IC`
`b`	объект типа `IL`
`c`	lvalue целочисленного типа
`x`	объект типа `Int<IC>`, представляющий то же значение, что и `a`
`y`	объект типа `Int<IL>`, представляющий то же значение, что и `b`
Оператор	Определение
`@=`	один из `+=`, `-=`, `*=`, `/=`, `%=`, `&=`, `\|=`, `^=`, `<<=` и `>>=`
`@`	один из `+`, `-`, `*`, `/`, `%`, `&`, `\|`, `^`, `<<`, `>>`, `&&`, `\|\|`, `==`, `!=`, `<`, `>`, `<=`, `>=`, `<=>` и `,`

Следующие выражения должны быть корректно сформированы и иметь указанные результаты и эффекты, если выполнены заданные условия:

Выражение	Условие	Результат	Эффекты
`a++`	Нет условий	prvalue типа `IC`, значение которого равно значению `a` до вычисления	изменяет значение `a`, прибавляя к нему `1`
`a--`	Нет условий		изменяет значение `a`, вычитая из него `1`
`++a`	эквивалентно выражению `a += 1`
`--a`	эквивалентно выражению `a -= 1`
`&a`	эквивалентно выражению `std::addressof(a)`
`!a`	`!x` корректно сформировано	то же, что и `!x`
`+a`	`+x` корректно сформировано	то же, что и `+x`, но имеет тип `IC`	то же, что и `+x`
`-a`	`-x` корректно сформировано	то же, что и `-x`, но имеет тип `IC`	то же, что и `-x`
`~a`	`~x` корректно сформировано	то же, что и `~x`, но имеет тип `IC`	то же, что и `~x`
`c @= a`	`c @= x` корректно сформировано	lvalue, ссылающееся на `c`	то же, что и `c @= x`
`a @= b`	`x @= y` корректно сформировано	lvalue, ссылающееся на `a`	то же, что и `x @= y`, за исключением того, что значение, которое было бы сохранено в `x`, сохраняется в `a`
`a @ b`	`x @ y` корректно сформировано	то же, что и `x @ y`, но тип результата отличается: Если `x @ y` имеет тип `Int<IC>`, результат имеет тип `IC`. Если `x @ y` имеет тип `Int<IL>`, результат имеет тип `IL`. Если `x @ y` имеет любой другой тип `T`, результат имеет тип `T`.	то же, что и `x @ y`
`b @ a`	`y @ x` корректно сформировано	то же, что и `y @ x`, но тип результата отличается: Если `y @ x` имеет тип `Int<IC>`, результат имеет тип `IC`. Если `y @ x` имеет тип `Int<IL>`, результат имеет тип `IL`. Если `y @ x` имеет любой другой тип `T`, результат имеет тип `T`.	то же, что и `y @ x`

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющих поведение, были применены задним числом к ранее опубликованным стандартам C++.

DR	Применён к	Опубликованное поведение	Корректное поведение
LWG 3366 (P2393R1)	C++20	для преобразования между целочисленным типом-классом и соответствующим целочисленным типом не гарантировалось получение представимого значения	гарантируется
LWG 3376 (P2393R1)	C++20	целочисленные типы-классы могли быть только типами-классами	допускаются также не-классовые типы
LWG 3467	C++20	bool считался целочисленным-подобным типом	исключён
LWG 3575 (P2393R1)	C++20	для целочисленных типов-классов не гарантировалась поддержка трёхстороннего сравнения	гарантируется

См. также

weakly_incrementable

(C++20)

указывает, что тип, моделирующий semiregular, можно инкрементировать с помощью операторов префиксного и постфиксного инкремента
(концепт)