Quelle plage de valeurs les types entiers peuvent-ils stocker en C ++?

StackOverflow https://stackoverflow.com/questions/1819189

  •  10-07-2019
  •  | 
  •  

Question

Peut-on unsigned long int conserver un numéro à dix chiffres (1 000 000 000 - 9 999 999 999) sur un ordinateur 32 bits?

De plus, quelles sont les plages de long int, unsigned int, short int, short unsigned int, int et <=>?

Était-ce utile?

La solution

Les plages minimales sur lesquelles vous pouvez compter sont les suivantes:

  • short int et int: -32 767 à 32 767
  • unsigned short int et unsigned int: 0 à 65 535
  • long int: -2 147 483 647 à 2 147 483 647
  • unsigned long int: 0 à 4 294 967 295

Cela signifie qu'il est impossible de compter sur long long int pour stocker un numéro à 10 chiffres. Cependant, un type plus volumineux unsigned long long int a été introduit dans C en C99 et C ++ en C ++ 11 (ce type est également souvent pris en charge en tant qu'extension par les compilateurs construits pour des normes plus anciennes qui ne l'incluaient pas). La plage minimale pour ce type, si votre compilateur le prend en charge, est la suivante:

  • <=>: -9 223 372 036 854 775 807 à 9 223 372 0 36 85 75 77 80
  • <=>: 0 à 18 446 744 073 709 551 615

Ce type sera donc suffisamment gros (encore une fois, si vous l'avez disponible).

Une note pour ceux qui croient que j'ai commis une erreur avec ces limites inférieures - ce n'est pas le cas. Les exigences C pour les plages sont écrites de manière à permettre les représentations d'entiers avec complément ou magnitude de signe, lorsque la valeur représentable la plus basse et la valeur représentable la plus élevée ne diffèrent que par le signe. Il est également permis d’avoir une représentation en complément à deux où la valeur avec le bit de signe 1 et tous les bits de valeur 0 est une représentation de déroutement plutôt qu’une valeur légale. En d'autres termes, <=> n'est pas nécessaire pour pouvoir représenter la valeur -32 768.

Autres conseils

La taille des types numériques n'est pas définie dans la norme C ++, bien que les tailles minimales le soient. Pour savoir quelle est leur taille sur votre plate-forme, utilisez les limites numériques <. / p>

Par exemple, la valeur maximale pour un int peut être trouvée par: 

std::numeric_limits<int>::max();

Les ordinateurs ne fonctionnent pas en base 10, ce qui signifie que la valeur maximale sera sous la forme 2 n -1 en raison de la façon dont les nombres de représentent en mémoire. Prenons par exemple huit bits (1 octet) 

  0100 1000

Le bit le plus à droite (nombre) lorsqu'il est défini sur 1 représente 2 0 , le bit suivant 2 1 , puis 2 2 , etc. jusqu'à ce que nous arrivions au bit le plus à gauche qui, si le nombre n'est pas signé, représente 2 7 .

Le nombre représente donc 2 6 + 2 3 = 64 + 8 = 72, car le 4ème bit de droite et le 7ème bit de gauche à gauche sont activés.

Si nous définissons toutes les valeurs sur 1: 

11111111

Le nombre est maintenant (en supposant non signé )

128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255 = 2 8 - 1
Et comme on peut le constater, c’est la plus grande valeur possible pouvant être représentée avec 8 bits.

Sur ma machine, int et long sont identiques, chacun pouvant contenir entre -2 31 et 2 31 - 1. D'après mon expérience, la taille la plus courante sur une machine de bureau 32 bits moderne.

Pour connaître les limites de votre système : 

#include <iostream>
#include <limits>
int main(int, char **) {
  std::cout
    << static_cast< int >(std::numeric_limits< char >::max()) << "\n"
    << static_cast< int >(std::numeric_limits< unsigned char >::max()) << "\n"
    << std::numeric_limits< short >::max() << "\n"
    << std::numeric_limits< unsigned short >::max() << "\n"
    << std::numeric_limits< int >::max() << "\n"
    << std::numeric_limits< unsigned int >::max() << "\n"
    << std::numeric_limits< long >::max() << "\n"
    << std::numeric_limits< unsigned long >::max() << "\n"
    << std::numeric_limits< long long >::max() << "\n"
    << std::numeric_limits< unsigned long long >::max() << "\n";
}

Notez que long long n’est légal que dans C99 et C ++ 11.

D'autres personnes ici publieront des liens vers data_sizes et précisions, etc.

Je vais vous dire comment vous en sortir.
Écrivez une petite application qui fera ce qui suit. 

unsigned int ui;
std::cout <<  sizeof(ui));

Ceci (en fonction du compilateur et de l'archicture) affichera 2, 4 ou 8 en disant 2 octets, 4 octets, etc.

Supposons qu'il en est 4.

Vous voulez maintenant que la valeur maximale que 4 octets puissent être stockée, la valeur maximale pour un octet étant (en hexadécimal) 0xFF. La valeur maximale de quatre octets est 0x suivie de 8 f (une paire de f pour chaque octet, le 0x indique au compilateur que la chaîne suivante est un nombre hexadécimal). Modifiez maintenant votre programme pour attribuer cette valeur et imprimez le résultat 

unsigned int ui = 0xFFFFFFFF;
std::cout <<  ui;

C'est la valeur maximale qu'un int non signé peut contenir, indiquée dans la représentation en base 10.

Faites-le pour les longs, les courts-métrages et toute autre valeur INTEGER qui vous intéresse.

NB: cette approche ne fonctionnera pas pour les nombres à virgule flottante (double ou float).

J'espère que cela vous aidera

En C ++, les données int et autres sont maintenant stockées à l'aide de la méthode de complément à 2. Cela signifie que la plage est la suivante: 

-2147483648 to 2147483647

ou -2 ^ 31 à 2 ^ 31-1

1 bit est réservé à 0, donc la valeur positive est inférieure à 2 ^ (31)

Pour le type de données non signé , il n'y a pas de bit de signe et tous les bits sont destinés aux données. ; alors que pour le type de données signé , le bit de poids fort est indiqué et les bits restants sont destinés aux données.

Pour trouver la plage, procédez comme suit:

Étape: 1 - > Recherchez pas d'octets pour le type de données donné.

Étape: 2 - > Appliquez les calculs suivants. 

      Let n = no of bits in data type  

      For signed data type ::
            Lower Range = -(2^(n-1)) 
            Upper Range = (2^(n-1)) - 1)  

      For unsigned data type ::
            Lower Range = 0 
            Upper Range = (2^(n)) - 1

Par exemple

Pour unsigned int size = 4 octets (32 bits) - > Plage [0, (2 ^ (32)) - 1]

Pour la taille int signée = 4 octets (32 bits) - > Plage [- (2 ^ (32-1)), (2 ^ (32-1)) - 1]

Non, seule une partie d'un nombre à dix chiffres peut être stockée dans un entier long non signé dont la plage valide va de 0 à 4 294 967 295. vous pouvez vous référer à ceci: http://msdn.microsoft.com/en-us /library/s3f49ktz(VS.80).aspx

  

Unigned long int peut-il contenir un nombre à dix chiffres (1 000 000 000 - 9 999 999 999) sur un ordinateur 32 bits.

Non

Vous devriez regarder les spécialisations des limites numériques < > modèle pour un type donné. C'est dans l'en-tête.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top