Définition d'un int sur Infinity en C ++

J'ai un int aqui doit être égal à "l'infini". Cela signifie que si

int b = anyValue;

a>b est toujours vrai.

Y a-t-il une fonctionnalité de C ++ qui pourrait rendre cela possible?

Les nombres entiers sont intrinsèquement finis. Le plus proche , vous pouvez obtenir est par la mise aà la intvaleur maximale de:

#include <limits>

// ...

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

Ce qui serait 2^31 - 1(ou 2 147 483 647) si intest de 32 bits de large sur votre implémentation.

Si vous avez vraiment besoin de l'infini, utilisez un type de nombre à virgule flottante, comme floatou double. Vous pouvez alors obtenir l'infini avec:

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

Les nombres entiers sont finis, si malheureusement vous ne pouvez pas l'avoir défini sur un vrai infini. Cependant, vous pouvez le définir à la valeur maximale d'un int, cela signifierait qu'il serait supérieur ou égal à tout autre int, c'est-à-dire:

a>=b

est toujours vrai.

Vous feriez cela en

#include <limits>

//your code here

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

//go off and lead a happy and productive life

Ce sera normalement égal à 2.147.483.647

Si vous avez vraiment besoin d'une vraie valeur «infinie», vous devrez utiliser un double ou un flottant. Ensuite, vous pouvez simplement le faire

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

Des explications supplémentaires sur les limites numériques peuvent être trouvées ici

Bon codage!

Remarque: Comme WTP l'a mentionné, s'il est absolument nécessaire d'avoir un int qui est "infini", vous devrez écrire une classe wrapper pour un int et surcharger les opérateurs de comparaison, bien que ce ne soit probablement pas nécessaire pour la plupart des projets.

intest intrinsèquement fini; il n'y a aucune valeur qui satisfait vos exigences.

Si vous souhaitez modifier le type de b, vous pouvez le faire avec des remplacements d'opérateurs:

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
}

C'est un message pour moi dans le futur:

Utilisez simplement: (unsigned)!((int)0)

Il crée le plus grand nombre possible dans n'importe quelle machine en attribuant tous les bits à 1s (uns), puis le convertit en non signé

Encore mieux

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

Et puis utilisez simplement INF dans votre code

Vous pouvez également utiliser INT_MAX:

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

cela équivaut à utiliser numeric_limits.

int valeurs min et 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

Je suppose que vous pouvez définir un égal à 9,223,372,036,854,775,807 mais il faudrait qu'il s'agisse d'un int64

si vous voulez toujours que a râpé cela b pourquoi avez-vous besoin de le vérifier? il suffit de le définir pour toujours être vrai