HOWTO · C
Différence entre entier non signé et entier signé en C
L'article suivant explorera les distinctions entre int signé et non signé dans le langage de programmation C.
Sur cette page
Un signed int peut représenter des valeurs négatives et positives, tandis qu’un unsigned int représente uniquement des valeurs non négatives. En C, int est signé par défaut : écrivez int pour un entier signé et unsigned int lorsque vous avez besoin d’un entier non signé. Le choix dépend des valeurs et des opérations arithmétiques dont votre programme a besoin. La différence semble minime — un type accepte le signe moins, l’autre non —, mais elle modifie aussi la plage de valeurs, ce qui se produit aux limites de cette plage et le comportement des expressions où les deux types sont mélangés.
Différence entre signed int et unsigned int en C
Les deux sont des types entiers, mais leurs plages de valeurs diffèrent. La norme C garantit que int peut représenter au minimum les valeurs de -32767 à 32767, et que unsigned int peut représenter au minimum celles de 0 à 65535. Ce sont des garanties minimales, pas les limites exactes de chaque système. Incluez limits.h et consultez INT_MIN, INT_MAX et UINT_MAX pour connaître les limites de l’implémentation utilisée pour la compilation.
| Type | Valeurs représentées | Plage minimale garantie par la norme |
|---|---|---|
int |
Valeurs négatives et non négatives | de -32767 à 32767 |
unsigned int |
Valeurs non négatives | de 0 à 65535 |
Les deux types occupent normalement la même taille de stockage : choisir entre eux ne crée donc pas davantage de place au total, mais décide de l’usage de cette place. Un type signé répartit ses valeurs entre nombres négatifs et positifs, tandis qu’un type non signé consacre toute sa plage aux valeurs non négatives, ce qui rend son maximum environ deux fois plus grand sur la même implémentation. Sur le système Linux 64 bits utilisé pour les exemples de cet article, les deux types occupent quatre octets, et l’affichage des limites donne les plages 32 bits bien connues :
#include <limits.h>
#include <stdio.h>
int main(void) {
printf("sizeof(int) = %zu\n", sizeof(int));
printf("sizeof(unsigned int) = %zu\n", sizeof(unsigned int));
printf("int range: %d to %d\n", INT_MIN, INT_MAX);
printf("unsigned int range: 0 to %u\n", UINT_MAX);
return 0;
}
sizeof(int) = 4
sizeof(unsigned int) = 4
int range: -2147483648 to 2147483647
unsigned int range: 0 to 4294967295
Considérez ces nombres exacts comme des propriétés de cette implémentation, et non du langage. Un code qui doit fonctionner partout devrait comparer avec INT_MIN, INT_MAX et UINT_MAX plutôt que d’écrire en dur des limites 32 bits.
Plages de valeurs et conversions
La plage réelle et la taille de stockage dépendent de l’implémentation. sizeof(int) et sizeof(unsigned int) n’ont pas nécessairement une taille de quatre octets, et C ne garantit pas que int comporte 32 bits. On ne peut pas affirmer de manière portable qu’un entier signé réserve son bit de gauche au signe : les détails de représentation dépendent de l’implémentation.
Lorsqu’une valeur négative est convertie vers un type non signé, le résultat est congru à cette valeur modulo UINT_MAX + 1. L’objet non signé contient donc une valeur non négative ; il ne conserve pas la valeur négative pour qu’une lecture ultérieure puisse la restituer. Les opérations arithmétiques non signées bouclent également modulo UINT_MAX + 1. L’exemple suivant applique cette règle de trois manières — convertir -1, soustraire en dessous de zéro et additionner au-delà du maximum :
#include <limits.h>
#include <stdio.h>
int main(void) {
unsigned int converted = -1;
unsigned int wrapped_down = 0u - 1u;
unsigned int wrapped_up = UINT_MAX + 1u;
printf("converted -1: %u\n", converted);
printf("0u - 1u: %u\n", wrapped_down);
printf("UINT_MAX + 1u: %u\n", wrapped_up);
return 0;
}
converted -1: 4294967295
0u - 1u: 4294967295
UINT_MAX + 1u: 0
Sur cette implémentation, -1 devient 4294967295, c’est-à-dire exactement UINT_MAX ; sur toute implémentation, le résultat est UINT_MAX lui-même, car -1 se trouve toujours un pas en dessous de zéro dans l’arithmétique modulo. Soustraire un à zéro boucle jusqu’à ce même maximum au lieu de produire -1, et ajouter un au maximum ramène à zéro. Aucune de ces opérations n’est une erreur : le bouclage est le comportement défini de l’arithmétique non signée.
Cet exemple complet utilise %d pour int et %u pour unsigned int. Il a été exécuté avec succès ; la sortie ci-dessous provient de cette exécution. Les libellés visibles dans l’exemple restent en anglais, car le bloc est conservé à l’identique.
#include <stdio.h>
int main(void) {
int temperature_change = -7;
unsigned int item_count = 42;
printf("Temperature change: %d\n", temperature_change);
printf("Item count: %u\n", item_count);
return 0;
}
Temperature change: -7
Item count: 42
Appliquez la règle de conversion ci-dessus pour déterminer le résultat de l’affectation d’une valeur négative à un type non signé ; la valeur exacte dépend de UINT_MAX. Passer un unsigned int à printf avec %d au lieu de %u ne correspond pas au format attendu et entraîne un comportement indéfini : le résultat affiché n’est donc pas fiable.
Dépassement : défini pour unsigned, indéfini pour signed
Le bouclage ci-dessus n’a pas d’équivalent signé. Le dépassement d’un entier signé — calculer un résultat au-dessus de INT_MAX ou en dessous de INT_MIN — est un comportement indéfini en C, et non un bouclage garanti. Les compilateurs optimisent en supposant qu’il ne se produit jamais, de sorte qu’un garde-fou consistant à vérifier si x + 1 est plus petit que x ne peut pas détecter de manière fiable un dépassement signé après coup. Si un calcul peut approcher des limites, vérifiez avant de calculer, par exemple en testant x > INT_MAX - y avant d’ajouter y à x, ou utilisez un type plus large. Cette asymétrie est une raison pratique de préférer les types signés pour l’arithmétique ordinaire : les erreurs sur des valeurs non signées bouclent silencieusement vers un nombre faux mais d’apparence valide, tandis que le code signé conserve les valeurs attendues jusqu’à ce qu’une limite soit réellement dépassée.
Mélanger signed et unsigned dans une même expression
Les différences les plus surprenantes apparaissent lorsque les deux types se rencontrent dans une même expression. Selon les conversions arithmétiques usuelles (usual arithmetic conversions), si un int et un unsigned int de même rang sont combinés, l’opérande int est converti en unsigned int avant l’opération. La comparaison ou le calcul s’effectue donc sans signe, même si un côté a commencé négatif :
#include <stdio.h>
int main(void) {
printf("-1 < 1: %d\n", -1 < 1);
printf("-1 < 1u: %d\n", -1 < 1u);
printf("-1 == 4294967295u: %d\n", -1 == 4294967295u);
return 0;
}
-1 < 1: 1
-1 < 1u: 0
-1 == 4294967295u: 1
Lu mathématiquement, -1 < 1 est vrai et affiche 1. Ajouter le suffixe u change la réponse en 0 : -1 est d’abord converti en 4294967295, et cette valeur n’est pas inférieure à 1. Pour la même raison, -1 est égal à la plus grande valeur non signée. GCC avertit exactement de ce motif avec -Wsign-compare, un avertissement qu’il vaut la peine d’activer en permanence. L’arithmétique suit la même règle, de sorte qu’un ajustement négatif peut se transformer en un énorme résultat positif au lieu d’un petit résultat négatif :
#include <stdio.h>
int main(void) {
unsigned int count = 10u;
int delta = -20;
int signed_total = 10 + delta;
printf("unsigned total: %u\n", count + delta);
printf("signed total: %d\n", signed_total);
return 0;
}
unsigned total: 4294967286
signed total: -10
Rien n’a dépassé le type non signé ici ; la conversion seule a produit 4294967286. Chaque fois qu’une valeur peut devenir négative — une différence entre deux comptes, un solde, une sentinelle d’erreur comme -1 —, conservez-la dans un type signé jusqu’au point où une valeur non négative est garantie.
Le piège de sizeof et les compteurs de boucle non signés
Le mélange se produit aussi là où aucun cast ni suffixe n’est visible. L’opérateur sizeof produit un size_t, un type non signé ; comparer une variable signée à un résultat de sizeof déclenche donc la même conversion :
#include <stdio.h>
int main(void) {
int index = -1;
printf("sizeof(int): %zu\n", sizeof(int));
printf("index < (int)sizeof(int): %d\n", index < (int)sizeof(int));
printf("index < sizeof(int): %d\n", index < sizeof(int));
return 0;
}
sizeof(int): 4
index < (int)sizeof(int): 1
index < sizeof(int): 0
La dernière comparaison devrait être vraie — -1 est réellement plus petit que 4 —, mais la comparaison non signée dit le contraire. Convertir le résultat de sizeof en int, lorsque sa valeur tient de façon connue, rétablit la réponse attendue. Un piège voisin est la boucle descendante écrite for (unsigned int i = count - 1; i >= 0; --i) : une valeur non signée est toujours supérieure ou égale à zéro, donc la condition n’est jamais fausse. Lorsque le compteur atteint zéro et est décrémenté, il boucle jusqu’à UINT_MAX — le même bouclage que l’exemple de conversion a affiché pour 0u - 1u — et la boucle continue avec un indice énorme. Comptez à rebours dans un type signé, ou utilisez l’idiome for (unsigned int i = count; i-- > 0; ), qui teste l’ancienne valeur avant de décrémenter.
Choisir entre signed int et unsigned int
Choisissez int lorsque les valeurs négatives ont un sens, par exemple pour une variation qui peut être positive ou négative. Choisissez unsigned int lorsque le domaine est non négatif et que l’arithmétique modulo convient, par exemple pour un compteur dont les opérations doivent boucler à la valeur maximale du type. Un type non signé n’est pas une solution générale pour stocker de plus grandes valeurs positives en toute sécurité : sa plage dépend de l’implémentation, et les conversions ou mélanges de valeurs signées et non signées peuvent modifier les résultats des comparaisons et des opérations arithmétiques. Utilisez le type dont la plage et l’arithmétique correspondent aux valeurs réellement traitées par votre programme.
En pratique, cela mène à quelques choix par défaut fiables. Utilisez un type signé pour l’arithmétique générale, les différences et les compteurs de boucle, même pour des quantités qui commencent non négatives, car les résultats intermédiaires doivent souvent passer en dessous de zéro. Réservez les types non signés aux motifs de bits et aux masques, aux valeurs dont le bouclage est délibéré, comme les valeurs de hachage et les registres matériels, et à l’adaptation à une interface qui utilise déjà un type non signé ou size_t. Ne choisissez pas unsigned uniquement pour documenter qu’une valeur ne devrait jamais être négative : cela n’empêche pas la valeur d’être produite par une soustraction, cela la renomme simplement en un très grand nombre positif. Enfin, si le problème réel est la plage, passez à un type plus large tel que long long plutôt que de compter sur l’espace supplémentaire qu’un type non signé semble offrir.
Trois idées reçues causent l’essentiel de la confusion autour de ces types. La première est que unsigned int serait simplement int avec une plus grande plage positive ; en réalité, les deux types diffèrent par le comportement en cas de dépassement, par les conversions et par les comparaisons, pas seulement par la plage. La deuxième est que stocker une valeur négative dans une variable non signée conserverait d’une façon ou d’une autre la valeur négative ; la conversion la remplace immédiatement, comme le montrent les exemples ci-dessus. La troisième est que l’arithmétique non signée serait plus sûre parce qu’elle ne peut pas devenir négative ; elle remplace les résultats négatifs par de grands résultats positifs, silencieusement, ce qui est souvent plus difficile à déboguer que le problème qu’elle était censée prévenir.