|
La taille des types de données sous DOS et UNIX (plus précisément, les systèmes compatibles POSIX comme Linux, macOS, BSD, etc.) peut varier légèrement en fonction du compilateur et de l'architecture système spécifique (par exemple, 32 bits contre 64 bits). Cependant, il existe des normes généralement acceptées et des tailles communes. Il est essentiel de se rappeler que cela n'est *pas* garanti et que vous devez toujours consulter la documentation de votre compilateur pour connaître les tailles définitives.
Tailles courantes des types de données (approximatives) :
| Type de données | DOS (généralement 16 bits) | UNIX (généralement 32 bits ou 64 bits) | Remarques |
|--------------------|--------------|-----------------------------------|--------------------------------------------|
| `char` | 1 octet | 1 octet | Généralement signé, mais peut être non signé. |
| `caractère non signé`| 1 octet | 1 octet | |
| `court` | 2 octets | 2 octets (généralement) | Souvent « short int » |
| `court non signé`| 2 octets | 2 octets (généralement) | |
| `int` | 2 octets | 4 octets (sur 32 bits), 4 ou 8 octets (sur 64 bits) | La taille dépend fortement de l'architecture. |
| `entier non signé` | 2 octets | 4 octets (sur 32 bits), 4 ou 8 octets (sur 64 bits) | La taille dépend fortement de l'architecture. |
| 'long' | 4 octets | 4 octets (sur 32 bits), 8 octets (sur 64 bits) | La taille dépend fortement de l'architecture. |
| `long non signé`| 4 octets | 4 octets (sur 32 bits), 8 octets (sur 64 bits) | La taille dépend fortement de l'architecture. |
| 'longtemps' | Pas standard | 8 octets | Norme C99 et ultérieure. |
| `non signé long long`| Pas standard | 8 octets | Norme C99 et ultérieure. |
| `flottant` | 4 octets | 4 octets | Virgule flottante simple précision. |
| `double` | 4 octets ou 8 octets | 8 octets | Virgule flottante double précision. |
| `long double` | 8 octets (souvent) | 8 octets ou 16 octets | Virgule flottante de précision étendue (la taille varie). |
| `pointeur` | 2 octets | 4 octets (32 bits), 8 octets (64 bits) | La taille dépend de l'architecture. |
Considérations importantes :
* Variantes DOS : Les tailles "DOS" sont des généralisations. Différents compilateurs DOS et même différents modèles de mémoire (comme petit, moyen, compact, grand, énorme) peuvent influencer la taille des types de données. DOS était en grande partie un système d'exploitation 16 bits, ce qui entraînait des tailles plus petites.
* Variantes UNIX/POSIX : Alors que les systèmes de type UNIX ont tendance à être plus cohérents, les tailles « int » et « long » peuvent varier en fonction de l'architecture du système (32 bits contre 64 bits). La norme impose des tailles *minimales*, et non des tailles exactes. L'utilisation de `stdint.h` (C99 et versions ultérieures) fournit des types entiers à largeur fixe (`int32_t`, `int64_t`, etc.) pour une meilleure portabilité.
* Influence du compilateur : Le compilateur que vous utilisez (GCC, Clang, Visual C++) peut avoir des impacts subtils sur la taille des types de données. Vérifiez toujours la documentation de votre compilateur ou utilisez `sizeof()` pour déterminer la taille exacte de votre système et de votre compilateur spécifiques.
* Opérateur `sizeof()` : Pour obtenir la taille précise d'un type de données en octets sur *votre* système, utilisez l'opérateur `sizeof()` en C/C++. Par exemple :`sizeof(int)`, `sizeof(long long)`, etc. C'est la méthode la plus fiable.
En résumé, bien que le tableau propose des tailles courantes, les tailles réelles dépendent du compilateur et de la plate-forme. Vérifiez toujours en utilisant `sizeof()` pour des informations précises et spécifiques à la plate-forme.
|
