Establecer un int en Infinity en C ++

Tengo un int aque debe ser igual a "infinito". Esto significa que si

int b = anyValue;

a>b siempre es cierto.

¿Existe alguna característica de C ++ que pueda hacer esto posible?

Los enteros son inherentemente finitos. Lo más cercano que puede obtener es estableciendo el valor máximo de ato int:

#include <limits>

// ...

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

Cuál sería 2^31 - 1(o 2 147 483 647) si inttiene 32 bits de ancho en su implementación.

Si realmente necesita infinito, use un tipo de número de punto flotante, como floato double. Luego puede obtener el infinito con:

double a = std::numeric_limits<double>::infinity();

Los enteros son finitos, por lo que, lamentablemente, no puede haberlo establecido en un verdadero infinito. Sin embargo, puede establecerlo en el valor máximo de un int, esto significaría que sería mayor o igual a cualquier otro int, es decir:

a>=b

siempre es cierto.

Harías esto por

#include <limits>

//your code here

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

//go off and lead a happy and productive life

Esto normalmente será igual a 2,147,483,647

Si realmente necesita un valor "infinito" verdadero, tendría que usar un doble o un flotante. Entonces puedes simplemente hacer esto

float a = std::numeric_limits<float>::infinity();

Aquí se pueden encontrar explicaciones adicionales de los límites numéricos.

¡Feliz codificación!

Nota: Como mencionó WTP, si es absolutamente necesario tener un int que sea "infinito", tendría que escribir una clase contenedora para un int y sobrecargar los operadores de comparación, aunque esto probablemente no sea necesario para la mayoría de los proyectos.

intes inherentemente finito; no hay valor que satisfaga sus requisitos.

Sin embargo, si está dispuesto a cambiar el tipo de b, puede hacerlo con anulaciones de operador:

class infinitytype {};

template<typename T>
bool operator>(const T &, const infinitytype &) {
  return false;
}

template<typename T>
bool operator<(const T &, const infinitytype &) {
  return true;
}

bool operator<(const infinitytype &, const infinitytype &) {
  return false;
}


bool operator>(const infinitytype &, const infinitytype &) {
  return false;
}

// add operator==, operator!=, operator>=, operator<=...

int main() {
  std::cout << ( INT_MAX < infinitytype() ); // true
}

Este es un mensaje para mí en el futuro:

Solo usa: (unsigned)!((int)0)

Crea el mayor número posible en cualquier máquina asignando todos los bits a unos (unos) y luego lo convierte en unsigned

Aun mejor

#define INF (unsigned)!((int)0)

Y luego solo usa INF en tu código

También puede utilizar INT_MAX:

http://www.cplusplus.com/reference/climits/

es equivalente a usar numeric_limits.

valores int min y max

Int -2,147,483,648 / 2,147,483,647 Int 64 -9,223,372,036,854,775,808 / 9,223,372,036,854,775,807

supongo que podría establecer un igual a 9,223,372,036,854,775,807 pero tendría que ser un int64

si siempre quieres que a sea más rallado, ¿por qué necesitas comprobarlo? solo configúralo para que sea cierto siempre