Può unsigned long intcontenere un numero di dieci cifre (1.000.000.000 - 9.999.999.999) su un computer a 32 bit?
Inoltre, quali sono le gamme di unsigned long int, long int, unsigned int, short int, short unsigned int, e int?
Risposte:
Gli intervalli minimi su cui puoi fare affidamento sono:
short inte int: da -32.767 a 32.767unsigned short inte unsigned int: da 0 a 65.535long int: Da -2.147.483.647 a 2.147.483.647unsigned long int: Da 0 a 4.294.967.295Ciò significa che no, long int non è possibile fare affidamento per memorizzare un numero di 10 cifre. Tuttavia, un tipo più grande è long long intstato introdotto in C in C99 e C ++ in C ++ 11 (questo tipo è spesso supportato anche come estensione da compilatori creati per standard precedenti che non lo includevano). L'intervallo minimo per questo tipo, se il tuo compilatore lo supporta, è:
long long int: Da -9.223.372.036.854.775.807 a 9.223.372.036.854.775.807unsigned long long int: Da 0 a 18.446.744.073.709.551.615Quindi quel tipo sarà abbastanza grande (di nuovo, se lo hai disponibile).
Una nota per coloro che credono che abbia commesso un errore con questi limiti inferiori - non l'ho fatto. I requisiti C per gli intervalli sono scritti per consentire rappresentazioni di interi in complemento a uno o di grandezza del segno, dove il valore rappresentabile più basso e il valore rappresentabile più alto differiscono solo nel segno. È anche consentito avere una rappresentazione in complemento a due in cui il valore con il bit di segno 1 e tutti i bit di valore 0 è una rappresentazione trappola piuttosto che un valore legale. In altre parole, nonint è necessario essere in grado di rappresentare il valore -32.768.
intsignifica long int.
La dimensione dei tipi numerici non è definita nello standard C ++, sebbene le dimensioni minime lo siano. Il modo per capire quale dimensione hanno sulla tua piattaforma è usare limiti numerici
Ad esempio, il valore massimo per un int può essere trovato da:
std::numeric_limits<int>::max();
I computer non funzionano in base 10, il che significa che il valore massimo sarà nella forma di 2 n -1 a causa di come i numeri di rappresentano in memoria. Prendi ad esempio otto bit (1 byte)
0100 1000
Il bit più a destra (numero) quando impostato su 1 rappresenta 2 0 , il bit successivo 2 1 , quindi 2 2 e così via fino a quando non si arriva al bit più a sinistra che se il numero è senza segno rappresenta 2 7 .
Quindi il numero rappresenta 2 6 + 2 3 = 64 + 8 = 72, perché il 4 ° bit da destra e il 7 ° bit da destra sono impostati.
Se impostiamo tutti i valori su 1:
11111111
Il numero è ora (supponendo non firmato )
128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255 = 2 8 - 1
E come possiamo vedere, che è il più grande valore possibile che può essere rappresentato con 8 bit.
Sulla mia macchina, int e un long sono gli stessi, ciascuno in grado di contenere tra -2 31 e 2 31 - 1. Nella mia esperienza la dimensione più comune sulla moderna macchina desktop a 32 bit.
Per scoprire i limiti del tuo sistema:
#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";
}
Nota che long longè legale solo in C99 e C ++ 11.
Altre persone qui pubblicheranno link a data_sizes e precisions ecc.
Ti dirò come capirlo da solo.
Scrivi una piccola app che farà quanto segue.
unsigned int ui;
std::cout << sizeof(ui));
questo (a seconda del compilatore e dell'archivio) stamperà 2, 4 o 8, dicendo 2 byte di lunghezza, 4 byte di lunghezza ecc.
Supponiamo che sia 4.
Ora vuoi il valore massimo che 4 byte possono memorizzare, il valore massimo per un byte è (in esadecimale) 0xFF. Il valore massimo di quattro byte è 0x seguito da 8 f (una coppia di f per ogni byte, lo 0x dice al compilatore che la stringa seguente è un numero esadecimale). Ora cambia il tuo programma per assegnare quel valore e stampa il risultato
unsigned int ui = 0xFFFFFFFF;
std::cout << ui;
Questo è il valore massimo che un int senza segno può contenere, mostrato nella rappresentazione in base 10.
Ora fallo per lunghi, corti e qualsiasi altro valore INTEGER di cui sei curioso.
NB: questo approccio non funzionerà per i numeri in virgola mobile (cioè double o float).
Spero che sia di aiuto
In C ++, ora int e altri dati vengono archiviati utilizzando il metodo compliment di 2. Ciò significa che la gamma è:
-2147483648 to 2147483647
o da -2 ^ 31 a 2 ^ 31-1
1 bit è riservato per 0, quindi il valore positivo è uno inferiore a 2 ^ (31)
È possibile utilizzare le funzioni numeric_limits<data_type>::min()e numeric_limits<data_type>::max()presenti nel limitsfile di intestazione e trovare i limiti di ciascun tipo di dati.
#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;
}
L'output sarà: Limiti dei tipi di dati:
Per il tipo di dati senza segno non esiste un bit di segno e tutti i bit sono per i dati; mentre per il tipo di dati con segno segno è indicato MSB bit di segno ei bit rimanenti sono per i dati.
Per trovare la gamma fare le seguenti cose:
Passaggio: 1 -> Scopri il numero di byte per il tipo di dati fornito.
Passaggio: 2 -> Applica i seguenti calcoli.
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
Per es
Per dimensioni int senza segno = 4 byte (32 bit) -> Intervallo [0, (2 ^ (32)) - 1]
Per dimensione int con segno = 4 byte (32 bit) -> Intervallo [- (2 ^ (32-1)), (2 ^ (32-1)) - 1]
No, solo una parte di un numero di dieci cifre può essere memorizzata in un int lungo senza segno il cui intervallo valido è compreso tra 0 e 4.294.967.295. puoi fare riferimento a questo: http://msdn.microsoft.com/en-us/library/s3f49ktz(VS.80).aspx
Dovresti esaminare le specializzazioni del modello numeric_limits <> per un dato tipo. È nell'intestazione.