Impostazione di un int su Infinity in C ++

Ho un int ache deve essere uguale a "infinito". Ciò significa che se

int b = anyValue;

a>b è sempre vero.

C'è qualche caratteristica di C ++ che potrebbe renderlo possibile?

Gli interi sono intrinsecamente finiti. Il più vicino si può ottenere è impostando aa int's valore massimo:

#include <limits>

// ...

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

Quale sarebbe 2^31 - 1(o 2 147 483 647) se intè largo 32 bit nella tua implementazione.

Se hai davvero bisogno di infinito, usa un tipo di numero in virgola mobile, come floato double. Puoi quindi ottenere l'infinito con:

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

I numeri interi sono finiti, quindi purtroppo non puoi averli impostati su un vero infinito. Tuttavia puoi impostarlo al valore massimo di un int, questo significherebbe che sarebbe maggiore o uguale a qualsiasi altro int, ovvero:

a>=b

è sempre vero.

Lo faresti entro

#include <limits>

//your code here

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

//go off and lead a happy and productive life

Normalmente sarà pari a 2.147.483.647

Se hai davvero bisogno di un vero valore "infinito", dovresti usare un double o un float. Quindi puoi semplicemente farlo

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

Ulteriori spiegazioni sui limiti numerici possono essere trovate qui

Buona programmazione!

Nota: come menzionato da WTP, se è assolutamente necessario avere un int "infinito" dovresti scrivere una classe wrapper per un int e sovraccaricare gli operatori di confronto, anche se probabilmente non è necessario per la maggior parte dei progetti.

intè intrinsecamente finito; non c'è valore che soddisfi le tue esigenze.

Se sei disposto a cambiare il tipo di b, però, puoi farlo con l'override dell'operatore:

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
}

Questo è un messaggio per me in futuro:

Usa solo: (unsigned)!((int)0)

Crea il numero più grande possibile in qualsiasi macchina assegnando tutti i bit a 1 (uno) e quindi lo converte in unsigned

Anche meglio

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

E poi usa semplicemente INF nel tuo codice

Puoi anche usare INT_MAX:

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

è equivalente all'utilizzo di numeric_limits.

valori int min e 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

immagino che potresti impostare a uguale a 9,223,372,036,854,775,807 ma dovrebbe essere un int64

se vuoi sempre a essere più grattugia che b perché devi controllarlo? basta impostarlo in modo che sia sempre vero