Quelle est la différence entre size_t et int en C++ ?

Question

Dans plusieurs exemples C++, je vois une utilisation du type size_t où j'aurais utilisé un simple int.Quelle est la différence et pourquoi size_t devrait être meilleur ?

Answer 1

De la Wikipédia conviviale :

  

Les fichiers d'en-tête stdlib.h et stddef.h définissent un type de données appelé size_t , utilisé pour représenter la taille d'un objet. Les fonctions de bibliothèque prenant des tailles s’attendent à ce qu’elles soient de type size_t, et l’opérateur sizeof est évalué à size_t.

     

Le type actuel de size_t dépend de la plate-forme. Une erreur courante est de supposer que size_t est identique à unsigned int, ce qui peut entraîner des erreurs de programmation, notamment lorsque les architectures 64 bits deviennent plus courantes.

Vérifiez également Pourquoi la taille est importante

Answer 2

size_t est le type utilisé pour représenter les tailles (comme son nom l’indique). Sa plate-forme (et même potentiellement sa mise en œuvre) dépend, et ne devrait être utilisée qu’à cette fin. Évidemment, représentant une taille, size_t est non signé. De nombreuses fonctions stdlib, y compris malloc, sizeof et diverses opérations sur les chaînes, utilisent size_t comme type de données.

Un int est signé par défaut et, même si sa taille dépend également de la plate-forme, il sera fixe à 32 bits sur la machine la plus moderne (et bien que size_t soit 64 bits sur une architecture 64 bits, int restera 32 bits sur ces architectures. ).

Pour résumer: utilisez size_t pour représenter la taille d'un objet et int (ou long) dans les autres cas.

Answer 3

C'est parce que size_t peut être autre chose qu'un int (peut-être une structure). L’idée est qu’il sépare son travail du type sous-jacent.

Answer 4

Le size_t type est défini comme le type intégral non signé du sizeof opérateur.Dans le monde réel, vous verrez souvent int défini comme 32 bits (pour une compatibilité ascendante) mais size_t défini comme 64 bits (vous pouvez donc déclarer des tableaux et des structures de plus de 4 Gio) sur les plates-formes 64 bits.Si un long int est également 64 bits, c'est ce qu'on appelle la convention LP64 ;si long int est de 32 bits mais long long int et les pointeurs sont en 64 bits, c'est LLP64.Vous pourriez également obtenir l'inverse, un programme qui utilise des instructions 64 bits pour la vitesse, mais des pointeurs 32 bits pour économiser de la mémoire.Aussi, int est signé et size_t n'est pas signé.

Il existait historiquement un certain nombre d'autres plates-formes où les adresses étaient plus larges ou plus courtes que la taille native de l'utilisateur. int.En fait, dans les années 70 et au début des années 80, c’était plus courant qu’autrement :tous les micro-ordinateurs 8 bits populaires avaient des registres 8 bits et des adresses 16 bits, et la transition entre 16 et 32 ​​bits a également produit de nombreuses machines dont les adresses étaient plus larges que leurs registres.Je vois encore parfois des questions ici sur Borland Turbo C pour MS-DOS, dont le mode mémoire énorme avait des adresses 20 bits stockées en 32 bits sur un processeur 16 bits (mais qui pouvait prendre en charge le jeu d'instructions 32 bits du 80386) ;le Motorola 68000 avait une ALU 16 bits avec des registres et des adresses 32 bits ;il y avait des mainframes IBM avec des adresses 15 bits, 24 bits ou 31 bits.Vous voyez également toujours différentes tailles d'ALU et de bus d'adresse dans les systèmes embarqués.

À tout moment int est plus petit que size_t, et vous essayez de stocker la taille ou le décalage d'un fichier ou d'un objet très volumineux dans un unsigned int, il est possible que cela déborde et provoque un bug.Avec un int, il y a aussi la possibilité d'obtenir un nombre négatif.Si un int ou unsigned int est plus large, le programme fonctionnera correctement mais gaspillera de la mémoire.

Vous devez généralement utiliser le type approprié si vous souhaitez la portabilité.Beaucoup de gens vous recommanderont d'utiliser des mathématiques signées plutôt que non signées (pour éviter des bugs désagréables et subtils comme 1U < -3).A cet effet, la bibliothèque standard définit ptrdiff_t dans <stddef.h> comme type signé du résultat de la soustraction d’un pointeur à un autre.

Cela dit, une solution de contournement pourrait consister à vérifier les limites de toutes les adresses et décalages par rapport à INT_MAX et soit 0 ou INT_MIN le cas échéant, et activez les avertissements du compilateur concernant la comparaison des quantités signées et non signées au cas où vous en manqueriez.De toute façon, vous devriez toujours, toujours, toujours vérifier les accès à votre tableau pour détecter tout débordement en C.

Answer 5

La définition de SIZE_T se trouve à: https://msdn.microsoft.com/en-us/library/cc441980. aspx et https://msdn.microsoft.com/en- us / library / cc230394.aspx

Collez ici les informations requises:

ULONG_PTR est un <=> représentant le nombre maximal d'octets vers lesquels un pointeur peut pointer.

Ce type est déclaré comme suit:

typedef ULONG_PTR SIZE_T;

Un <=> est un type long non signé utilisé pour la précision du pointeur. Il est utilisé lors de la conversion d'un pointeur sur un type long pour effectuer une arithmétique de pointeur.

Ce type est déclaré comme suit:

typedef unsigned __int3264 ULONG_PTR;