valor máximo de int

¿Hay algún código para encontrar el valor máximo de entero (de acuerdo con el compilador) en la Integer.MaxValuefunción similar a C / C ++ en Java?

En C ++:

#include <limits>

luego usa

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

std::numeric_limits es un tipo de plantilla que se puede instanciar con otros tipos:

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

C ª:

#include <limits.h>

luego usa

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

o

#include <float.h>

float fmin = FLT_MIN;  // minimum positive value
double dmin = DBL_MIN; // minimum positive value

float fmax = FLT_MAX;
double dmax = DBL_MAX;

Sé que es una pregunta antigua, pero tal vez alguien pueda usar esta solución:

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

Hasta ahora tenemos -1 como resultado 'hasta que el tamaño sea ​​un int con signo.

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

Como dice Standard, los bits que se desplazan son 1 si la variable está firmada y negativa y 0 si la variable estaría sin signo o firmada y positiva.

Como el tamaño es con signo y negativo, cambiaríamos en el bit de signo que es 1, lo que no ayuda mucho, por lo que lo convertimos en int sin signo, forzando a cambiar en 0, estableciendo el bit de signo en 0 mientras que todos los demás bits permanecen en 1.

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

También podríamos usar una máscara y xor, pero luego teníamos que saber el tamaño exacto de bits de la variable. Con el desplazamiento de bits al frente, no tenemos que saber en ningún momento cuántos bits tiene el int en la máquina o el compilador ni necesitamos incluir bibliotecas adicionales.

#include <climits>
#include <iostream>
using namespace std;

int main() {
  cout << INT_MAX << endl;
}

Aquí hay una macro que uso para obtener el valor máximo para enteros con signo, que es independiente del tamaño del tipo de entero con signo utilizado, y por el cual gcc -Woverflow no se quejará

#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);

¿Por qué no escribir un código como:

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

OK, no tengo representante para comentar sobre la respuesta anterior (de Philippe De Muyter) ni aumentar su puntaje, de ahí un nuevo ejemplo que usa su definición para SIGNED_MAX trivialmente extendida para tipos sin signo:

// 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;

A diferencia de usar este o aquel encabezado, aquí usamos el tipo real del compilador.

#include <iostrema>

int main(){
    int32_t maxSigned = -1U >> 1;
    cout << maxSigned << '\n';
    return 0;
}

Puede depender de la arquitectura, pero funciona al menos en mi configuración.

Para el valor máximo específico de int , generalmente escribo la notación hexadecimal:

int my_max_int = 0x7fffffff;

en lugar del valor decimal irregular:

int my_max_int = 2147483647;

¿Qué pasa con (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2)). Esto es lo mismo que 2^(8*sizeof(int)-2) - 1 + 2^(8*sizeof(int)-2).

Si 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].

No se puede usar 2*(1 << (8*sizeof(int)-2)) - 1porque se desbordará, pero (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2))funciona.