Os tamanhos dos tipos de dados em DOS e UNIX (com mais precisão, sistemas compatíveis com POSIX como Linux, MacOS, BSD, etc.) podem variar um pouco, dependendo do compilador e da arquitetura específica do sistema (por exemplo, 32 bits vs. 64 bits). No entanto, existem padrões e tamanhos comuns geralmente aceitos. É crucial lembrar que isso * não é * garantido e você sempre deve consultar a documentação do seu compilador para tamanhos definitivos.


Tamanhos de tipo de dados comuns (aproximadamente):

| Tipo de dados | DOS (normalmente de 16 bits) | UNIX (normalmente de 32 bits ou 64 bits) | Notas |
| ----------------- | ---------------------- | ----------------------------------- | ---------------------------------------- |
| `char` | 1 byte | 1 byte | Geralmente assinado, mas pode não ser assinado. |
| `char não assinado | 1 byte | 1 byte | |
| `Short` | 2 bytes | 2 bytes (geralmente) | Freqüentemente `curto int` |
| `Não assinado curto '| 2 bytes | 2 bytes (geralmente) | |
| `int` | 2 bytes | 4 bytes (em 32 bits), 4 ou 8 bytes (em 64 bits) | O tamanho depende muito da arquitetura. |
| `não assinado int` | 2 bytes | 4 bytes (em 32 bits), 4 ou 8 bytes (em 64 bits) | O tamanho depende muito da arquitetura. |
| `Long` | 4 bytes | 4 bytes (em 32 bits), 8 bytes (em 64 bits) | O tamanho depende muito da arquitetura. |
| `não assinado long` | 4 bytes | 4 bytes (em 32 bits), 8 bytes (em 64 bits) | O tamanho depende muito da arquitetura. |
| `Long Long` | Não padrão | 8 bytes | C99 e padrão posterior. |
| `UNSIGADO LONGO LONGO '| Não padrão | 8 bytes | C99 e padrão posterior. |
| `float` | 4 bytes | 4 bytes | Ponto flutuante de precisão única. |
| `Double` | 4 bytes ou 8 bytes | 8 bytes | Ponto flutuante de precisão dupla. |
| `Long Double` | 8 bytes (frequentemente) | 8 bytes ou 16 bytes | Ponto flutuante de precisão estendida (o tamanho varia). |
| `pointer` | 2 bytes | 4 bytes (32 bits), 8 bytes (64 bits) | O tamanho depende da arquitetura. |



Considerações importantes:

* variações do DOS: Os tamanhos "DOS" são generalizações. Compiladores DOS diferentes e até diferentes modelos de memória (como pequeno, médio, compacto, grande, enorme) podem influenciar o tamanho dos tipos de dados. O DOS era em grande parte um sistema operacional de 16 bits, resultando em tamanhos menores.

* variações unix/posix: Enquanto os sistemas semelhantes ao Unix tendem a ser mais consistentes, os tamanhos `int` e` long 'podem variar com base na arquitetura do sistema (32 bits vs. 64 bits). Os tamanhos mínimos * mínimos *, não tamanhos exatos. O uso de `stdint.h` (C99 e posterior) fornece tipos inteiros de largura fixa (` int32_t`, `int64_t`, etc.) para melhor portabilidade.

* Influência do compilador: O compilador que você usa (GCC, CLANG, Visual C ++) pode ter impactos sutis nos tamanhos dos tipos de dados. Sempre verifique a documentação do seu compilador ou use `sizeof ()` para determinar o tamanho exato em seu sistema e compilador específico.

* `sizeof ()` operador: Para obter o tamanho preciso de um tipo de dados em bytes no seu sistema *, use o operador `sizeof ()` em C/C ++. Por exemplo:`sizeof (int)`, `sizeof (comprimento)` etc. Este é o método mais confiável.


Em resumo, enquanto a tabela oferece tamanhos comuns, os tamanhos reais são dependentes do compilador e da plataforma. Sempre verifique o uso de `sizeof ()` para obter informações precisas e específicas da plataforma.