# Setting an int to Infinity in C++

## Setting an int to Infinity in C++

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();
```

Integers are finite, so sadly you cant 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.

#### Setting an int to Infinity in C++

`int`

is inherently finite; theres no value that satisfies your requirements.

If youre 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
}
```