Ajout ou affectation d'un littéral entier à size_t

Question

En C, je vois beaucoup de code qui ajoute ou affecte un littéral entier à une variable size_t.

size_t foo = 1; 
foo += 1; 

Quelle conversion a lieu ici, et peut-il jamais arriver qu'un size_t est « mis à jour » à un int puis reconverti en un size_t? Serait-ce encore enveloppant si j'étais au maximum?

size_t foo = SIZE_MAX; 
foo += 1; 

Est-ce que ce comportement est défini? Il s'agit d'un type non signé size_t qui a un int signé ajouté (qui peut être un type plus grand?) Et le converti en size_t. Y a-t-il un risque de débordement d'entier signé?

Serait-il logique d'écrire quelque chose comme foo + bar + (size_t)1 au lieu de foo + bar + 1? Je ne vois jamais de code comme ça, mais je me demande si c'est nécessaire si les promotions entières sont gênantes.

C89 ne dit pas comment un size_t sera Ranked ou exactement ce qu'il est:

La valeur du résultat est défini par l'implémentation, et son type (un type intégral non signé) est size_t défini dans l'en-tête.

Answer 1

La norme actuelle de C permet une possibilité d'une mise en œuvre qui provoquerait un comportement non défini lors de l'exécution du code suivant, mais cette mise en œuvre n'existe pas, et ne sera probablement jamais:

size_t foo = SIZE_MAX; 
foo += 1; 

Le size_t type est aussi type non signé , avec une plage minimum: [0,65535].

Le type size_t peut être défini comme un synonyme du type unsigned short. Le type unsigned short peut être défini avec 16 bits de précision, avec la plage: [0,65535]. Dans ce cas, la valeur de SIZE_MAX est 65535.

Le type int peut être défini avec 16 bits de précision (plus un bit de signe), une représentation complémentaire à deux et une plage: [-65536,65535].

L'expression foo + = 1 équivaut à foo = foo + 1 (sauf que foo est évalué une seule fois mais cela n'a pas d'importance ici). La variable foo sera promue en utilisant des promotions entières . Il sera promu au type int parce que le type int peut représenter toutes les valeurs de type size_t et le rang de size_t, étant synonyme de short non signé, est inférieur au rang de int. Comme les valeurs maximales de size_t et int sont les mêmes, le calcul provoque un dépassement de capacité signé, ce qui provoque un comportement indéfini.

Ceci est valable pour la norme actuelle, et devrait également s'appliquer à C89 car il n'y a pas de restrictions plus strictes sur les types.

Solution pour éviter le débordement signé pour toute mise en œuvre imaginable est d'utiliser une constante entier non signé int:

foo += 1u; 

Dans ce cas, si foo a un rang inférieur int, il sera promu unsigned int en utilisant d'habitude conversions arithmétiques.

---

(cité de la norme ISO/IEC 9899/201x 7,19 définitions communes 2)

de size_t qui est le type entier non signé du résultat de l'opérateur sizeof;

(Cité de la norme ISO/IEC 9899/201x 7.20.3 Limites des autres types entiers 2)
limites de size_t
SIZE_MAX 65535

(Cité de la norme ISO/IEC 9899/201x 6.3.1.1 Booléen, caractères et nombres entiers 2)
Les expressions suivantes peuvent être utilisées dans une expression où un entier int ou unsigned peut être utilisé: :
Un objet ou une expression de type entier (autre que int ou unsigned int) dont le rang de conversion entier est inférieur ou égal au rang de int et unsigned int.
Si un entier peut représenter toutes les valeurs du type d'origine (limité par la largeur, pour un champ de bits ), la valeur est convertie en int; sinon, il est converti en un entier non signé . Ceux-ci sont appelés les promotions entières. Tous les autres types sont inchangés par les promotions entières .

Answer 2

Cela dépend, car size_t est un type intégral non signé défini par l'implémentation.

Les opérations impliquant un size_t introduiront donc des promotions, mais celles-ci dépendent de ce que sont effectivement size_t et des autres types impliqués dans l'expression.

Si size_t était équivalent à un unsigned short (par exemple un type 16 bits), puis

size_t foo = 1; 
foo += 1; 

serait (sémantiquement) promouvoir foo à un int, ajouter 1, puis convertir le résultat à size_t pour le stockage au foo. (Je dis "sémantiquement", parce que c'est la signification du code selon la norme.) Un compilateur est libre d'appliquer la règle "comme si" - c'est-à-dire faire ce qu'il veut, pourvu qu'il produise le même effet net).

D'un autre côté, si size_t était équivalent à un long long unsigned (par exemple un type signé 64 bits), le même code favoriserait 1 être de type long long unsigned, l'ajouter à la valeur de foo, et stocker le résultat retour au foo. Dans les deux cas, le résultat net est le même sauf si un débordement se produit. Dans ce cas, il n'y a pas de débordement, étant donné qu'un int et size_t sont garantis capables de représenter les valeurs 1 et 2.

Si un dépassement survient (par exemple en ajoutant une valeur intégrale plus grande), alors le comportement peut varier. Le dépassement d'un type intégral signé (par exemple int) entraîne un comportement indéfini. Le dépassement d'un type intégral unsigned utilise l'arithmétique modulo.

En ce qui concerne le code

size_t foo = SIZE_MAX; 
foo += 1; 

il est possible de faire le même genre d'analyse.

Si size_t est équivalent à unsigned short, alors foo sera converti en int. Si int est équivalent à signed short, il ne peut pas représenter la valeur SIZE_MAX, de sorte que la conversion déborde et le résultat est un comportement indéfini. Si int est en mesure de représenter une plus grande plage que short int (par exemple, il est équivalent à long), puis la conversion de foo à int réussira, incrémenter cette valeur réussira, et le stockage de retour à size_t utilisera l'arithmétique modulo et produire le résultat de 0.

Si size_t est équivalent à unsigned long, alors la valeur 1 seront automatiquement converties en unsigned long, ajoutant à foo utilisera arithmétique modulo (à savoir produire un résultat égal à zéro), et qui seront stockées dans foo.

Il est possible de faire des analyses similaires en supposant que size_t est réellement d'autres types intégraux non signés.

Remarque: Dans les systèmes modernes, un size_t de même taille ou plus petit qu'un int est inhabituel. Toutefois, de tels systèmes ont existé (par exemple, les compilateurs Microsoft et Borland C qui ciblent MS-DOS 16 bits sur du matériel avec un processeur 80286). Des microprocesseurs 16 bits sont encore en production, principalement pour les systèmes embarqués à faible consommation d'énergie et à faible débit, et les compilateurs C qui les ciblent (par exemple le compilateur Keil C166 qui cible la famille de microprocesseurs Infeon XE166). [Note: Je n'ai jamais eu de raison d'utiliser le compilateur Keil mais, étant donné sa plate-forme cible, il ne serait pas surprenant qu'il prenne en charge un size_t 16 bits de même taille ou plus petit que le type natif int sur cette plate-forme ]

Answer 3

foo += 1 signifie foo = foo + 1. Si size_t est plus étroit que int (c'est-à int peut représenter toutes les valeurs de size_t), alors foo est promu à int dans l'expression foo + 1.

La seule façon dont cela pourrait déborder est si INT_MAX == SIZE_MAX. Théoriquement, cela est possible, par ex. Int 16 bits et 15 bits size_t. (Ce dernier aurait probablement 1 bit de remplissage).

Plus probablement, SIZE_MAX sera inférieur à INT_MAX, de sorte que le code sera défini par l'implémentation en raison de la cession hors de portée. Normalement, la définition d'implémentation est la plus "évidente", les bits élevés sont ignorés, donc le résultat sera 0. Comme décision pratique, je ne recommanderais pas mangling votre code pour répondre à ces cas (15 bits size_t, ou définition d'implémentation non évidente) qui ne sont probablement jamais arrivé et ne le sera jamais. Au lieu de cela, vous pourriez faire des tests de compilation qui donneront une erreur si ces cas se produisent. Une affirmation au moment de la compilation que INT_MAX < SIZE_MAX serait pratique à ce jour et l'âge.