Qu'est-ce que size_t en C?

Je m'embrouille avec size_ten C. Je sais qu'il est retourné par l' sizeofopérateur. mais qu'est ce que c'est exactement? S'agit-il d'un type de données?

Disons que j'ai une forboucle:

for(i = 0; i < some_size; i++)

Dois-je utiliser int i;ou size_t i;?

De Wikipédia :

Selon la norme ISO C 1999 (C99), size_test un type entier non signé d'au moins 16 bits (voir sections 7.17 et 7.18.3).

size_test un type de données non signé défini par plusieurs normes C / C ++, par exemple la norme C99 ISO / IEC 9899, ​​définie dans stddef.h. 1 Il peut encore être importé en l'incluant stdlib.hcomme ce fichier en interne comprend stddef.h.

Ce type est utilisé pour représenter la taille d'un objet. Les fonctions de bibliothèque qui prennent ou retournent des tailles s'attendent à ce qu'elles soient de type ou aient le type de retour size_t. De plus, la taille d'opérateur basée sur le compilateur la plus fréquemment utilisée doit être évaluée à une valeur constante compatible avec size_t.

Comme implication, size_test un type garanti pour contenir n'importe quel index de tableau.

size_test un type non signé. Ainsi, il ne peut représenter aucune valeur négative (<0). Vous l'utilisez lorsque vous comptez quelque chose et êtes sûr qu'il ne peut pas être négatif. Par exemple, strlen()renvoie a size_tcar la longueur d'une chaîne doit être d'au moins 0.

Dans votre exemple, si votre index de boucle va toujours être supérieur à 0, il peut être judicieux d'utiliser size_t, ou tout autre type de données non signé.

Lorsque vous utilisez un size_tobjet, vous devez vous assurer que dans tous les contextes où il est utilisé, y compris l'arithmétique, vous souhaitez des valeurs non négatives. Par exemple, supposons que vous ayez:

size_t s1 = strlen(str1);
size_t s2 = strlen(str2);

et vous voulez trouver la différence des longueurs de str2et str1. Tu ne peux pas faire:

int diff = s2 - s1; /* bad */

En effet, la valeur affectée à diffsera toujours un nombre positif, même lorsque s2 < s1, car le calcul est effectué avec des types non signés. Dans ce cas, en fonction de votre cas d'utilisation, il est préférable d'utiliser int(ou long long) pour s1et s2.

Certaines fonctions de C / POSIX pourraient / devraient être utilisées size_t, mais pas pour des raisons historiques. Par exemple, le deuxième paramètre à fgetsdevrait idéalement être size_t, mais il l'est int.

size_t est un type qui peut contenir n'importe quel index de tableau.

Selon l'implémentation, il peut s'agir de:

unsigned char

unsigned short

unsigned int

unsigned long

unsigned long long

Voici comment size_test défini dans stddef.hma machine:

typedef unsigned long size_t;

Si vous êtes du type empirique ,

echo | gcc -E -xc -include 'stddef.h' - | grep size_t

Sortie pour Ubuntu 14.04 64-bit GCC 4.8:

typedef long unsigned int size_t;

Notez que cela stddef.hest fourni par GCC et non par la glibc src/gcc/ginclude/stddef.hdans GCC 4.2.

Apparitions C99 intéressantes

• mallocprend size_tcomme argument, il détermine donc la taille maximale qui peut être allouée.

  Et comme il est également renvoyé par sizeof, je pense qu'il limite la taille maximale de tout tableau.

  Voir aussi: Quelle est la taille maximale d'un tableau en C?

La page de manuel de types.h indique:

size_t doit être un type entier non signé

Puisque personne ne l'a encore mentionné, la signification linguistique principale de size_test que l' sizeofopérateur renvoie une valeur de ce type. De même, la signification principale de ptrdiff_test que la soustraction d'un pointeur à un autre donnera une valeur de ce type. Les fonctions de bibliothèque qui l'acceptent le font car cela permettra à ces fonctions de fonctionner avec des objets dont la taille dépasse UINT_MAX sur les systèmes où de tels objets pourraient exister, sans forcer les appelants à perdre du code en passant une valeur supérieure à "unsigned int" sur les systèmes où le type plus grand suffirait pour tous les objets possibles.

Pour expliquer pourquoi il size_tfallait exister et comment nous en sommes arrivés là:

En termes pragmatiques, size_tet ptrdiff_tsont garantis à 64 bits de large sur une implémentation 64 bits, 32 bits de large sur une implémentation 32 bits, et ainsi de suite. Ils ne pouvaient forcer aucun type existant à signifier cela, sur chaque compilateur, sans casser le code hérité.

Un size_tou ptrdiff_tn'est pas nécessairement le même qu'un intptr_tou uintptr_t. Ils étaient différents sur certaines architectures qui étaient encore en usage quand size_tet ptrdiff_tont été ajoutés à la norme à la fin des années 80, et devenant obsolètes lorsque C99 a ajouté de nombreux nouveaux types mais pas encore disparus (tels que Windows 16 bits). Le x86 en mode protégé 16 bits avait une mémoire segmentée où la plus grande matrice ou structure possible ne pouvait avoir qu'une taille de 65 536 octets, mais un farpointeur devait avoir une largeur de 32 bits, plus large que les registres. Sur ceux-ci, intptr_taurait été de 32 bits de large mais size_tetptrdiff_tpourrait avoir une largeur de 16 bits et rentrer dans un registre. Et qui savait quel type de système d'exploitation pourrait être écrit à l'avenir? En théorie, l'architecture i386 propose un modèle de segmentation 32 bits avec des pointeurs 48 bits qu'aucun système d'exploitation n'a jamais réellement utilisé.

Le type d'un décalage de mémoire ne peut pas être longdû au fait que trop de code hérité suppose une longlargeur exacte de 32 bits. Cette hypothèse a même été intégrée aux API UNIX et Windows. Malheureusement, beaucoup d'autres codes hérités supposaient également que a longest suffisamment large pour contenir un pointeur, un décalage de fichier, le nombre de secondes qui se sont écoulées depuis 1970, etc. POSIX fournit désormais un moyen normalisé de forcer la dernière hypothèse à être vraie au lieu de la première, mais aucune hypothèse portable n'est à faire.

Cela ne pouvait pas être intparce que seule une petite poignée de compilateurs dans les années 90 faisaient int64 bits de large. Ensuite, ils sont vraiment devenus étranges en gardant une longlargeur de 32 bits. La prochaine révision de la norme l'a déclarée illégale pour intêtre plus large que long, mais elle intest toujours de 32 bits sur la plupart des systèmes 64 bits.

Il ne pouvait pas l'être long long int, ce qui a été ajouté de toute façon plus tard, car il a été créé pour être d'au moins 64 bits, même sur les systèmes 32 bits.

Donc, un nouveau type était nécessaire. Même si ce n'était pas le cas, tous ces autres types signifiaient autre chose qu'un décalage dans un tableau ou un objet. Et s'il y avait une leçon à tirer du fiasco de la migration de 32 à 64 bits, c'était de préciser les propriétés qu'un type devait avoir et de ne pas en utiliser une qui signifiait différentes choses dans différents programmes.

size_tet intne sont pas interchangeables. Par exemple, sur 64 bits, Linux a une size_ttaille de 64 bits (c'est-à-dire sizeof(void*)) mais intest de 32 bits.

Notez également que ce size_tn'est pas signé. Si vous avez besoin d'une version signée, il y en a ssize_tsur certaines plates-formes et cela serait plus pertinent pour votre exemple.

En règle générale, je suggérerais d'utiliser la intplupart des cas généraux et de n'utiliser size_t/ que ssize_tlorsqu'il y a un besoin spécifique (avec mmap()par exemple).

En général, si vous commencez à 0 et montez, utilisez toujours un type non signé pour éviter un débordement vous entraînant dans une situation de valeur négative. Ceci est extrêmement important, car si les limites de votre tableau s'avèrent être inférieures au maximum de votre boucle, mais que votre maximum de boucle se trouve être supérieur au maximum de votre type, vous passerez à négatif et vous pourrez rencontrer une erreur de segmentation (SIGSEGV ). Donc, en général, n'utilisez jamais int pour une boucle commençant à 0 et remontant. Utilisez un non signé.

size_t est un type de données entier non signé. Sur les systèmes utilisant la bibliothèque GNU C, ce sera int non signé ou entier long non signé. size_t est couramment utilisé pour l'indexation de tableaux et le comptage de boucles.

size_t ou tout type non signé peut être considéré comme une variable de boucle car les variables de boucle sont généralement supérieures ou égales à 0.

Lorsque nous utilisons un objet size_t , nous devons nous assurer que dans tous les contextes où il est utilisé, y compris l'arithmétique, nous ne voulons que des valeurs non négatives. Par exemple, le programme suivant donnerait certainement le résultat inattendu:

// C program to demonstrate that size_t or
// any unsigned int type should be used 
// carefully when used in a loop

#include<stdio.h>
int main()
{
const size_t N = 10;
int a[N];

// This is fine
for (size_t n = 0; n < N; ++n)
a[n] = n;

// But reverse cycles are tricky for unsigned 
// types as can lead to infinite loop
for (size_t n = N-1; n >= 0; --n)
printf("%d ", a[n]);
}

Output
Infinite loop and then segmentation fault

size_test un type de données entier non signé qui ne peut affecter que 0 et plus de 0 valeurs entières. Il mesure les octets de la taille de n'importe quel objet et est retourné par l' sizeofopérateur. constest la représentation syntaxique de size_t, mais sans constvous pouvez exécuter le programme.

const size_t number;

size_trégulièrement utilisé pour l'indexation de tableaux et le comptage de boucles. Si le compilateur fonctionne, 32-bitil fonctionnerait unsigned int. Si le compilateur fonctionne, 64-bitil fonctionnerait unsigned long long intégalement. Il existe une taille maximale en size_tfonction du type de compilateur.

size_tdéfinir déjà sur le <stdio.h>fichier d' en- tête, mais il peut également définir par <stddef.h>, <stdlib.h>, <string.h>, <time.h>, les en- <wchar.h>têtes.

• Exemple (avec const)

#include <stdio.h>

int main()
{
    const size_t value = 200;
    size_t i;
    int arr[value];

    for (i = 0 ; i < value ; ++i)
    {
        arr[i] = i;
    }

    size_t size = sizeof(arr);
    printf("size = %zu\n", size);
}

Production -: size = 800

• Exemple (sans const)

#include <stdio.h>

int main()
{
    size_t value = 200;
    size_t i;
    int arr[value];

    for (i = 0 ; i < value ; ++i)
    {
        arr[i] = i;
    }

    size_t size = sizeof(arr);
    printf("size = %zu\n", size);
}

Production -: size = 800

D'après ma compréhension, size_test un unsignedentier dont la taille en bits est suffisamment grande pour contenir un pointeur de l'architecture native.

Donc:

sizeof(size_t) >= sizeof(void*)