la taille des types de données de base en C

J'ai un exemple de programme que j'ai copié à partir d'un certain site web.

int main(void)
{
   int answer;
   short x = 1;
   long y = 2;
   float u = 3.0;
   double v = 4.4;
   long double w = 5.54;
   char c = 'p';

   typedef enum
   {
      kAttributeInvalid,
      kBooleanAttributeActive,
      kBooleanAttributeAlarmSignal,
      kBooleanAttributeAlign64,
      kBooleanAttributeAutoNegotiationComplete,
   }codes_t;

  /* __DATE__, __TIME__, __FILE__, __LINE__ are predefined symbols */
  #if 0
  printf("Date : %s\n", __DATE__);
  printf("Time : %s\n", __TIME__);
  printf("File : %s\n", __FILE__);
  printf("Line : %d\n", __LINE__);
  #endif

  /* The size of various types */
  printf("The size of int         %zu\n", sizeof(answer));
  printf("The size of short       %zu\n", sizeof(x));
  printf("The size of long        %zu\n", sizeof(y));
  printf("The size of float       %zu\n", sizeof(u));
  printf("The size of double      %zu\n", sizeof(v));
  printf("The size of long double %zu\n", sizeof(w));
  printf("The size of char        %zu\n", sizeof(c));
  printf("The size of enum        %zu\n", sizeof(codes_t));

  return 0;
}

J'ai exécuté ce programme et le résultat que j'ai obtenu comme suit.

The size of int         4
The size of short       2
The size of long        8
The size of float       4
The size of double      8
The size of long double 16
The size of char        1
The size of enum        4

Je suis en cours d'exécution ce sur un PC sous linux qui est en cours d'exécution 64 bits d'Ubuntu.Ma question est si je devais exécuter le même programme sur une machine 32 bits vais-je voir des résultats différents.En d'autres termes, la taille de la base de données dépendent du type de

processeur
Système D'Exploitation
autre chose

Il a littéralement dépend de tout.
Pour moi, la seule hypothèse sur, par exemple. de la taille d'un int, c'est que la taille d'un int est toujours sizeof(int)
Aussi sizeof(int) >= 2 tel que défini dans la norme ANSI C. en dehors de cela, tous les paris sont éteints.
La taille de float et double doit être d'au moins 4 et 8, respectivement. 2 <= court <= int <= long. Et 1 <= char. Sinon, tous les paris sont éteints, comme SecurityMatt dit.
Lèche Pas. char pouvez avoir plus de 8 bits, de sorte sizeof(int) == 1 est possible, par exemple sur la TI 28Cxx où les deux ont 16 bits.

OriginalL'auteur liv2hak | 2013-02-11

c types

4

Sous réserve d'avoir à installer des bibliothèques [probablement juste de la glibc] c'est 32-bit, vous devriez être en mesure d'essayer par vous-même en utilisant gcc -m32 myprog.c [ou clang -m32 myprog.c].

Cependant, la seule chose de vos articles qui ont été énumérés qui va changer si vous vous déplacez d'un 64-bit x86 système linux 32-bit x86 système linux, à l'aide de gcc à base de compilateurs, de la taille d' long. Remarque lourde de qualification de x86, gcc, etc - les compilateurs ont beaucoup de liberté. Quelqu'un pourrait écrire un compilateur pour Linux qui utilise 16 bits int et 64 bits long sur un système 32 bits avec pas énorme quantité de difficulté. À l'aide de ce compilateur pour compiler le noyau Linux et de nombreux outils Linux serait probablement pas [plus probable, y compris la compilation de gcc avec ce compilateur]. Mais vous ne pouvez pas vraiment dire "sur cette architecture" ou "dans ce système d'exploitation" ou "avec ce compilateur" ... sans qualification ce que les AUTRES paramètres.

Affaire au point: Microsoft C/C++ compilateur a un long qui est de 32 bits, même sur les systèmes 64 bits. Pourquoi, je vous entends demander? Parce qu'un grand nombre de fonctions de l'API Windows utiliser long comme une valeur de 32 bits comme héritage à partir de quand Windows est un système d'exploitation 16 bits Intel 286/386 processeurs. Depuis quelques appels système sont compatibles un très long chemin dans Windows, le code qui est écrit pour les systèmes 16 bits fonctionnera toujours sur Windows 64 bits (sauf si le code est à l'aide de certains de vraiment inhabituel appels système, et bien sûr, le STYLE aura l'air un peu ancienne]. Changer long à une valeur de 64 bits aurait brisé une partie de cette functioanilty, de sorte que le compilateur les gars de chez MS a décidé de rester avec long = 32 bits. Si vous voulez les entiers 64 bits, vous devez utiliser long long ou int64_t ou quelque chose d'autre, pas long. Bien sûr, cela rompt un peu de code qui suppose que sizeof(long) == sizeof(void *). Heureusement, la plupart de ces code a déjà été fixé...

OriginalL'auteur Mats Petersson
7

Ma question est si je devais exécuter le même programme sur une machine 32 bits vais-je voir des résultats différents

Peut-être. Ou peut-être pas.

Ou en d'autres termes la taille de la base de données dépendent du type de 1) processeur 2) Système d'Exploitation 3) autre chose
1. Oui, 2. oui, 3. oui, par exemple, si vous exécutez une application 32 bits en 32 bits mode de compatibilité sur un OS 64 bits, puis elle sera très probablement utiliser un mot de 32 bits taille (bien sûr, il a été compilé comme ça). Oh, et oui, elle peut dépendre du compilateur.
"Et vos drapeaux du compilateur..." (Merci, Kay!)

Et vos drapeaux du compilateur.

OriginalL'auteur
4

Si vous vous souciez de la taille exacte de l'variables utilisation
```
#include <stdint.h>
```
Et ensuite utiliser la largeur fixe les types qui y sont définies:
```
uint8_t
uint16_t
uint32_t
uint64_t
```
ou leurs signé cousins
```
int8_t
int16_t
int32_t
int64_t
```
Ne comptez pas sur les tailles des types natifs dans C. Différents compilateurs ont des règles différentes.

Grande peu d'info, ajoute de la clarté

OriginalL'auteur SecurityMatt
2

Oui, cela dépend du matériel, OS, compilateur et même la langue dans certains cas.

Mais sur x86 linux, aspire sera de 4 octets sur les plates-formes 32 bits au lieu de 8.
Les autres, je crois que tous reste le même (pas sûr de long double).

Anecdote:

J'ai travaillé sur 24 bits système où la taille de mot était de 24 bits, et chaque type natif est le 1er mot dans la taille. sizeof(char)? 1 (ie: 24 bits). sizeof(int)? 1 (ie: 24 bits). Etc. Amusant!

IIRC, long double utilisé pour être de 96 bits (x86-32.
fait que la mise en œuvre ont stdio.h?

OriginalL'auteur PQuinn
2

Les montants sont fixés dans la pierre par le compilateur au moment de la compilation, car le compilateur émet de la taille des instructions spécifiques, soulignent les membres dans les structures, et de savoir struct tailles pour tous les requis de l'adresse de calculs.

Donc, si vous compilez votre code source dans un fichier binaire 64 bits et l'exécuter sur un tas de différents systèmes, les types ont la même taille à chaque exécution, si le système prend en charge le binaire.

Si vous puis de compiler le code source dans un fichier binaire 32 bits ou utiliser différents commutateurs de compilateur, lorsque vous exécutez sur un tas de différents systèmes, les chiffres peuvent être différents de la version 64 bits de cas, mais ils seront en accord sur tous les différents systèmes.

J'aime cette réponse, parce qu'il indique clairement que les tailles sont décidées par le compilateur. J'ai pu mettre en œuvre un traducteur (compilateur ou l'interpréteur) qui utilise 111 bits char, short, int, long, etc ..., et quelle que soit 32 vs 64 bits, la taille de ces types seraient tous des 1.

OriginalL'auteur NovaDenizen

Vous devez vous connecter pour publier un commentaire.