Pouvez unsigned long int contenir un nombre à dix chiffres (1 000 000 000 - 9 999 999 999) sur un ordinateur 32 bits?
En outre, quelles sont les gammes de unsigned long int, long int, unsigned int, short int, short unsigned intet int?
Réponses:
Les plages minimales sur lesquelles vous pouvez compter sont:
short intet int: -32 767 à 32 767unsigned short intet unsigned int: 0 à 65 535long int: -2 147 483 647 à 2 147 483 647unsigned long int: 0 à 4 294 967 295Cela signifie que non, long int ne peut pas être invoqué pour stocker un numéro à 10 chiffres. Cependant, un type plus grand a long long intété introduit dans C en C99 et 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:
long long int: -9 223 372 036 854 775 807 à 9 223 372 036 854 775 807unsigned long long int: 0 à 18 446 744 073 709 551 615Donc, 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 - je ne l'ai pas fait. Les exigences C pour les plages sont écrites pour permettre des représentations entières de complément ou de grandeur de signe, où 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 de complément à deux où la valeur avec le bit de signe 1 et tous les bits de valeur 0 est une représentation d'interruption plutôt qu'une valeur légale. En d'autres termes, il intn'est pas nécessaire de pouvoir représenter la valeur -32 768.
intsignifie long int.
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 sont sur votre plate-forme est d'utiliser des limites numériques
Par exemple, la valeur maximale d'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 de 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 mis à 1 représente 2 0 , le bit suivant 2 1 , puis 2 2 et ainsi de suite jusqu'à ce que nous arrivions au bit le plus à gauche qui, si le nombre n'est pas signé, représente 2 7 .
Ainsi, le nombre représente 2 6 + 2 3 = 64 + 8 = 72, car le 4ème bit à droite et le 7ème bit à droite à gauche sont définis.
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 nous pouvons le voir, c'est la plus grande valeur possible qui peut être représentée avec 8 bits.
Sur ma machine et int et un long sont les mêmes, chacun pouvant contenir entre -2 31 à 2 31 - 1. D'après mon expérience, la taille la plus courante sur la 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 ce long longn'est légal qu'en C99 et en C ++ 11.
D'autres personnes ici publieront des liens vers des tailles de données et des précisions, etc.
Je vais vous dire comment le comprendre vous-même.
Écrivez une petite application qui fera ce qui suit.
unsigned int ui;
std::cout << sizeof(ui));
cela affichera (selon le compilateur et l'architecture) 2, 4 ou 8, soit 2 octets de long, 4 octets de long, etc.
Supposons que c'est 4.
Vous voulez maintenant que la valeur maximale que 4 octets puissent stocker, la valeur maximale pour un octet est (en hexadécimal) 0xFF. La valeur maximale de quatre octets est 0x suivi 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 de base 10.
Maintenant, faites-le pour les longs, les shorts et toute autre valeur INTEGER qui vous intéresse.
NB: Cette approche ne fonctionnera pas pour les nombres à virgule flottante (c'est-à-dire double ou flottant).
J'espère que cela t'aides
En C ++, maintenant int et les autres données sont stockées à l'aide de la méthode compliment de 2. Cela signifie que la plage est:
-2147483648 to 2147483647
ou -2 ^ 31 à 2 ^ 31-1
1 bit est réservé pour 0 donc la valeur positive est un de moins que 2 ^ (31)
Vous pouvez utiliser les fonctions numeric_limits<data_type>::min()et numeric_limits<data_type>::max()présentes dans le limitsfichier d' en- tête et trouver les limites de chaque type de données.
#include <iostream>
#include <limits>
using namespace std;
int main()
{
cout<<"Limits of Data types:\n";
cout<<"char\t\t\t: "<<static_cast<int>(numeric_limits<char>::min())<<" to "<<static_cast<int>(numeric_limits<char>::max())<<endl;
cout<<"unsigned char\t\t: "<<static_cast<int>(numeric_limits<unsigned char>::min())<<" to "<<static_cast<int>(numeric_limits<unsigned char>::max())<<endl;
cout<<"short\t\t\t: "<<numeric_limits<short>::min()<<" to "<<numeric_limits<short>::max()<<endl;
cout<<"unsigned short\t\t: "<<numeric_limits<unsigned short>::min()<<" to "<<numeric_limits<unsigned short>::max()<<endl;
cout<<"int\t\t\t: "<<numeric_limits<int>::min()<<" to "<<numeric_limits<int>::max()<<endl;
cout<<"unsigned int\t\t: "<<numeric_limits<unsigned int>::min()<<" to "<<numeric_limits<unsigned int>::max()<<endl;
cout<<"long\t\t\t: "<<numeric_limits<long>::min()<<" to "<<numeric_limits<long>::max()<<endl;
cout<<"unsigned long\t\t: "<<numeric_limits<unsigned long>::min()<<" to "<<numeric_limits<unsigned long>::max()<<endl;
cout<<"long long\t\t: "<<numeric_limits<long long>::min()<<" to "<<numeric_limits<long long>::max()<<endl;
cout<<"unsiged long long\t: "<<numeric_limits<unsigned long long>::min()<<" to "<<numeric_limits<unsigned long long>::max()<<endl;
cout<<"float\t\t\t: "<<numeric_limits<float>::min()<<" to "<<numeric_limits<float>::max()<<endl;
cout<<"double\t\t\t: "<<numeric_limits<double>::min()<<" to "<<numeric_limits<double>::max()<<endl;
cout<<"long double\t\t: "<<numeric_limits<long double>::min()<<" to "<<numeric_limits<long double>::max()<<endl;
}
La sortie sera: Limites des types de données:
Pour le type de données non signé, il n'y a pas de bit de signe et tous les bits sont pour les données; alors que pour le type de données signé MSB est un bit de signe indiqué et les bits restants sont pour les données.
Pour trouver la gamme, procédez comme suit:
Étape: 1 -> Découvrez 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
Pour par exemple
Pour taille int non signée = 4 octets (32 bits) -> Plage [0, (2 ^ (32)) - 1]
Pour la taille d'un entier signé = 4 octets (32 bits) -> Plage [- (2 ^ (32-1)), (2 ^ (32-1)) - 1]
Non, seule une partie du nombre à dix chiffres peut être stockée dans un entier long non signé dont la plage valide est comprise entre 0 et 4 294 967 295. vous pouvez vous référer à ceci: http://msdn.microsoft.com/en-us/library/s3f49ktz(VS.80).aspx
Vous devriez regarder les spécialisations du modèle numeric_limits <> pour un type donné. C'est dans l'en-tête.