CODEWITHSUNDEEP
c++infinity
daniel gratzer
daniel gratzer

Reputation: 53881

Setting an int to Infinity in C++

I have an int a that needs to be equal to "infinity". This means that if

int b = anyValue;

a>b is always true.

Is there any feature of C++ that could make this possible?

Upvotes: 159

Views: 372144

Answers (6)

Amrit Sanjeev
Amrit Sanjeev

Reputation: 323

I think that a macro INFINITY is defined in header "<cmath>".

It is defined as follows,

#define INFINITY ((float)(1e+300 * 1e+300))

This is such a large number that no other number (at least in c++) can be greater than it. But obviously since we are converting to a type (int), which at max can hold a value 2147483647. So then it would implicitly convert to that value.

Upvotes: 6

Wilmer E. Henao
Wilmer E. Henao

Reputation: 4302

This is a message for me in the future:

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

It creates the largest possible number in any machine by assigning all bits to 1s (ones) and then casts it to unsigned

Even better

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

And then just use INF in your code

Upvotes: 14

nicodjimenez
nicodjimenez

Reputation: 1208

You can also use INT_MAX:

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

it's equivalent to using numeric_limits.

Upvotes: 10

daniel gratzer
daniel gratzer

Reputation: 53881

Integers are finite, so sadly you can't have set it to a true infinity. However you can set it to the max value of an int, this would mean that it would be greater or equal to any other int, ie:

a>=b

is always true.

You would do this by

#include <limits>

//your code here

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

//go off and lead a happy and productive life

This will normally be equal to 2,147,483,647

If you really need a true "infinite" value, you would have to use a double or a float. Then you can simply do this

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

Additional explanations of numeric limits can be found here

Happy Coding!

Note: As WTP mentioned, if it is absolutely necessary to have an int that is "infinite" you would have to write a wrapper class for an int and overload the comparison operators, though this is probably not necessary for most projects.

Upvotes: 92

Etienne de Martel
Etienne de Martel

Reputation: 36852

Integers are inherently finite. The closest you can get is by setting a to int's maximum value:

#include <limits>

// ...

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

Which would be 2^31 - 1 (or 2 147 483 647) if int is 32 bits wide on your implementation.

If you really need infinity, use a floating point number type, like float or double. You can then get infinity with:

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

Upvotes: 185

bdonlan
bdonlan

Reputation: 231123

int is inherently finite; there's no value that satisfies your requirements.

If you're willing to change the type of b, though, you can do this with operator overrides:

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
}

Upvotes: 13

Related Questions