O que variam de valores inteiros pode armazenar tipos em C ++

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

  •  10-07-2019
  •  | 
  •  

Pergunta

Can unsigned long int segurar um número de dez dígitos (1000000000 - 9999999999) em um computador de 32 bits

?

Além disso, quais são as gamas de unsigned long int, long int, unsigned int, short int, short unsigned int e int?

Foi útil?

Solução

O mínimo varia você pode confiar são:

  • short int e int: -32.767 a 32.767
  • unsigned short int e unsigned int: 0 a 65.535
  • long int: -2147483647 a 2.147.483.647
  • unsigned long int: 0 a 4,294,967,295

Isto significa que não, long int não pode ser invocado para armazenar qualquer número de 10 dígitos. No entanto, um tipo long long int maior foi introduzido para C em C99 e C ++ em C ++ 11 (este tipo também é muitas vezes suportado como uma extensão por compiladores construído para padrões mais antigos que não incluí-lo). O intervalo mínimo para este tipo, se suas sustentações do compilador, é:

  • long long int: -9.223.372.036.854.775.807 para 9.223.372.036.854.775.807
  • unsigned long long int: 0 a 18.446.744.073.709.551.615

Assim que tipo será grande o suficiente (novamente, se que você tem disponível).

Uma nota para aqueles que acreditam que eu cometi um erro com esses limites inferiores - eu não tenho. Os requisitos C para as faixas são escritos para permitir representações complemento ou sinal de magnitude inteiros queridos, onde o menor valor representável eo maior valor representável diferem apenas no sinal. Também é permitido ter representação a dois complemento onde o valor com sinal bit 1 e todos os bits de valor 0 é uma representação armadilha em vez de um valor legal. Em outras palavras, int é não necessário para ser capaz de representar o valor -32.768.

Outras dicas

O tamanho dos tipos numéricos não está definida no padrão C ++, embora os tamanhos mínimos são. A maneira de dizer o tamanho que eles estão em sua plataforma é usar limites numéricos

Por exemplo, o valor máximo para um int pode ser encontrado: 

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

computadores não trabalho na base 10, o que significa que o valor máximo irá ser na forma de dois n -1 devido ao modo como os números de representar em memória. Tome, por exemplo oito bits (1 byte) 

  0100 1000

O direito mais bits (número) quando conjunto para um representa 2 0 , o próximo bit 2 1 , em seguida, 2 2 e assim até chegarmos ao bit mais à esquerda, que, se o número não está assinado representa 2 7 .

Assim, o número representa 2 6 + 2 3 = 64 + 8 = 72, porque o quarto bit a partir da direita e o sétimo bit direita à esquerda são conjunto.

Se definir todos os valores a 1: 

11111111

O número agora é (assumindo não assinado )
+ 64 + 128 32 + 16 + 8 + 4 + 2 + 1 = 255 = 2 8 - 1 | E como podemos ver, que é o maior valor possível que pode ser representado com 8 bits.

Na minha máquina e int e uma longa são os mesmos, cada um capaz de manter entre -2 31 a 2 31 - 1. Na minha experiência, o tamanho mais comum na moderna máquina desktop de 32 bits.

Para saber os limites de o 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";
}

Note que long long só é legal em C99 e no C ++ 11.

Outros gente aqui vai postar links para data_sizes e precisões etc.
Vou dizer-lhe como descobrir a si mesmo.
Escreva um pequeno aplicativo que irá fazer o seguinte. 

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

essa vontade (dependendo do compilador e archicture) imprimir 2, 4 ou 8, dizendo 2 bytes, 4 bytes de comprimento etc.

Vamos supor que é 4.

Agora você deseja que o valor máximo de 4 bytes podem armazenar, o valor máximo para um byte é (em hex) 0xFF. O valor máximo de quatro bytes é 0x seguido por 8 de F (um par de f do para cada byte, o 0x informa o compilador que a cadeia que se segue é um número hex). Agora, mudar o seu programa para atribuir esse valor e imprimir o resultado 

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

Isso é o valor máximo um unsigned int pode conter, mostrada na representação de base 10.

Agora, fazer isso por longos de, shorts e qualquer outro valor inteiro você está curioso sobre.

NB:. Esta abordagem não funciona para números de ponto (isto é, duas vezes ou flutuador) flutuante

Espero que isso ajude

C ++, agora int e outros dados são armazenados usando o método de complemento de dois. Isso significa que o intervalo é: 

-2147483648 to 2147483647

ou -2 ^ 31-2 ^ 31-1

1 bit é reservado para 0 valor tão positivo é um menos do que 2 ^ (31)

Para tipo de dados não assinado não há nenhum bit de sinal e todos os bits são para dados ; enquanto que para tipo de dados assinado MSB é o bit de sinal indicada e bits restantes são para dados.

Para encontrar o intervalo do seguinte coisas:

Passo:. 1 -> Saiba nenhum dos bytes para o tipo de dados give

Passo:. 2 -> Aplicar seguinte 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 unsigned int size = 4 bytes (32 bits) -> intervalo [0, (2 ^ (32)) - 1]

Para int assinado size = 4 bytes (32 bits) -> Faixa [- (2 ^ (32-1)), (2 ^ (32-1)) - 1]

Não, apenas parte do número de dígitos de dez pode ser armazenado em um int longo sem sinal, cujo válido intervalo é de 0 a 4294967295. você pode referir-se a isto: http://msdn.microsoft.com/en-us /library/s3f49ktz(VS.80).aspx

Can int longo não assinado segurar um número de dez dígitos (1000000000 - 9999999999). Em um computador de 32 bits

Não

Você deve olhar para as especializações dos numeric_limits <> modelo para um determinado tipo. Sua no cabeçalho.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top