valor máximo de int

Existe algum código para encontrar o valor máximo de inteiro (de acordo com o compilador) em C / C + + como a function Integer.MaxValue em java?

Em C ++:

 #include  

então use

 int imin = std::numeric_limits::min(); // minimum value int imax = std::numeric_limits::max(); 

std::numeric_limits é um tipo de modelo que pode ser instanciado com outros tipos:

 float fmin = std::numeric_limits::min(); // minimum positive value float fmax = std::numeric_limits::max(); 

Em C:

 #include  

então use

 int imin = INT_MIN; // minimum value int imax = INT_MAX; 

ou

 #include  float fmin = FLT_MIN; // minimum positive value double dmin = DBL_MIN; // minimum positive value float fmax = FLT_MAX; double dmax = DBL_MAX; 

Eu sei que é uma pergunta antiga, mas talvez alguém possa usar essa solução:

 int size = 0; // Fill all bits with zero (0) size = ~size; // Negate all bits, thus all bits are set to one (1) 

Até agora temos -1 como resultado até o tamanho ser um int assinado.

 size = (unsigned int)size >> 1; // Shift the bits of size one position to the right. 

Como diz o Standard, os bits deslocados são 1 se a variável for assinada e negativa e 0 se a variável for sem sinal ou assinada e positiva.

Como o tamanho é assinado e negativo, nós mudamos em bit de sinal que é 1, o que não está ajudando muito, então convertemos para unsigned int, forçando a mudança em 0, definindo o bit de sinal para 0 enquanto deixando todos os outros bits permanecerem 1.

 cout << size << endl; // Prints out size which is now set to maximum positive value. 

Nós também poderíamos usar uma máscara e xor mas nós tivemos que saber o tamanho exato da variável. Com a mudança na frente de bits, não precisamos saber a qualquer momento quantos bits o int tem na máquina ou no compilador nem precisamos include bibliotecas extras.

 #include  #include  using namespace std; int main() { cout << INT_MAX << endl; } 

Por que não escrever um trecho de código como:

 int max_neg = ~(1 << 31); int all_ones = -1; int max_pos = all_ones & max_neg; 

Aqui está uma macro que eu uso para obter o valor máximo para números inteiros assinados, que é independente do tamanho do tipo inteiro assinado usado, e para o qual o gcc -Wowflow não vai reclamar

 #define SIGNED_MAX(x) (~(-1 << (sizeof(x) * 8 - 1))) int a = SIGNED_MAX(a); long b = SIGNED_MAX(b); char c = SIGNED_MAX(c); /* if char is signed for this target */ short d = SIGNED_MAX(d); long long e = SIGNED_MAX(e); 

OK, eu não tenho representante para comentar a resposta anterior (de Philippe De Muyter) nem aumentar sua pontuação, portanto, um novo exemplo usando seu define para SIGNED_MAX estendido trivialmente para tipos não assinados:

 // We can use it to define limits based on actual compiler built-in types also: #define INT_MAX SIGNED_MAX(int) // based on the above, we can extend it for unsigned types also: #define UNSIGNED_MAX(x) ( (SIGNED_MAX(x)<<1) | 1 ) // We reuse SIGNED_MAX #define UINT_MAX UNSIGNED_MAX(unsigned int) // on ARM: 4294967295 // then we can have: unsigned int width = UINT_MAX; 

Ao contrário de usar este ou aquele header, aqui usamos o tipo real do compilador.

Para o valor máximo específico de int , normalmente escrevo a notação hexadecimal:

 int my_max_int = 0x7fffffff; 

em vez do valor decimal irregular:

 int my_max_int = 2147483647; 

E quanto a (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2)) . Isto é o mesmo que 2^(8*sizeof(int)-2) - 1 + 2^(8*sizeof(int)-2) .

Se sizeof(int) = 4 => 2^(8*4-2) - 1 + 2^(8*4-2) = 2^30 - 1 + 20^30 = (2^32)/2 - 1 [max signed int of 4 bytes] .

Você não pode usar 2*(1 << (8*sizeof(int)-2)) - 1 porque ele irá transbordar, mas (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2)) funciona.