Fundamental types

From cppreference.net

(Voir aussi type pour un aperçu du système de types et la liste des utilitaires liés aux types fournis par la bibliothèque C++)

Les types suivants sont collectivement appelés types fondamentaux :

(éventuellement qualifié cv) void

(éventuellement qualifié cv) std::nullptr_t

(depuis C++11)

Table des matières

void

void — type avec un ensemble vide de valeurs. C'est un type incomplet qui ne peut être complété (par conséquent, les objets de type void sont interdits). Il n'existe pas de tableaux de void , ni de références à void . Cependant, pointeurs vers void et fonctions retournant le type void ( procédures dans d'autres langages) sont autorisés.

std::nullptr_t

Défini dans l'en-tête `<cstddef>`
typedef decltype ( nullptr ) nullptr_t ;		(depuis C++11)

std::nullptr_t est le type du littéral de pointeur nul, nullptr . C'est un type distinct qui n'est pas lui-même un type pointeur ou un type pointeur vers membre. Toutes ses prvalues sont des constantes de pointeur nul .

sizeof ( std:: nullptr_t ) est égal à sizeof ( void * ) .

(depuis C++11)

Types entiers

Types entiers standard

int — type entier de base. Le mot-clé int peut être omis si l'un des modificateurs listés ci-dessous est utilisé. Si aucun modificateur de longueur n'est présent, il est garanti d'avoir une largeur d'au moins 16 bits. Cependant, sur les systèmes 32/64 bits, il est presque exclusivement garanti d'avoir une largeur d'au moins 32 bits (voir ci-dessous).

Modificateurs

Modifie le type entier de base. Peut être mélangé dans n'importe quel ordre. Un seul de chaque groupe peut être présent dans le nom de type.

Signage :

signed — le type cible aura une représentation signée (c'est la valeur par défaut si omis)

unsigned — le type cible aura une représentation non signée

Taille :

short — le type cible sera optimisé pour l'espace et aura une largeur d'au moins 16 bits.

long — le type cible aura une largeur d'au moins 32 bits.

long long — le type cible aura une largeur d'au moins 64 bits.

(depuis C++11)

Remarque : comme pour tous les spécificateurs de type, tout ordre est autorisé : unsigned long long int et long int unsigned long désignent le même type.

Propriétés

Le tableau suivant résume tous les types entiers standard disponibles et leurs propriétés dans différents modèles de données courants :

**Note:** Aucune traduction n'a été effectuée car : - Le texte contenu dans les balises ` ` est du code C++ et ne doit pas être traduit - Les termes C++ spécifiques (`unsigned`, `long`, `int`) sont conservés dans leur forme originale - La mention "(C++11)" est une référence technique qui ne nécessite pas de traduction - Toutes les balises HTML et attributs sont préservés intacts

Spécificateur de type	Type équivalent	Largeur en bits par modèle de données
Spécificateur de type	Type équivalent	Norme C++	LP32	ILP32	LLP64	LP64
signed char	signed char	au moins 8	8	8	8	8
unsigned char	unsigned char	au moins 8	8	8	8	8
short	short int	au moins 16	16	16	16	16
short int
signed short
signed short int
unsigned short	unsigned short int
unsigned short int	unsigned short int
int	int	au moins 16	16	32	32	32
signed
signed int
unsigned	unsigned int
unsigned int	unsigned int
long	long int	au moins 32	32	32	32	64
long int
signed long
signed long int
unsigned long	unsigned long int
unsigned long int	unsigned long int
long long	long long int (C++11)	au moins 64	64	64	64	64
long long int
signed long long
signed long long int
unsigned long long	unsigned long long int (C++11)
unsigned long long int	unsigned long long int (C++11)

Note : l'arithmétique entière est définie différemment pour les types entiers signés et non signés. Voir les opérateurs arithmétiques , en particulier les dépassements d'entiers .

std::size_t est le type entier non signé du résultat de l'opérateur sizeof ainsi que de l'opérateur sizeof... et de l'opérateur alignof (depuis C++11) .

Types entiers étendus

Les types entiers étendus sont définis par l'implémentation. Notez que les types entiers de largeur fixe sont généralement des alias des types entiers standards.

(depuis C++11)

Type booléen

bool — type entier, capable de contenir l'une des deux valeurs :


          true


          false

. La valeur de sizeof ( bool ) est définie par l'implémentation et peut différer de 1 .

Types de caractères

Les types de caractères sont des types entiers utilisés pour la représentation des caractères.

signed char — type pour la représentation de caractères signés.

unsigned char — type pour la représentation de caractères non signés. Également utilisé pour inspecter les représentations d'objets (mémoire brute).

char — type pour la représentation de caractères qui peut être traité le plus efficacement sur le système cible (a la même représentation et alignement que soit signed char soit unsigned char , mais est toujours un type distinct). Les chaînes de caractères multioctets utilisent ce type pour représenter les unités de code. Pour chaque valeur de type unsigned char dans l'intervalle

255

, convertir la valeur en char puis de nouveau en unsigned char produit la valeur originale. (depuis C++11) La signe de char dépend du compilateur et de la plateforme cible : les valeurs par défaut pour ARM et PowerPC sont généralement non signées, les valeurs par défaut pour x86 et x64 sont généralement signées.

wchar_t — type pour la représentation de caractères larges (voir chaînes larges ). Il a la même taille, signe et alignement qu'un des types entiers, mais est un type distinct. En pratique, il fait 32 bits et contient UTF-32 sur Linux et de nombreux autres systèmes non-Windows, mais 16 bits et contient des unités de code UTF-16 sur Windows. La norme exigeait auparavant que wchar_t soit suffisamment grand pour représenter n'importe quel point de code de caractère pris en charge. Cependant, cette exigence ne peut pas être satisfaite sur Windows, et est donc considérée comme un défaut et a été supprimée.

char16_t — type pour la représentation de caractères UTF-16, requis pour être suffisamment grand pour représenter toute unité de code UTF-16 (16 bits). Il a la même taille, signe et alignement que std::uint_least16_t , mais est un type distinct.

char32_t — type pour la représentation de caractères UTF-32, requis pour être suffisamment grand pour représenter toute unité de code UTF-32 (32 bits). Il a la même taille, signe et alignement que std::uint_least32_t , mais est un type distinct.

(depuis C++11)

char8_t — type pour la représentation de caractères UTF-8, devant être suffisamment grand pour représenter toute unité de code UTF-8 (8 bits). Il a la même taille, signe et alignement que unsigned char (et donc, la même taille et le même alignement que char et signed char ), mais est un type distinct.

(depuis C++20)

Outre les nombres de bits minimaux, la norme C++ garantit que

1 == sizeof ( char )

≤

sizeof ( short )

≤

sizeof ( int )

≤

sizeof ( long )

≤

sizeof ( long long ) .

**Note:** Le contenu C++ et les termes techniques (`sizeof`, `char`, `short`, `int`, `long`, `long long`) n'ont pas été traduits conformément aux instructions. La structure HTML et les balises ont été conservées intactes.

Note : cela permet le cas extrême où les bytes ont une taille de 64 bits, tous les types (y compris char ) ont une largeur de 64 bits, et sizeof retourne 1 pour chaque type.

Types à virgule flottante

Types à virgule flottante standard

Les trois types suivants et leurs versions qualifiées cv sont collectivement appelés types flottants standard.

float — type à virgule flottante simple précision. Généralement format binaire 32 bits IEEE-754 .

double — type à virgule flottante double précision. Généralement format binaire 64 bits IEEE-754 .

long double — type à virgule flottante précision étendue. Ne correspond pas nécessairement aux types imposés par IEEE-754.

Le format binaire 128 bits IEEE-754 est utilisé par certaines implémentations HP-UX, SPARC, MIPS, ARM64 et z/OS.
Le plus connu format étendu binaire 64 bits IEEE-754 est le format de précision étendue 80 bits x87 . Il est utilisé par de nombreuses implémentations x86 et x86-64 (une exception notable est MSVC, qui implémente long double dans le même format que double , c'est-à-dire binaire 64 bits).
Sur PowerPC, le double-double peut être utilisé.

Types de virgule flottante étendus

Les types de virgule flottante étendus sont définis par l'implémentation. Ils peuvent inclure les types de virgule flottante de largeur fixe .

(depuis C++23)

Propriétés

Les types à virgule flottante peuvent prendre en charge des valeurs spéciales :

l'infini (positif et négatif), voir INFINITY
le zéro négatif , - 0.0 . Il est égal au zéro positif en comparaison, mais est significatif dans certaines opérations arithmétiques, par exemple 1.0 / 0.0 == INFINITY , mais 1.0 / - 0.0 == - INFINITY ), et pour certaines fonctions mathématiques, par exemple sqrt (std::complex)
non-nombre (NaN), qui n'est égal à rien en comparaison (y compris lui-même). Plusieurs motifs de bits représentent les NaNs, voir std::nan , NAN . Notez que C++ ne prend pas en compte spécialement les NaNs signalés, sauf pour détecter leur support par std::numeric_limits::has_signaling_NaN , et traite tous les NaNs comme silencieux.

Les nombres à virgule flottante peuvent être utilisés avec les opérateurs arithmétiques + , - , / , et * ainsi que diverses fonctions mathématiques de <cmath> . Les opérateurs intégrés et les fonctions de bibliothèque peuvent lever des exceptions de virgule flottante et définir errno comme décrit dans math errhandling .

Les expressions en virgule flottante peuvent avoir une plage et une précision supérieures à celles indiquées par leurs types, voir FLT_EVAL_METHOD . Les expressions en virgule flottante peuvent également être contractées , c'est-à-dire calculées comme si toutes les valeurs intermédiaires avaient une plage et une précision infinies, voir #pragma STDC FP_CONTRACT . Le C++ standard ne restreint pas la précision des opérations en virgule flottante.

Certaines opérations sur les nombres à virgule flottante sont affectées par et modifient l'état de l'environnement de virgule flottante (notamment, la direction d'arrondi).

Conversions implicites sont définies entre les types flottants et les types entiers.

Voir limites des types à virgule flottante et std::numeric_limits pour des détails, limites et propriétés supplémentaires des types à virgule flottante.

Plage de valeurs

Le tableau suivant fournit une référence pour les limites des représentations numériques courantes.

Avant C++20, la norme C++ autorisait toute représentation d'entiers signés, et la plage minimale garantie des entiers signés de N bits était de $-(2 N-1 -1)$ à $+2 N-1 -1$ (par exemple −127 à 127 pour un type signé 8 bits), ce qui correspond aux limites du complément à un ou de la représentation signe-magnitude .

Cependant, tous les compilateurs C++ utilisent le complément à deux comme représentation, et depuis C++20, c'est la seule représentation autorisée par la norme, avec la plage garantie de $-2 N-1$ à $+2 N-1 -1$ (par exemple −128 à 127 pour un type signé 8 bits).

Les représentations en complément à un et signe-magnitude sur 8 bits pour char ont été interdites depuis C++11 (via la résolution de CWG issue 1759 ), car une unité de code UTF-8 de valeur 0x80 utilisée dans un littéral de chaîne UTF-8 doit pouvoir être stockée dans un objet de type char .

La plage pour un type à virgule flottante T est définie comme suit :

La plage minimale garantie est le nombre flottant fini le plus négatif représentable dans T jusqu'au nombre flottant fini le plus positif représentable dans T .
Si l'infini négatif est représentable dans T , la plage de T est étendue à tous les nombres réels négatifs.
Si l'infini positif est représentable dans T , la plage de T est étendue à tous les nombres réels positifs.

Puisque les infinis négatifs et positifs sont représentables dans les formats ISO/IEC/IEEE 60559 , tous les nombres réels se situent dans la plage des valeurs représentables d'un type à virgule flottante conforme à l'ISO/IEC/IEEE 60559.

Type	Taille en bits	Format	Plage de valeurs
Type	Taille en bits	Format	Approximative	Exacte
caractère	8	signé		−128 à 127
	8	non signé		0 à 255
	16	UTF-16		0 à 65535
	32	UTF-32		0 à 1114111 ( 0x10ffff )
entier	16	signé	± 3.27 · 10 ⁴	−32768 à 32767
	16	non signé	0 à 6.55 · 10 ⁴	0 à 65535
	32	signé	± 2.14 · 10 ⁹	−2,147,483,648 à 2,147,483,647
	32	non signé	0 à 4.29 · 10 ⁹	0 à 4,294,967,295
	64	signé	± 9.22 · 10 ¹⁸	−9,223,372,036,854,775,808 à 9,223,372,036,854,775,807
	64	non signé	0 à 1.84 · 10 ¹⁹	0 à 18,446,744,073,709,551,615
virgule flottante binaire	32	IEEE-754	sous-normal min : ± 1.401,298,4 · 10 ⁻⁴⁵ normal min : ± 1.175,494,3 · 10 ⁻³⁸ max : ± 3.402,823,4 · 10 ³⁸	sous-normal min : ±0x1p−149 normal min : ±0x1p−126 max : ±0x1.fffffep+127
	64	IEEE-754	sous-normal min : ± 4.940,656,458,412 · 10 ⁻³²⁴ normal min : ± 2.225,073,858,507,201,4 · 10 ⁻³⁰⁸ max : ± 1.797,693,134,862,315,7 · 10 ³⁰⁸	sous-normal min : ±0x1p−1074 normal min : ±0x1p−1022 max : ±0x1.fffffffffffffp+1023
	80 ^{[note 1]}	x86	sous-normal min : ± 3.645,199,531,882,474,602,528 · 10 ⁻⁴⁹⁵¹ normal min : ± 3.362,103,143,112,093,506,263 · 10 ⁻⁴⁹³² max : ± 1.189,731,495,357,231,765,021 · 10 ⁴⁹³²	sous-normal min : ±0x1p−16445 normal min : ±0x1p−16382 max : ±0x1.fffffffffffffffep+16383
	128	IEEE-754	sous-normal min : ± 6.475,175,119,438,025,110,924, 438,958,227,646,552,5 · 10 ⁻⁴⁹⁶⁶ normal min : ± 3.362,103,143,112,093,506,262, 677,817,321,752,602,6 · 10 ⁻⁴⁹³² max : ± 1.189,731,495,357,231,765,085, 759,326,628,007,016,2 · 10 ⁴⁹³²	sous-normal min : ±0x1p−16494 normal min : ±0x1p−16382 max : ±0x1.ffffffffffffffffffffffffffff p+16383

↑ La représentation d'objet occupe généralement 96/128 bits sur les plateformes 32/64 bits respectivement.

Note : les limites réelles (par opposition aux minimales garanties) sur les valeurs représentables par ces types sont disponibles dans l' interface des limites numériques C et dans std::numeric_limits .

Modèles de données

Les choix effectués par chaque implémentation concernant les tailles des types fondamentaux sont collectivement connus sous le nom de modèle de données . Quatre modèles de données ont été largement adoptés :

Systèmes 32 bits :

LP32 ou 2/4/4 ( int est 16 bits, long et pointeur sont 32 bits)

API Win16

ILP32 ou 4/4/4 ( int , long , et pointeur sont 32 bits) ;

API Win32
Systèmes Unix et de type Unix (Linux, macOS)

Systèmes 64 bits :

LLP64 ou 4/4/8 ( int et long sont 32-bit, le pointeur est 64-bit)

API Win32 (également appelée API Windows) avec cible de compilation ARM 64-bit (AArch64) ou x86-64 (alias x64)

LP64 ou 4/8/8 ( int est 32-bit, long et le pointeur sont 64-bit)

Systèmes Unix et de type Unix (Linux, macOS)

Les autres modèles sont très rares. Par exemple, ILP64 ( 8/8/8 : int , long , et les pointeurs sont 64 bits) n'est apparu que dans certains systèmes Unix 64 bits anciens (par exemple UNICOS sur Cray ).

Notes

Macro de test de fonctionnalité	Valeur	Std	Fonctionnalité
`__cpp_unicode_characters`	`200704L`	(C++11)	Nouveaux types de caractères ( char16_t et char32_t )
`__cpp_char8_t`	`201811L`	(C++20)	char8_t
`__cpp_char8_t`	`202207L`	(C++23)	char8_t correctif de compatibilité et de portabilité ( permet l'initialisation de tableaux `(unsigned) char` à partir de littéraux de chaîne UTF-8 )

Mots-clés

void , bool , true , false , char , char8_t , char16_t , char32_t , wchar_t , int , short , long , signed , unsigned , float , double

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 tel que publié	Comportement correct
CWG 238	C++98	les contraintes imposées à une implémentation en virgule flottante n'étaient pas spécifiées	spécifié comme aucune contrainte
CWG 1759	C++11	char n'est pas garanti de pouvoir représenter l'unité de code UTF-8 0x80	garanti
CWG 2689	C++11	std::nullptr_t qualifié cv n'était pas un type fondamental	il l'est
CWG 2723	C++98	les plages de valeurs représentables pour les types en virgule flottante n'étaient pas spécifiées	spécifiées
P2460R2	C++98	wchar_t devait pouvoir représenter des codes distincts pour tous les membres du plus grand jeu de caractères étendu spécifié parmi les locales supportées	non requis

Références

Norme C++23 (ISO/CEI 14882:2024) :

6.8.2 Types fondamentaux [basic.fundamental]

Norme C++20 (ISO/CEI 14882:2020) :

6.8.1 Types fondamentaux [basic.fundamental]

Norme C++17 (ISO/CEI 14882:2017) :

6.9.1 Types fondamentaux [basic.fundamental]

Norme C++14 (ISO/CEI 14882:2014) :

3.9.1 Types fondamentaux [basic.fundamental]

Norme C++11 (ISO/CEI 14882:2011) :

3.9.1 Types fondamentaux [basic.fundamental]

Norme C++03 (ISO/CEI 14882:2003) :

3.9.1 Types fondamentaux [basic.fundamental]

Norme C++98 (ISO/CEI 14882:1998) :

3.9.1 Types fondamentaux [basic.fundamental]

Voir aussi

Documentation C pour les types arithmétiques

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

Comments
ASCII
Punctuation
Names and identifiers
Types
Fundamental types
Objects
Scope
Object lifetime
Storage duration and linkage
Definitions and ODR
Name lookup
Qualified name lookup
Unqualified name lookup
The as-if rule
Undefined behavior
Memory model
Multi-threaded executions and data races (C++11)
Character sets and encodings
Phases of translation
The `main` function
Modules (C++20)
Contracts (C++26)

cppreference.net

Namespaces

Variants

Fundamental types

Table des matières

void

std::nullptr_t

Types entiers

Types entiers standard

Modificateurs

Propriétés

Types entiers étendus

Type booléen

Types de caractères

Types à virgule flottante

Types à virgule flottante standard

Types de virgule flottante étendus

Propriétés

Plage de valeurs

Modèles de données

Notes

Mots-clés

Rapports de défauts

Références

Voir aussi