Traductions de cette page?:

Types de données C++

Les programmeurs C++ ont accès à cinq types de données en C:void, int, float, double, et char.

TypeDescription
voidaucun type
intentier
floatnombre à virgule flottante (décimal)
doublenombre à virgule flottante de précision double
charcaractère

Le C++ en définit deux de plus: bool et wchar_t.

TypeDescription
boolvaleur booléenne; VRAI ou FAUX
wchar_tcaractère étendu

Modifieurs de types

Plusieurs de ces types peuvent être modifiés en utilisant les mots-clés signed, unsigned, short, et long. Lorsqu'un de ces modifieurs de type est utilisé seul, le type par défaut est le type entier. Une liste complète des types de données possibles suit:

types entiers
bool
char
signed char
unsigned char
wchar_t
shortshort intsigned shortsigned short int
unsigned shortunsigned short int
intsignedsigned int
unsignedunsigned int
longlong intsigned longsigned long int
unsigned longunsigned long int
types à virgule flottante
float
double
long double
types entiers supportés optionnellement
long longlong long intsigned long longsigned long long int
unsigned long longunsigned long long int

Taille et étendue des types

La taille et l'étendue d'un type de donnée dépend de l'architecture et du compilateur. Vous pouvez utiliser l'opérateur sizeof pour déterminer la taille d'un type de donnée (exprimée en octets). Cependant, beaucoup d'architectures implémentent les types de données d'une taille standard. Les entiers sont souvent codés sur 32 bits; un caractère (char) est codé sur 8 bits, un entier court (short) sur 16 bits et un entier long sur 32 bits, le type long long est codé sur 64 bits.

Le fichier d'entête “cfloat” (ou “float.h”) défini l'étendue des nombres décimaux, “climits” (ou “limits.h”) - celle des entiers.

Les limites des valeurs numériques sont définies dans l'entête <limits>. Les valeurs modèles de limits fournissent des représentations numériques indépendantes du système pour les types de données du C++. Utilisez la fonction appropriée en fournissant le type de donnée en paramètre comme indiqué ci-dessous. Notez que les limites numériques peuvent aussi être surchargées pour les types définis par l'utilisateur.

Méthode ou
constante
RetourDescription
is_specializedbool
radixintbase de l'exposant
digitsintnombre de bits utilisés dans la représentation
digits10intnombre de chiffres qui peuvent être représentés
is_signedboolnombre signé ?
is_integerboolnombre entier ?
is_exactbool
min()<type>plus petit nombre représentable (non négatif)
max()<type>plus grand nombre
epsilon()<type>différence entre 1 et la plus petite valeur plus grande que 1
round_error()<type>erreur maximum d'arrondi
infinity()<type>infini
quiet_NaN()<type>nombre invalide ne signalant pas d'erreur
signaling_NaN()<type>nombre invalide signalant une erreur
denorm_min()<type>
min_exponentint
min_exponent10int
max_exponentint
max_exponent10int
has_infinitybool
has_quiet_NaNbool
has_signaling_NaNbool
has_denorm<type>_denorm_style
has_denorm_lossbool
is_iec559boolconforme à l'IEC-559
is_boundedbool
is_modulobool
trapsbool
tinyness_beforebool
round_stylefloat_round_style { round_to_nearest, … }

L'utilisation la plus commune est la vérification des limites, pour être sûr qu'un nombre donnée est valide et peut être stocké. Le code suivant affiche les valeurs minimal et maximal d'un entier court sur le système courant.

  #include <limits>
  std::cout << "Maximum : " << std::numeric_limits<short>::max() << std::endl;
  std::cout << "Minimum : " << std::numeric_limits<short>::min() << std::endl;

Lecture des déclarations de type

Les déclarations simple sont faciles à comprendre:

  int i

Mais parfois cela peut devenir plus compliqué:

  double **d[8]              // hmm...
  char *(*(**foo [][8])())[] // argh! qu'est foo ?

Pour comprendre ces déclarations, suivez les trois règles :

  1. Commencez au nom de la variable (d ou foo dans les exemples ci-dessus)
  2. Terminez par le type de donnée (double ou char)
  3. Allez à droite quand vous pouvez, et à gauche quand vous le devez. (Les parenthèses ramènent à gauche.)

Par exemple:

ExpressionSignifie
double **d[8];
double **d[8]; d est … double
double **d[8]; d est un tableau de 8 … double
double **d[8]; d est un tableau de 8 pointeurs vers … double
double **d[8]; d est un tableau de 8 pointeurs vers un pointeur de double

Un autre exemple:

ExpressionSignifie
char *(*(**foo [][8])())[]
char *(*(**foo [][8])())[] foo est … char
char *(*(**foo [][8])())[] foo est un tableau de … char
char *(*(**foo [][8])())[] foo est un tableau de tableaux de 8 … char
char *(*(**foo [][8])())[] foo est un tableau de tableaux de 8 pointeurs vers … char
char *(*(**foo [][8])())[] foo est un tableau de tableaux de 8 pointeurs vers un pointeur de … char
char *(*(**foo [][8])())[] foo est un tableau de tableaux de 8 pointeurs vers un pointeur de fonction retournant … char
char *(*(**foo [][8])())[] foo est un tableau de tableaux de 8 pointeurs vers un pointeur de fonction retournant un pointeur de … char
char *(*(**foo [][8])())[] foo est un tableau de tableaux de 8 pointeurs vers un pointeur de fonction retournant un pointeur de tableau de … char
char *(*(**foo [][8])())[] foo est un tableau de tableaux de 8 pointeurs vers un pointeur de fonction retournant un pointeur de tableau de pointeurs de char

Pour une explication plus détaillée en anglais, voyez la description de comment lire les déclarations en C de Steve Friedl à http://www.unixwiz.net/techtips/reading-cdecl.html.