c++ - resueltos - valor máximo de int

programa en c++

Question

¿Hay algún código para encontrar el valor máximo de un entero (según el compilador) en C / C ++ como la función Integer.MaxValue en Java?

Answer 1

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

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

Answer 2

¿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 puede usar 2*(1 << (8*sizeof(int)-2)) - 1 porque se desbordará, pero (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2)) funciona.

Answer 3

Aquí hay una macro que uso para obtener el valor máximo para los enteros con signo, que es independiente del tamaño del tipo entero con signo utilizado, y para 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);

Answer 4

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 puede std::numeric_limits una instancia 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;

Answer 5

OK, no tengo representante para comentar la respuesta anterior (de Philippe De Muyter) ni elevo su puntuación, de ahí un nuevo ejemplo que usa su definición para SIGNED_MAX trivialmente extendido para tipos sin firmar:

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

Answer 6

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;

Answer 7

Sé que es una vieja pregunta, 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 firmado.

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 es negativa y 0 si la variable no está firmada o firmada y es positiva.

Como el tamaño está firmado y negativo, cambiaríamos en el bit de signo que es 1, lo que no está ayudando mucho, así que lanzamos a unsigned int, forzando a cambiar en 0, estableciendo el bit de signo a 0 mientras dejamos que todos los demás bits permanezcan 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 en bits, 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.

Answer 8

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

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