Comprendre les types entiers en C++ : signed, unsigned, short et long

En C++, la gestion des nombres entiers repose sur plusieurs types de données : signed, unsigned, short et long. Chacun de ces types influence la plage de valeurs possibles et la quantité de mémoire utilisée. Cet article explique leurs différences et leur impact sur la mémoire.

1. Signed vs Unsigned : Quelle différence ?

Signed (`signed`)

Peut contenir des valeurs positives et négatives.
Utilise un bit pour représenter le signe (0 pour positif, 1 pour négatif).

Unsigned (`unsigned`)

Ne peut contenir que des valeurs positives.
Toute la mémoire est utilisée pour stocker des valeurs positives.

Type	Plage de valeurs sur 32 bits
`signed int`	-2,147,483,648 à 2,147,483,647
`unsigned int`	0 à 4,294,967,295

Exemple :

signed int a = -10;   // OK
unsigned int b = -10; // ⚠️ Erreur : valeur négative interdite

2. Short vs Long : Gestion de la mémoire

Ces mots-clés définissent la taille de l’entier en mémoire. La taille exacte dépend de l’architecture du système (32 bits ou 64 bits).

Type	Taille (32 bits)	Taille (64 bits)	Plage approximative
`short`	2 octets (16 bits)	2 octets (16 bits)	-32,768 à 32,767
`int`	4 octets (32 bits)	4 octets (32 bits)	-2,147,483,648 à 2,147,483,647
`long`	4 octets (32 bits)	8 octets (64 bits)	Variable
`long long`	8 octets (64 bits)	8 octets (64 bits)	Très grand nombre

Exemple de programme pour vérifier la taille :

#include <iostream>

int main() {
    std::cout << "Taille de short: " << sizeof(short) << " octets" << std::endl;
    std::cout << "Taille de int: " << sizeof(int) << " octets" << std::endl;
    std::cout << "Taille de long: " << sizeof(long) << " octets" << std::endl;
    std::cout << "Taille de long long: " << sizeof(long long) << " octets" << std::endl;
    return 0;
}

3. Impact sur la mémoire et la représentation binaire

Les entiers sont stockés en binaire. La manière dont ils sont interprétés dépend de leur type (signed ou unsigned).

Signed vs Unsigned en binaire

Nombre	Signed (Complément à 2)	Unsigned
127	`0111 1111`	`0111 1111`
-1	`1111 1111`	🚫 Impossible
-128	`1000 0000`	🚫 Impossible
255	🚫 Impossible	`1111 1111`

Exemple d’affichage du stockage en mémoire :

#include <iostream>

int main() {
    signed char s = -1;
    unsigned char u = 255;

    std::cout << "Signed char (-1) : " << (int)s << std::endl;
    std::cout << "Unsigned char (255) : " << (int)u << std::endl;

    return 0;
}

4. Erreurs fréquentes et pièges à éviter

Dépassement de capacité (Overflow)

#include <iostream>

int main() {
    unsigned int u = 0;
    u--; // Essai de passer à -1

    std::cout << "Valeur après décrémentation : " << u << std::endl;
    return 0;
}

Résultat : 4294967295 au lieu de -1, car unsigned ne peut pas être négatif !

Comparaison entre `signed` et `unsigned`

#include <iostream>

int main() {
    signed int s = -1;
    unsigned int u = 1;

    if (s < u) {
        std::cout << "-1 est inférieur à 1" << std::endl;
    } else {
        std::cout << "-1 est considéré comme un grand nombre!" << std::endl;
    }
    return 0;
}

💡 Problème : s (-1) est converti en unsigned, ce qui donne 4294967295, donc u < s devient true !

5. Quand utiliser quel type ?

Situation	Type recommandé
Petits nombres optimisés en mémoire	`short`
Nombres standard	`int`
Grandes valeurs entières	`long` ou `long long`
Valeurs toujours positives	`unsigned`

Conclusion

✔️ signed et unsigned influencent la plage de valeurs et la manière dont les bits sont interprétés. ✔️ short, int, long, long long influencent la quantité de mémoire utilisée. ✔️ Un mauvais choix de type peut causer des erreurs cachées !

📌 Meilleur conseil :

Si les valeurs ne peuvent pas être négatives → unsigned.
Si tu veux économiser de la mémoire pour des petits nombres → short.
Si tu veux éviter des erreurs, reste sur int sauf nécessité particulière.

💡 As-tu des questions ou veux-tu plus d’exemples ? N’hésite pas à laisser un commentaire ! 🚀