valor máximo de int

177

¿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?

d3vdpro
fuente
1
¿Hay alguna manera de encontrar el valor máximo de long long int ??
d3vdpro
Simplemente reemplace intcon la long long intrespuesta de Gregories ...
Georg Fritzsche
1
excepto que mucho tiempo no es parte de C ++
Duplicado de, por ejemplo, stackoverflow.com/questions/1732011/c-max-integer
Georg Fritzsche el
@Neil, a la derecha, es C99, pero VC y GCC (sin -pedantic) lo admiten.
Georg Fritzsche

Respuestas:

323

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;
Gregory Pakosz
fuente
13
Tenga en cuenta que los puntos flotantes minson el valor positivo mínimo , mientras que el número entero mines el valor mínimo. Lo mismo ocurre con las macros / constantes de C.
dalle
44
en C99 también puede usar UINT64_MAX e INT64_MAX
Dmitry Vyal
3
@DmitryVyal: Sí, puedes, pero esos son los límites de , uint64_ty int64_tno de int.
Keith Thompson
En C ++, utilicé el mismo código que se muestra arriba: #include <limits>y int imax = std::numeric_limits<int>::max();, pero obtengo el error Can't resolve struct member 'max'. ¿Alguna idea de por qué ocurre esto y cómo solucionarlo? Estoy usando CLion IDE, con CMake y C ++ 11 en Ubuntu 14.04. Creo que está relacionado con este problema
modulitos
1
Esperemos que esto ayude a alguien, porque fue un error de CLion IDE que solucioné utilizando el último CLion (compilación 138.2344 - CLion está en la fase del Programa de acceso temprano, y por lo tanto inestable)
modulitos
30

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.

MJeB
fuente
1
cout << "INT_MAX:\t" << (int) ((~((unsigned int) 0)) >> 1) << '\n' << "UINT_MAX:\t" << ~((unsigned int) 0) << endl;
Slaiyer
15
#include <climits>
#include <iostream>
using namespace std;

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

fuente
1
No llamaría INT_MAX "una solución para C". Sin embargo, es de la vieja escuela y está en desuso en C ++.
Paul Tomblin
66
Creo que ambas son respuestas de C ++. numeric_limits<int>::max()- funciona también en contextos de plantilla, pero (por alguna razón insondable para mí) no puede usarse como una constante de tiempo de compilación. INT_MAX- es una macro, bastante inútil dentro de las funciones de plantilla, pero se puede usar como una constante de tiempo de compilación.
UncleBens
17
Lo curioso es que numeric_limits <int> :: max implementación en msvc se ve así: return (INT_MAX);
Nikola Smiljanić
13
@paul Referencia para la desaprobación por favor. ¿Y adivina cómo numeric_limits implementa max ()? Así es, "return INT_MAX", al menos en GCC 4.4.0.
2
@UncleBens: las funciones en línea actualmente no se pueden reducir a expresiones constantes.
Georg Fritzsche
1

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);
Philippe De Muyter
fuente
1

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

int  max_neg = ~(1 << 31);
int  all_ones = -1;
int max_pos = all_ones & max_neg;
Prabhu
fuente
28
No hay garantía de que int tenga un tamaño de 32 bits y no hay garantía sobre el formato entero negativo en memoria. Menos importante, no hay necesidad de hacer que la gente busque '~'.
Sqeaky
0

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.

A. Genchev
fuente
0
#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.

macmur
fuente
-1

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;
Hao
fuente
-1

¿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.

izanbf1803
fuente