Smallest expressible value above given value - c++

Question

Given a variable defined as
T x;
where T is a generic arithmetic type (i.e. such that std::is_arithmetic<T>::value), is there a simple expression (e.g something from std::numeric_limits) that evaluates to the lowest value y expressible in T such that y > x?
(i.e. a kind of generalized increment..)

Answer 1

You can use std::nextafter.
Note that here I use std::numeric_limits<Floating>::max(), if you want meaningful behavior for infinities, you might want to modify the code.
#include <iostream>
#include <limits>
#include <cmath>
#include <type_traits>
#include <iomanip>
template <typename Floating,
std::enable_if_t<std::is_arithmetic_v<Floating> && !std::is_integral_v<Floating>, bool> = false>
Floating generic_next_val(Floating val) {
return std::nextafter(val, std::numeric_limits<Floating>::max());
}
template <typename Integral,
std::enable_if_t<std::is_arithmetic_v<Integral> && std::is_integral_v<Integral>, int> = 0>
Integral generic_next_val(Integral val) {
return static_cast<Integral>(val + static_cast<Integral>(1));
}
int main() {
int a = 1;
float f = 0.0f;
std::cout << std::setprecision(20) << generic_next_val(f) << " " << generic_next_val(a) << std::endl;
return 0;
}

Answer 2

The <cmath> header's std::nexttoward() will do this. It accepts a float, double, long double, or integral type, and returns the next value in the direction of its second parameter.
So, given code like this:
T my_val = some_input; // float, double, int, etc.
T next = std::nexttoward(my_val, std::numeric_limits<T>::max());`
If my_val were 1.0f, next would be the next biggest float after 1; if my_val were the integer 2, you would get 3, etc.
(Note that there's a lot of fine print here around numeric overflows, which the CppReference page linked above discusses. The long and short of it is don't pass std::numeric_limits<T>::max() in for the first parameter.)

Answer 3

#include <type_traits>
#include <limits>
#include <iostream>
/*
NOTE: Untested code for 'proof' of concept only.
This will cover all the is_integral<T> except bool.
This should probably be a set of free functions rather than a class
but just to check out the idea. Class should have constraints but as
the final implementation should probably be free functions they are
omitted.
*/
template<typename T>
class GLB{
public:
using limits = std::numeric_limits<T>;
static T get(const T& value){
return value == limits::max() ? limits::max() : value + static_cast<T>(1);
}
};
int main(int, char**){
std::cout << GLB<int>::get(42) << '\n';
std::cout << GLB<unsigned>::get(42) << '\n';
std::cout << GLB<wchar_t>::get(42) << '\n';
return 0;
}
/*
That was the easy bit now what about the floating point numbers.
*/
While fooling around with this scur3 pointed out that cmath can solve the floating point values. So some typing and some testing required.