Choisir un type entier approprié en C et C

Introduction

Lorsque Dennis Ritchie a créé C, il a fait de int (un type entier signé) le type par défaut. La taille (nombre de bits) d'un int a été délibérément non spécifiée. Même lorsque C était standardisé, tout ce qui était garanti était une taille minimale. Le raisonnement était que la taille de int devait être la taille « naturelle » d’un mot pour un entier sur un processeur donné.

Si vous n'aviez besoin que d'entiers signés plus petits et que vous vouliez économiser un peu d'espace, Ritchie nous a donné court ; ou, si vous aviez besoin de plus grands entiers, il nous a donné long. (C99 nous a donné des entiers encore plus grands avec long long.) Si vous n'aviez besoin que d'entiers non signés, vous pouvez inclure unsigned dans une déclaration. C99 nous a également fourni des alias de type entier signé de taille spécifique (par exemple, int32_t) et des alias de type non signé (par exemple, uint32_t).

Cependant, en programmation, les entiers négatifs (nécessitant donc un type entier signé) ne sont pas nécessaires la plupart du temps. La longueur des chaînes, le nombre d'objets, la taille des objets, la taille des fichiers, etc., sont tous des entiers non signés. Les alias de type de taille spécifique sont encore moins nécessaires que les entiers signés.

Pourtant, j'ai vu beaucoup de code qui utilise des types entiers de manière inappropriée. Un tel code peut transmettre des informations sous-spécifiées ou trompeuses aux lecteurs (y compris vous-même dans plusieurs mois). Il est préférable de choisir le bon type entier pour le bon objectif.

Lignes directrices

Voici mes directives pour choisir un type entier :

• Lorsque vous représentez un nombre d'octets en mémoire, utilisez l'alias de type standard size_t.

Il s'agit du type utilisé par les bibliothèques standard C et C, par exemple par memcpy(), strlen(), std::string::size(), etc., il existe donc de nombreux précédents.

• Lorsque vous représentez la taille ou une position dans un fichier sur le disque, utilisez l'alias de type off_t POSIX.

Si vous avez affaire à des fichiers très volumineux, sur certaines plates-formes, vous devrez peut-être compiler avec -D_FILE_OFFSET_BITS=64 pour obtenir une version 64 bits de off_t.

• Lorsque vous représentez un nombre d'objets en mémoire, utilisez également size_t.

C'est également le type utilisé par les bibliothèques standard C et C, par exemple par fread() et fwrite().

• Seulement si vous devez représenter une valeur contenue dans un nombre spécifique de bits ou si vous devez vous conformer à une API spécifique, utilisez l'un des alias de type int8_t, int16_t, int32_t ou int64_t pour les types signés ; ou l'un des alias de type uint8_t, uint16_t, uint32_t ou uint64_t pour les types non signés.

Les seules fois où vous avez généralement besoin d'un entier de taille fixe, c'est lorsque vous « externalisez » une valeur, par exemple lorsque vous l'écrivez sur le disque ou l'envoyez via un socket.

L'utilisation d'un entier de taille fixe alors que vous n'avez pas réellement besoin d'un nombre spécifique de bits transmet des informations erronées au lecteur.

De plus :

• Lorsque vous représentez une valeur entière qui doit être la taille exacte d'un pointeur, utilisez l'alias de type intptr_t ou uintptr_t standard.

• Seulement si vous avez besoin de valeurs négatives, utilisez l'une des valeurs suivantes : short, int, long ou long long, int étant préféré, sauf si vous avez besoin de valeurs plus petites ou plus grandes.

Enfin :

• Sinon, utilisez l'un des types suivants : non signé court, non signé, non signé long ou non signé long long de la même manière, non signé étant préféré, sauf si vous avez besoin de valeurs plus petites ou plus grandes.

Autrement dit, à moins que vous n'ayez affaire à l'un des cas répertoriés ci-dessus, utilisez par défaut des types non signés.

Conclusion

Choisir le bon type d'entier transmet des informations correctes au lecteur et peut éliminer les contrôles d'exécution.

Épilogue

À l'origine, et jusqu'à C99, int était le type implicite, c'est-à-dire que si vous ne spécifiiez aucun type, il était compris comme étant int. Par exemple :

power( x, n )  /* x and n are int; returns int */
{
    int p;
    for ( p = 1; n > 0; --n )
        p *= x;
    return p;
}

définit une fonction qui a des paramètres int et renvoie int, mais int n'est pas utilisé dans la déclaration.

Les prototypes de fonctions ont été rétroportés de C à C89, mais les définitions de fonctions originales de « style K&R » étaient toujours autorisées jusqu'à C23. Le comité ANSI C est un groupe conservateur.

Encore plus étrange, avant C99, il était également permis à int d'être implicite dans des déclarations telles que :

i;      // int i
*p;     // int *p
*a[4];  // int *a[4]
*f();   // int *f()

Heureusement, de telles déclarations sont illégales depuis longtemps.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!