web-dev-qa-db-fra.com

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

Pouvez unsigned long int détenir 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 unsigned long int, long int, unsigned int, short int, short unsigned int, et int?

c++int
73
yihangho

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 que non, long intne peut pas être utilisé pour stocker un numéro à 10 chiffres. Cependant, un type plus grand long long int a été introduit en C en C99 et en C++ en C++ 11 (ce type est également souvent pris en charge en tant qu'extension par des 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:

  • long long int: -9,223,372,036,854,775,707 à 9,223,372,036,854,775,807
  • unsigned long long int: 0 à 18 446 744 073 709 551 615

Donc ce type sera assez grand (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 à complément à deux où la valeur avec le bit de signe 1 et tous les bits de valeur 0 est une représentation de trappe plutôt qu'une valeur légale. En d'autres termes, int n'est pas non pour pouvoir représenter la valeur -32,768.

118
caf

La taille des types numériques n'est pas définie dans la norme C++, bien que les tailles minimales le soient. La façon de savoir quelle taille ils ont sur votre plate-forme est d'utiliser limites numériques

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 2n-1 à cause 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, le prochain bit 21puis 22 et ainsi de suite jusqu'à ce que nous arrivions au bit le plus à gauche qui, si le nombre n'est pas signé, représente 2sept.

Donc, le nombre représente 26 + 23 = 64 + 8 = 72, car le 4ème bit de droite et le 7ème bit de gauche à gauche sont activés.

Si nous fixons toutes les valeurs à 1:

11111111

Le nombre est maintenant (en supposant non signé )
128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255 = 28 - 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 et int et long sont les mêmes, chacun pouvant tenir entre -231 à 231 - 1. D'après mon expérience, la taille la plus répandue sur les ordinateurs de bureau 32 bits modernes.

29
Yacoby

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

#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 qu'en C99 et en C++ 11.

9
Hal Canary

D'autres personnes ici publieront des liens vers data_sizes et précisions, etc.
Je vais vous dire comment résoudre le problème vous-même.
Ecrivez 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 que c'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, 0x indique au compilateur que la chaîne suivante est un nombre hexadécimal). Maintenant, changez votre programme pour assigner cette valeur et imprimer le résultat

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

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

Faites-le maintenant 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 (c'est-à-dire doubles ou flottants).

J'espère que cela t'aides

7
Binary Worrier

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

-2147483648 to 2147483647

ou -2 ^ 31 à 2 ^ 31-1

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

6
Shah Rukh Qasim

Pour 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 type de données signé, MSB indique le bit de signe et les bits restants sont destinés aux données.

Pour trouver la plage, faites les choses suivantes:

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

Étape 2 -> Appliquer 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 la taille int non signée = 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]

2
Ashish

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

1
Raymond

Vous devriez examiner les spécialisations du modèle numeric_limits <> pour un type donné. C'est dans l'en-tête.

0
PaulJWilliams

Unigned long int peut conserver un numéro à dix chiffres (1 000 000 000 - 9 999 999 999) sur un ordinateur 32 bits.

Non

0
justin