Types de données C++

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

Type	Description
void	aucun type
int	entier
float	nombre à virgule flottante (décimal)
double	nombre à virgule flottante de précision double
char	caractère

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

Type	Description
bool	valeur booléenne; VRAI ou FAUX
wchar_t	caractè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
short	short int	signed short	signed short int
unsigned short		unsigned short int
int	signed	signed int
unsigned		unsigned int
long	long int	signed long	signed long int
unsigned long		unsigned long int
types à virgule flottante
float
double
long double
types entiers supportés optionnellement
long long	long long int	signed long long	signed long long int
unsigned long long		unsigned 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 keywords/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 /fr/support/types/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	Retour	Description
is_specialized	bool
radix	int	base de l'exposant
digits	int	nombre de bits utilisés dans la représentation
digits10	int	nombre de chiffres qui peuvent être représentés
is_signed	bool	nombre signé ?
is_integer	bool	nombre entier ?
is_exact	bool
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_exponent	int
min_exponent10	int
max_exponent	int
max_exponent10	int
has_infinity	bool
has_quiet_NaN	bool
has_signaling_NaN	bool
has_denorm	<type>_denorm_style
has_denorm_loss	bool
is_iec559	bool	conforme à l'IEC-559
is_bounded	bool
is_modulo	bool
traps	bool
tinyness_before	bool
round_style	float_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:

Expression	Signifie
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:

Expression	Signifie
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.