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

template < class T > constexpr bool /*is-integer-like*/ = /* voir description */ ;	(1)	(depuis C++20) ( exposition uniquement* )
template < class T > constexpr bool /*is-signed-integer-like*/ = /* voir description */ ;	(2)	(depuis C++20) ( exposition uniquement* )

Table des matières 1 Type de classe Integer 2 Type de type Integer 3 Comportements requis 4 Rapports de défauts 5 Voir aussi

Type de classe entière

Un type T est un type de classe entière s'il fait partie d'un ensemble de types définis par l'implémentation qui se comportent comme le font les types entiers , tel que défini ci-dessous . Un type de classe entière n'est pas nécessairement un type classe .

Un type de classe entière peut représenter \(\scriptsize 2^N \) 2 N
entiers consécutifs, où N , un entier positif, est appelé la largeur du type de classe entière.

Un type de classe entière est soit signé soit non signé :

• Un type de classe entier signé peut représenter tous les entiers dans [ \(\scriptsize -2^{N-1} \) -2 N-1
  , \(\scriptsize 2^{N-1}-1 \) 2 N-1
  -1 ] , où N est supérieur à la largeur de chaque type entier signé.
• Un type de classe entier non signé peut représenter tous les entiers dans [ \(\scriptsize 0 \) 0 , \(\scriptsize 2^N-1 \) 2 N
  -1 ] , où N est supérieur à la largeur de chaque type entier non signé.

Tous les types de classe entière modélisent regular et three_way_comparable < std:: strong_ordering > .

Un objet de type classe-entier initialisé par valeur a la valeur ​ 0 ​ .

Une expression E de type integer-class T est contextuellement convertible en bool comme si par bool ( E ! = T ( 0 ) ) .

Type de type entier

Un type autre que (éventuellement qualifié cv) bool est de type entier s'il modélise integral ou s'il s'agit d'un type de classe entière.

• Un type de type entier est de type entier signé s'il modélise signed_integral ou s'il s'agit d'un type de classe d'entier signé.
• Un type de type entier est de type entier non signé s'il modélise unsigned_integral ou s'il s'agit d'un type de classe d'entier non signé.

Comportements requis

Les expressions de type integer-class sont explicitement convertibles en tout type de type integer-like, et implicitement convertibles en tout type integer-class de largeur égale ou supérieure et de même signe. Les expressions de type intégral sont à la fois implicitement et explicitement convertibles en tout type integer-class. Les conversions entre les types intégral et integer-class et entre deux types integer-class ne sortent pas via une exception. Le résultat d'une telle conversion est la valeur unique du type de destination qui est congrue à la source modulo \(\scriptsize 2^N \) 2 N
, où N est la largeur du type de destination.

Soit Int<T> le type suivant :

• Si T est un type de classe entière, Int<T> est un type hypothétique unique de type entier étendu de même signe et de même largeur que T .
• Si T est un type intégral, soit Int<T> le même type que T .

Étant donné les types, valeurs et opérateurs suivants :

Type	Définition
IC	un type de classe entière
IL	un type similaire à un entier
Valeur	Définition
a	un objet de type IC
b	un objet de type IL
c	une lvalue de type entier
x	un objet de type Int<IC> qui représente la même valeur que a
y	un objet de type Int<IL> qui représente la même valeur que b
Opérateur	Définition
@ =	l'un des opérateurs + = , - = , * = , / = , % = , & = , | = , ^ = , <<= et >>=
@	l'un des opérateurs + , - , * , / , % , & , | , ^ , << , >> , && , || , == , ! = , < , > , <= , >= , <=> et ,

Les expressions suivantes doivent être bien formées et avoir le résultat et les effets spécifiés si les conditions indiquées sont satisfaites :

Expression	Condition	Résultat	Effets
a ++	Aucune condition	une prvalue de type IC dont la valeur est égale à celle de a avant l'évaluation	modifie la valeur de a en lui ajoutant 1
a --			modifie la valeur de a en lui soustrayant 1
++ a	équivalent-expression à a + = 1
-- a	expression équivalente à a - = 1
& a	expression équivalente à std:: addressof ( a )
! a	! x est bien formé	identique à ! x
+ a	+ x est bien formé	identique à + x , mais a le type IC	identique à + x
- a	- x est bien formé	identique à - x , mais a le type IC	identique à - x
~a	~x est bien formé	identique à ~x , mais a le type IC	identique à ~x
c @ = a	c @ = x est bien formé	une lvalue référençant c	identique à c @ = x
a @ = b	x @ = y est bien formé	une lvalue référençant a	identique à x @ = y , sauf que la valeur qui serait stockée dans x est stockée dans a
a @ b	x @ y est bien formé	identique à x @ y , mais le type du résultat est différent : Si x @ y est de type Int<IC> , le résultat a pour type IC . Si x @ y est de type Int<IL> , le résultat a pour type IL . Si x @ y est de tout autre type T , le résultat a pour type T .	identique à x @ y
b @ a	y @ x est bien formé	identique à y @ x , mais le type de résultat est différent : Si y @ x est de type Int<IC> , le résultat a pour type IC . Si y @ x est de type Int<IL> , le résultat a pour type IL . Si y @ x est de tout autre type T , le résultat a pour type T .	identique à y @ x

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR	Appliqué à	Comportement publié	Comportement corrigé
LWG 3366 ( P2393R1 )	C++20	la conversion entre un type integer-class et son type entier correspondant n'était pas garantie de produire une valeur représentable	garantie
LWG 3376 ( P2393R1 )	C++20	les types integer-class ne pouvaient être que des types classe	également autorisés pour les types non-classe
LWG 3467	C++20	bool était considéré comme un type integer-like	exclu
LWG 3575 ( P2393R1 )	C++20	les types integer-class n'étaient pas garantis d'être three-way-comparable	garanti

Voir aussi

weakly_incrementable (C++20)

spécifie qu'un type semiregular peut être incrémenté avec les opérateurs de pré-incrémentation et post-incrémentation (concept)