Définir un int à l'infini en C++

Question

J'ai un int a qui 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 ?

Answer 1

Les nombres entiers sont par nature finis. Le plus proche que vous puissiez obtenir est de définir a a int La valeur maximale de l'entreprise :

#include <limits>

// ...

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

Ce qui serait 2^31 - 1 (ou 2 147 483 647 ) si int est d'une largeur de 32 bits sur votre implémentation.

Si vous vraiment pour l'infini, utilisez un type de nombre à virgule flottante, tel que float o double . Vous pouvez alors obtenir l'infini avec :

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

Answer 2

Les nombres entiers sont finis, donc malheureusement vous ne pouvez pas l'avoir fixé à un véritable infini. Cependant, vous pouvez le définir sur la valeur maximale d'un int, ce qui signifie qu'il serait supérieur ou égal à n'importe quel autre int, c'est à dire :

a>=b

est toujours vrai.

Pour ce faire, vous devez

#include <limits>

//your code here

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

//go off and lead a happy and productive life

Ce chiffre sera normalement égal à 2 147 483 647.

Si vous avez vraiment besoin d'une véritable valeur "infinie", vous devez utiliser un double ou un flottant. Dans ce cas, vous pouvez simplement faire ceci

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

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

Bon codage !

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

Answer 3

int est par nature finie ; il n'existe aucune valeur qui satisfasse vos exigences.

Si vous êtes prêt à changer le type de b Cependant, vous pouvez le faire avec des surcharges 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
}

Answer 4

C'est un message pour moi à l'avenir :

Il suffit d'utiliser : (unsigned)!((int)0)

Il crée le plus grand nombre possible dans n'importe quelle machine en assignant tous les bits à des 1 (uns), puis le transforme en un nombre non signé.

Encore mieux

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

Et ensuite, utilisez simplement INF dans votre code

Answer 5

Vous pouvez également utiliser INT_MAX :

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

c'est équivalent à l'utilisation de numeric_limits.