Les types de données en C : int, float, char, double et les autres

Toute variable en C a un type, choisi à la déclaration et figé pour sa durée de vie. Le type décide de trois choses : combien d'octets la variable occupe, comment ces octets sont interprétés, et quelles opérations ont un sens sur elle.

La liste des types du C est courte. La complexité est dans les modificateurs.

Les quatre types de base

#include <stdio.h>

int main(void) {
    char  initial = 'K';        /* un caractere / un octet */
    int   count   = 42;         /* nombre entier */
    float ratio   = 3.14f;      /* decimal, simple precision */
    double precise = 3.141592653589793;  /* decimal, double precision */

    printf("char   : %c\n", initial);
    printf("int    : %d\n", count);
    printf("float  : %f\n", ratio);
    printf("double : %.15f\n", precise);
    return 0;
}

• char contient un octet. Il sert aux caractères isolés ('A'), aux octets d'une chaîne, et parfois de tout petit entier.
• int est le type entier de travail. Compteurs de boucle, tailles, identifiants.
• float et double contiennent des nombres réels. double a environ deux fois plus de précision.
• void est en un sens le quatrième type, mais il signifie « aucune valeur » - vous ne pouvez pas déclarer une variable void, seulement l'utiliser comme type de retour de fonction, comme liste de paramètres vide, ou comme pointeur sans type.

Notez le suffixe f sur 3.14f. Sans lui, le littéral est un double, et l'affecter à un float perd de la précision silencieusement. Certains compilateurs avertissent.

Modificateurs : short, long, unsigned

Les types entiers de base viennent avec des modificateurs qui changent la taille ou le signe.

#include <stdio.h>

int main(void) {
    short small = 32000;
    int normal = 2000000;
    long big = 2000000000L;
    long long huge = 9000000000000000000LL;

    unsigned int positive_only = 4000000000U;

    printf("short        : %hd\n", small);
    printf("int          : %d\n", normal);
    printf("long         : %ld\n", big);
    printf("long long    : %lld\n", huge);
    printf("unsigned int : %u\n", positive_only);
    return 0;
}

Chaque type entier a son propre spécificateur de format : %hd pour short, %d pour int, %ld pour long, %lld pour long long, %u pour unsigned. Utiliser le mauvais est un comportement indéfini, pas une erreur d'arrondi.

unsigned supprime le bit de signe et double la plage positive. Un unsigned int contient de 0 à environ 4,3 milliards au lieu de -2,1 à +2,1 milliards. C'est le bon choix pour ce qui ne peut réellement pas être négatif - tailles, comptes d'octets, motifs de bits - et un piège pour tout ce qui pourrait être soustrait en dessous de zéro.

signed est la valeur par défaut pour int, short, long et long long, vous ne l'écrivez donc presque jamais. Le seul endroit où cela compte est char : le fait qu'un char simple soit signé ou non est défini par l'implémentation, alors écrivez signed char ou unsigned char quand le signe compte.

Tailles : ce que vous obtenez réellement

La norme C spécifie des minimums, pas des tailles exactes. Sur toute machine moderne 64 bits sous Linux, macOS ou Windows, vous verrez ceci :

La ligne long est celle qui piège : 8 octets sous Linux et macOS, et 4 octets sous Windows 64 bits. Du code qui suppose que long peut contenir une valeur 64 bits n'est pas portable. Utilisez long long, ou les types de largeur exacte de stdint.h (int32_t, uint64_t) quand la taille fait partie de l'exigence.

sizeof : demandez au compilateur

Ne devinez jamais une taille - mesurez-la :

#include <stdio.h>

int main(void) {
    printf("char      : %zu octet(s)\n", sizeof(char));
    printf("short     : %zu octets\n", sizeof(short));
    printf("int       : %zu octets\n", sizeof(int));
    printf("long      : %zu octets\n", sizeof(long));
    printf("long long : %zu octets\n", sizeof(long long));
    printf("float     : %zu octets\n", sizeof(float));
    printf("double    : %zu octets\n", sizeof(double));
    printf("un pointeur : %zu octets\n", sizeof(int *));
    return 0;
}

sizeof est un opérateur, pas une fonction, et il est évalué à la compilation. Il produit une valeur de type size_t, qui s'affiche avec %zu.

sizeof(char) vaut exactement 1, c'est garanti - c'est la définition d'un octet en C. Tout le reste est mesuré par rapport à lui.

limits.h et float.h

Les plages exactes pour votre compilateur sont disponibles sous forme de constantes nommées :

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main(void) {
    printf("INT_MIN      = %d\n", INT_MIN);
    printf("INT_MAX      = %d\n", INT_MAX);
    printf("UINT_MAX     = %u\n", UINT_MAX);
    printf("LONG_MAX     = %ld\n", LONG_MAX);
    printf("CHAR_BIT     = %d bits par octet\n", CHAR_BIT);
    printf("FLT_DIG      = %d chiffres decimaux\n", FLT_DIG);
    printf("DBL_DIG      = %d chiffres decimaux\n", DBL_DIG);
    return 0;
}

Ce sont les valeurs auxquelles se comparer quand vous devez savoir si une opération va déborder. Vérifier if (a > INT_MAX - b) avant de calculer a + b est la façon de détecter un débordement avant qu'il n'arrive - ce qui compte, car on ne peut pas détecter un débordement signé après coup.

Le débordement d'entier

Ce qui se passe quand une valeur dépasse la plage de son type dépend entièrement du signe.

Le débordement non signé est défini : la valeur boucle modulo 2^N.

#include <stdio.h>
#include <limits.h>

int main(void) {
    unsigned int u = UINT_MAX;
    printf("UINT_MAX     = %u\n", u);
    printf("UINT_MAX + 1 = %u\n", u + 1);   /* garanti a 0 */

    unsigned int zero = 0;
    printf("0 - 1        = %u\n", zero - 1); /* boucle vers UINT_MAX */
    return 0;
}

Ce second cas est une vraie source de bugs. Une boucle comme for (unsigned i = n - 1; i >= 0; i--) ne se termine jamais, car une valeur non signée est toujours >= 0.

Le débordement signé est un comportement indéfini. Pas « il boucle » - indéfini. Le compilateur est autorisé à supposer que cela n'arrive jamais et à optimiser sur cette base, ce qui signifie qu'une vérification de débordement écrite après coup peut être supprimée :

int sum = a + b;
if (sum < a) { /* le compilateur peut supprimer entierement ceci */ }

Vérifiez avant, en utilisant les limites :

if (b > 0 && a > INT_MAX - b) {
    /* a + b deborderait - gerez-le */
}

La précision en virgule flottante

float et double stockent les nombres en binaire, et la plupart des fractions décimales n'ont pas de forme binaire exacte - de la même façon que 1/3 n'a pas de forme décimale exacte.

#include <stdio.h>

int main(void) {
    double a = 0.1;
    double b = 0.2;
    double sum = a + b;

    printf("0.1 + 0.2 = %.20f\n", sum);
    printf("Est-ce 0.3 ? %s\n", (sum == 0.3) ? "oui" : "non");

    /* La bonne facon : comparer avec une tolerance. */
    double diff = sum - 0.3;
    if (diff < 0) diff = -diff;
    printf("Assez proche ? %s\n", (diff < 1e-9) ? "oui" : "non");
    return 0;
}

La règle qui en découle : ne comparez jamais des valeurs flottantes avec ==. Comparez plutôt la différence absolue à une petite tolérance.

Et n'utilisez jamais de flottant pour de l'argent. Stockez les centimes en entier ; un long long de centimes est exact là où un double d'euros ne l'est pas.

Choisir un type

Une courte liste de décision qui couvre la plupart du code :

• Nombres entiers : int sauf raison contraire. C'est le type que le processeur traite le plus efficacement et celui autour duquel toutes les règles arithmétiques sont construites.
• Tout ce qui dépasse 2 milliards : long long, ou int64_t de stdint.h.
• Tailles, longueurs, indices de tableaux issus de sizeof ou strlen : size_t. Il est non signé et garanti assez grand pour n'importe quel objet.
• Décimaux : double. N'utilisez float que pour diviser la mémoire par deux dans de grands tableaux ou sur du matériel embarqué sans unité double précision.
• Caractères isolés et octets bruts : char pour le texte, unsigned char pour les données binaires.
• Vrai/faux : bool de stdbool.h - voir les booléens en C.
• Largeurs de bits exactes (formats de fichiers, protocoles réseau, registres matériels) : stdint.h - uint8_t, int16_t, uint32_t, et ainsi de suite.

#include <stdio.h>
#include <stdint.h>

int main(void) {
    uint8_t  flags = 0xFF;          /* exactement 8 bits, non signe */
    int32_t  offset = -100000;      /* exactement 32 bits, signe */
    uint64_t file_size = 5000000000ULL;

    printf("flags     : %u\n", flags);
    printf("offset    : %d\n", offset);
    printf("file_size : %llu octets\n", (unsigned long long)file_size);
    return 0;
}

Mélanger les types

Quand vous combinez deux types différents dans une expression, le C les convertit dans votre dos avant de faire l'arithmétique. C'est généralement utile et parfois désastreux :

#include <stdio.h>

int main(void) {
    int a = 7, b = 2;

    printf("7 / 2 en int     = %d\n", a / b);        /* 3, pas 3.5 */
    printf("7 / 2 avec 2.0   = %f\n", a / 2.0);      /* 3.5 */

    int  small = -1;
    unsigned int big = 1;
    printf("-1 < 1u ? %s\n", (small < big) ? "oui" : "non");  /* surprenant */
    return 0;
}

Le premier cas est une division entière : les deux opérandes sont des int, donc le résultat est un int et la fraction est jetée. Le troisième est pire - comparer une valeur signée avec une non signée convertit la signée en non signée, transformant -1 en un nombre positif énorme.

Ces règles de conversion, et comment en prendre le contrôle avec des casts explicites, font l'objet de transtypage en C.