Non, interdire les types d'entiers intégrés serait absurde. Cependant, ils ne doivent pas non plus être maltraités.
Si vous avez besoin d'un entier de exactement N bits de large, utilisez (ou si vous avez besoin d'une version). Considérer comme un entier 32 bits et comme un entier 64 bits est tout simplement faux. C'est peut-être le cas sur vos plates-formes actuelles, mais cela repose sur un comportement défini par l'implémentation.std::intN_t
std::uintN_t
unsigned
int
long long
L'utilisation de types entiers à largeur fixe est également utile pour interagir avec d'autres technologies. Par exemple, si certaines parties de votre application sont écrites en Java et d'autres en C ++, vous souhaiterez probablement faire correspondre les types d'entiers afin d'obtenir des résultats cohérents. (Gardez toujours à l'esprit que les débordements dans Java ont une sémantique bien définie, tandis que les signed
dépassements en C ++ représentent un comportement non défini. La cohérence est donc un objectif primordial.) Ils seront également précieux pour l'échange de données entre différents hôtes informatiques.
Si vous n'avez pas besoin exactement de N bits, mais simplement d'un type suffisamment large , envisagez d'utiliser (optimisé pour l'espace) ou (optimisé pour la vitesse). Encore une fois, les deux familles ont aussi leurs homologues.std::int_leastN_t
std::int_fastN_t
unsigned
Alors, quand utiliser les types prédéfinis? Eh bien, étant donné que la norme ne spécifie pas précisément leur largeur, utilisez-les lorsque vous ne vous souciez pas de la largeur réelle des bits, mais d’autres caractéristiques.
A char
est le plus petit entier adressable par le matériel. Le langage vous oblige en fait à l’utiliser pour aliaser de la mémoire arbitraire. C'est également le seul type viable pour représenter des chaînes de caractères (étroites).
An int
sera généralement le type le plus rapide que la machine puisse gérer. Il sera suffisamment large pour pouvoir être chargé et stocké avec une seule instruction (sans masquer ni décaler les bits) et suffisamment étroit pour pouvoir être utilisé avec les instructions matérielles (les plus efficaces). Par conséquent, int
est un choix parfait pour transmettre des données et faire du calcul lorsque les débordements ne sont pas un sujet de préoccupation. Par exemple, le type d'énumérations sous-jacent par défaut est int
. Ne le changez pas en un entier 32 bits simplement parce que vous le pouvez. De plus, si vous avez une valeur qui ne peut être que –1, 0 et 1, unint
est un choix parfait, sauf si vous allez en stocker d'énormes tableaux, auquel cas vous voudrez peut-être utiliser un type de données plus compact au prix de payer un prix plus élevé pour accéder à des éléments individuels. Une mise en cache plus efficace sera probablement rentable. De nombreuses fonctions du système d'exploitation sont également définies en termes de int
. Il serait stupide de convertir leurs arguments et leurs résultats dans les deux sens. Tout ce que cela pourrait faire serait d’ introduire des erreurs de débordement.
long
sera généralement le type le plus large pouvant être traité avec des instructions machine simples. Cela est particulièrement unsigned long
intéressant pour traiter des données brutes et toutes sortes de manipulations de bits. Par exemple, je m'attendrais à voir unsigned long
dans la mise en œuvre d'un vecteur de bits. Si le code est écrit avec soin, la largeur du type importe peu (car le code s'adapte automatiquement). Sur les plateformes où le mot machine natif est 32 bits, le tableau de sauvegarde du vecteur de bits étant un tableau deunsigned
Les entiers 32 bits sont les plus souhaitables car il serait idiot d'utiliser un type 64 bits qui doit être chargé via des instructions coûteuses uniquement pour décaler et masquer les bits inutiles. D'autre part, si la taille de mot native de la plate-forme est de 64 bits, je souhaite un tableau de ce type, car cela signifie que des opérations telles que «trouver le premier ensemble» peuvent être exécutées jusqu'à deux fois plus vite. Ainsi, le «problème» du long
type de données que vous décrivez, du fait que sa taille varie d'une plate-forme à l'autre, est en fait une fonctionnalité qui peut être utilisée à bon escient. Cela ne devient un problème que si vous considérez les types intégrés comme des types d'une certaine largeur de bit, ce qu'ils ne sont tout simplement pas.
char
, int
et long
sont des types très utiles comme décrit ci-dessus. short
et long long
ne sont pas aussi utiles parce que leur sémantique est beaucoup moins claire.
long
est le seul moyen de garantir 32 bits.int
peut être 16 bits, donc pour certaines applications, cela ne suffit pas. Oui,int
c’est parfois 16 bits sur les compilateurs modernes. Oui, les gens écrivent des logiciels sur des microcontrôleurs. Je dirais que plus de gens écrivent des logiciels qui ont plus d'utilisateurs sur des microcontrôleurs que sur des PC avec la montée des appareils iPhone et Android, sans parler de la montée des Arduinos, etc.int
reste encore beaucoup 16 bits. Je déteste le dire, mais si vous écrivez à propos du "monde multiplateforme d'aujourd'hui", vous ne pouvez pas ignorer le sous-continent indien dans son ensemble.