Configurando um int para Infinity em C ++

Eu tenho um int aque precisa ser igual ao "infinito". Isso significa que se

int b = anyValue;

a>b é sempre verdade.

Existe algum recurso do C ++ que poderia tornar isso possível?

Os inteiros são inerentemente finitos. O mais próximo que você pode obter é através da criação ade int's valor máximo:

#include <limits>

// ...

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

Que seria 2^31 - 1(ou 2 147 483 647) se tivesse int32 bits de largura em sua implementação.

Se você realmente precisa do infinito, use um tipo de número de ponto flutuante, como floatou double. Você pode obter o infinito com:

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

Os inteiros são finitos, portanto, infelizmente, você não pode defini-los como um infinito verdadeiro. No entanto, você pode defini-lo com o valor máximo de um int, isso significaria que seria maior ou igual a qualquer outro int, ou seja:

a>=b

é sempre verdade.

Você faria isso por

#include <limits>

//your code here

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

//go off and lead a happy and productive life

Isso normalmente será igual a 2.147.483.647

Se você realmente precisa de um valor "infinito" verdadeiro, terá que usar um double ou um float. Então você pode simplesmente fazer isso

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

Explicações adicionais sobre os limites numéricos podem ser encontradas aqui

Happy Coding!

Nota: Como WTP mencionou, se for absolutamente necessário ter um int que seja "infinito", você teria que escrever uma classe wrapper para um int e sobrecarregar os operadores de comparação, embora isso provavelmente não seja necessário para a maioria dos projetos.

inté inerentemente finito; não há valor que atenda às suas necessidades.

Se você deseja alterar o tipo de b, no entanto, pode fazer isso com as substituições 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
}

Esta é uma mensagem para mim no futuro:

Apenas use: (unsigned)!((int)0)

Ele cria o maior número possível em qualquer máquina, atribuindo todos os bits a 1s (uns) e, em seguida, converte-o em sem sinal

Melhor ainda

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

E então é só usar INF em seu código

Você também pode usar INT_MAX:

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

é equivalente a usar numeric_limits.

valores mínimos e máximos int

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

eu acho que você poderia definir a igual a 9.223.372.036.854.775.807, mas seria necessário ser um int64

se você sempre quer a ser maior que b, por que você precisa verificar? apenas configure para ser verdade sempre