Die Größen von Datentypen in DOS und UNIX (genauer gesagt, pox-konforme Systeme wie Linux, MacOS, BSD usw.) können je nach Compiler und spezifischer Systemarchitektur (z. B. 32-Bit gegenüber 64-Bit) geringfügig variieren. Es gibt jedoch allgemein anerkannte Standards und gemeinsame Größen. Es ist wichtig, sich daran zu erinnern, dass dies * nicht * garantiert ist und Sie immer die Dokumentation Ihres Compilers für endgültige Größen konsultieren sollten.

Gemeinsame Datentypgrößen (ungefähr):

| Datentyp | DOS (typisch 16-Bit) | UNIX (typischerweise 32-Bit oder 64-Bit) | Notizen |

| --------------- | ------------------------ | ------------------------------- | ----------------------------------------------

| `char` | 1 Byte | 1 Byte | Normalerweise signiert, kann aber nicht signiert werden. |

| `Unsigned char` | 1 Byte | 1 Byte | |

| `Short` | 2 Bytes | 2 Bytes (normalerweise) | Oft `Short int` |

| `Unsigned Short` | 2 Bytes | 2 Bytes (normalerweise) | |

| `int` | 2 Bytes | 4 Bytes (auf 32-Bit), 4 oder 8 Bytes (auf 64-Bit) | Die Größe hängt stark von der Architektur ab. |

| `Unsigned int` | 2 Bytes | 4 Bytes (auf 32-Bit), 4 oder 8 Bytes (auf 64-Bit) | Die Größe hängt stark von der Architektur ab. |

| `Long` | 4 Bytes | 4 Bytes (auf 32-Bit), 8 Bytes (auf 64-Bit) | Die Größe hängt stark von der Architektur ab. |

| `Unsigned Long` | 4 Bytes | 4 Bytes (auf 32-Bit), 8 Bytes (auf 64-Bit) | Die Größe hängt stark von der Architektur ab. |

| `Long Long` | Nicht Standard | 8 Bytes | C99 und später Standard. |

| `Unsigned Long Long` | Nicht Standard | 8 Bytes | C99 und später Standard. |

| `float` | 4 Bytes | 4 Bytes | Einzelprezisions-Gleitpunkt. |

| `Double` | 4 Bytes oder 8 Bytes | 8 Bytes | Schwimmpunkt für doppelte Präzision. |

| `Long Double` | 8 Bytes (oft) | 8 Bytes oder 16 Bytes | Schwimmpunkt der erweiterten Präzision (Größe variiert). |

| `zeiger` | 2 Bytes | 4 Bytes (32-Bit), 8 Bytes (64-Bit) | Die Größe hängt von der Architektur ab. |

Wichtige Überlegungen:

* dos Variationen: Die "DOS" -Gegrößen sind Verallgemeinerungen. Verschiedene DOS -Compiler und sogar unterschiedliche Speichermodelle (wie kleine, mittlere, kompakte, große, riesige) können die Größe der Datentypen beeinflussen. DOS war größtenteils ein 16-Bit-Betriebssystem, was zu kleineren Größen führte.

* Unix/POSIX -Variationen: Während Unix-ähnliche Systeme in der Regel konsistenter sind, können die Größen "int" und "long" je nach Systemarchitektur (32-Bit gegenüber 64-Bit) variieren. Die Standardmandate * Minimum * Größen, keine genauen Größen. Die Verwendung von `stdint.h` (C99 und später) bietet für eine bessere Portabilität feste Ganzzahltypen mit fester Breite (` int32_t`, `int64_t` usw.).

* Compiler Einfluss: Der von Ihnen verwendete Compiler (GCC, Clang, Visual C ++) kann subtile Auswirkungen auf die Datentypgrößen haben. Überprüfen Sie immer die Dokumentation Ihres Compilers oder verwenden Sie `sizeof ()`, um die genaue Größe Ihres spezifischen Systems und Ihres Compilers zu bestimmen.

* `sizeof ()` operator: Um die genaue Größe eines Datentyps in Bytes auf Ihrem * * System zu erhalten, verwenden Sie den `sizeof ()` -Operator in C/C ++. Zum Beispiel:`sizeof (int)` `sizeof (lang lang)` usw. Dies ist die zuverlässigste Methode.

Zusammenfassend lässt sich sagen, dass die Tabelle gemeinsame Größen bietet, die tatsächlichen Größen Compiler- und Plattform-abhängig sind. Überprüfen Sie immer mit `sizeof ()` für genaue, plattformspezifische Informationen.