Pode unsigned long intconter um número de dez dígitos (1.000.000.000 - 9.999.999.999) em um computador de 32 bits?
Além disso, quais são os intervalos de unsigned long int, long int, unsigned int, short int, short unsigned int, e int?
Respostas:
Os intervalos mínimos em que você pode confiar são:
short inte int: -32.767 a 32.767unsigned short inte unsigned int: 0 a 65.535long int: -2.147.483.647 a 2.147.483.647unsigned long int: 0 a 4.294.967.295Isso significa que não, long int não se pode confiar em nenhum número de 10 dígitos. No entanto, um tipo maior long long intfoi introduzido em C em C99 e C ++ em C ++ 11 (esse tipo também é freqüentemente suportado como uma extensão por compiladores construídos para padrões mais antigos que não o incluíam). O intervalo mínimo para este tipo, se o seu compilador suportar, é:
long long int: -9.223.372.036.854.775.807 a 9.223.372.036.854.775.807unsigned long long int: 0 a 18.446.744.073.709.551.615Portanto, esse tipo será grande o suficiente (novamente, se você tiver disponível).
Uma observação para aqueles que acreditam que cometi um erro com esses limites inferiores - não cometi. Os requisitos C para os intervalos são escritos para permitir o complemento de uns ou representações inteiras de magnitude de sinal, onde o menor valor representável e o maior valor representável diferem apenas em sinal. Também é permitido ter uma representação de complemento de dois, em que o valor com o bit de sinal 1 e todos os bits de valor 0 é uma representação de trap em vez de um valor legal. Em outras palavras, nãoint é necessário ser capaz de representar o valor -32.768.
intsignifica long int.
O tamanho dos tipos numéricos não é definido no padrão C ++, embora os tamanhos mínimos sejam. A maneira de saber o tamanho deles em sua plataforma é usar limites numéricos
Por exemplo, o valor máximo para um int pode ser encontrado por:
std::numeric_limits<int>::max();
Os computadores não funcionam na base 10, o que significa que o valor máximo será na forma de 2 n -1 devido à forma como os números de representam na memória. Tome, por exemplo, oito bits (1 byte)
0100 1000
O bit mais à direita (número) quando definido como 1 representa 2 0 , o próximo bit 2 1 , depois 2 2 e assim por diante até chegarmos ao bit mais à esquerda que, se o número não tiver sinal, representa 2 7 .
Portanto, o número representa 2 6 + 2 3 = 64 + 8 = 72, porque o 4º bit da direita e o 7º bit da direita estão definidos.
Se definirmos todos os valores como 1:
11111111
O número agora é (assumindo não assinado )
128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255 = 2 8 - 1
E como podemos ver, esse é o maior valor possível que pode ser representado com 8 bits.
Na minha máquina e int e long são iguais, cada um capaz de conter entre -2 31 a 2 31-1 . Em minha experiência, o tamanho mais comum em uma máquina de desktop moderna de 32 bits.
Para descobrir os limites do seu 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";
}
Observe que isso long longsó é válido no C99 e no C ++ 11.
Outras pessoas aqui postarão links para data_sizes e precisions, etc.
Vou lhe dizer como descobrir você mesmo.
Escreva um pequeno aplicativo que fará o seguinte.
unsigned int ui;
std::cout << sizeof(ui));
isto irá (dependendo do compilador e arquitetura) imprimir 2, 4 ou 8, dizendo 2 bytes de comprimento, 4 bytes de comprimento etc.
Vamos supor que sejam 4.
Agora você quer o valor máximo que 4 bytes podem armazenar, o valor máximo para um byte é (em hexadecimal) 0xFF. O valor máximo de quatro bytes é 0x seguido por 8 f's (um par de f's para cada byte, o 0x diz ao compilador que a seguinte string é um número hexadecimal). Agora mude seu programa para atribuir esse valor e imprimir o resultado
unsigned int ui = 0xFFFFFFFF;
std::cout << ui;
Esse é o valor máximo que um int sem sinal pode conter, mostrado na representação de base 10.
Agora faça isso por longos, shorts e qualquer outro valor INTEGER que você esteja curioso.
NB: Esta abordagem não funcionará para números de ponto flutuante (ou seja, duplo ou flutuante).
Espero que isto ajude
Em C ++, agora int e outros dados são armazenados usando o método de complemento de 2. Isso significa que o intervalo é:
-2147483648 to 2147483647
ou -2 ^ 31 a 2 ^ 31-1
1 bit é reservado para 0, portanto, o valor positivo é menor que 2 ^ (31)
Você pode usar as funções numeric_limits<data_type>::min()e numeric_limits<data_type>::max()presentes no limitsarquivo de cabeçalho e encontrar os limites de cada tipo de dados.
#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;
}
A saída será: Limites de tipos de dados:
Para o tipo de dados sem sinal, não há bit de sinal e todos os bits são para dados; enquanto que para tipo de dados assinados sinal MSB é indicado o bit de sinal e os bits restantes são para os dados.
Para encontrar o intervalo, faça o seguinte:
Passo: 1 -> Descubra o número de bytes para o tipo de dado dado.
Passo: 2 -> Aplicar os seguintes cálculos.
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
Por exemplo
Para tamanho interno sem sinal = 4 bytes (32 bits) -> Intervalo [0, (2 ^ (32)) - 1]
Para tamanho interno assinado = 4 bytes (32 bits) -> Intervalo [- (2 ^ (32-1)), (2 ^ (32-1)) - 1]
Não, apenas parte do número de dez dígitos pode ser armazenado em um int longo sem sinal cujo intervalo válido é de 0 a 4.294.967.295. você pode consultar: http://msdn.microsoft.com/en-us/library/s3f49ktz(VS.80).aspx
Você deve olhar para as especializações do modelo numeric_limits <> para um determinado tipo. Está no cabeçalho.