C++ implicit type conversion in argument lists

Question

I am confused about how implicit type conversion works with regard to C++ argument lists. In particular, I have a bunch of functions called like inRange(x, start, end), which return a bool depending on whether x is between start and end.

[In this description inRange is just syntactic sugar for (x > start && x < end) -- which is still nice when x is a long string or an expensive function -- but in the real code there are extra args for handling the open/closed nature of the boundaries.]

I was vague about the types above. In particular there are different implementations for integer and floating point comparisons, and this meant that templates were not really appropriate since there is no C++ linguistic grouping that differentiates int/long/unsigned/size_t etc. from float/double, etc. So I tried to use the type system by defining two versions of inRange with wide enough int/float types:

inline bool inRange(long x, long start, long end)
inline bool inRange(double x, double start, double end)

This won't catch "long long" or similar, but our code only uses at most doubles and longs. So it looked pretty safe: my hope was that inRange(int, long, long) etc. would implicitly upcast the int to a long and everything would be fine. However, in cases where literal doubles are written sloppily for the floating point comparison (which I want to allow), e.g. inRange(mydouble, 10, 20), I also had to add a bunch of explicit casts to get rid of compiler warnings and ensure that the floating point comparison is used:

inline bool inRange(double value, long low, long high) {
  return inRange(value, (double)low, (double)high);
}
inline bool inRange(double value, double low, long high) {
  return inRange(value, low, (double)high, lowbound, highbound);
}
...

Not so nice -- I'd hoped that the conversion of long to double would have been automatic/implicit -- but ok. But the next discovery really screwed me: my compiler encountered an inRange with three ints (not longs) as arguments, and said:

call of overloaded ‘inRange(int&, int&, int&)’ is ambiguous

followed by a list of all the inRange functions defined so far! So C++ doesn't have a preference for (int, int, int) arg lists to be resolved by (long, long, long) rather than by (double, double, double)? Really?

Any help to get me out of this hole would be much appreciated... I'd never have thought something so simple with only primitive types involved could turn out to be so hard to resolve. Making the full set of ~1000 three-arg function signatures with all possible numerical type combinations is not the answer I'm hoping for!

To resolve ambiguity use type identifiers, like a long would be: 50l, unsigned int: 50u, float: 50.f, etc. But, I guess that only solves the case for constants, not variables. — Nic Foster
– Nic Foster, Commented Feb 15, 2012 at 15:23
...templates were not really appropriate since there is no C++ linguistic grouping that differentiates int/long/unsigned/size_t etc. from float/double, etc... -- While this is technically true, in practice it is trivial to implement a template for the general cases and overload that same function for specific cases, just as Nim pointed out in the answer below. This means that outside of the specific cases you've defined for floating point, the generic version will be used (which will eliminate the ambiguity). — Justin ᚅᚔᚈᚄᚒᚔ
– Justin ᚅᚔᚈᚄᚒᚔ, Commented Feb 15, 2012 at 15:34
@Justinᚅᚔᚈᚄᚒᚔ: Actually not so true. std::numeric_limits has a is_integer see reference. — Matthieu M.
– Matthieu M., Commented Feb 15, 2012 at 15:38
@Justinᚅᚔᚈᚄᚒᚔ: I would not venture down that road. A number of things implemented in the standard headers (is_trivially_copyable ?) cannot be defined in "pure C++". Thus I would argue that the Standard Library is part of the language itself; Boost is an extension ;) — Matthieu M.
– Matthieu M., Commented Feb 15, 2012 at 15:47
Being pragmatic here, you say "In particular there are different implementations for integer and floating point comparisons". If they're different, then use different function names for integer and floating-point comparisons. Problem solved! — Mr Lister
– Mr Lister, Commented Feb 15, 2012 at 15:49

Matthieu M. · Accepted Answer · 2012-02-15 20:27:06Z

Templates are the basics here, you just need some SFINAE.

#include <limits>
#include <utility>

template <typename T>
struct is_integral {
  static bool const value = std::numeric_limits<T>::is_integer;
};

template <typename Integral, typename T>
typename std::enable_if<is_integral<Integral>::value, bool>::type
inRange(Integral x, T start, T end) {
  return x >= static_cast<Integral>(start) and x <= static_cast<Integral>(end);
}

template <typename Real, typename T>
typename std::enable_if<not is_integral<Real>::value, bool>::type
inRange(Real x, T start, T end) {
  return x >= static_cast<Real>(start) and x <= static_cast<Real>(end);
}

In theory, we could be even more lenient and just allow start and end to have different types. If we want to.

EDIT: Changed to switch to the real version as soon as there are one real, with built-in sanity check.

#include <limits>
#include <utility>
#include <iostream>

template <typename T>
struct is_integral {
  static bool const value = std::numeric_limits<T>::is_integer;
};

template <typename T>
struct is_real {
  static bool const value = not is_integral<T>::value;
};

template <typename T, typename L, typename R>
struct are_all_integral {
  static bool const value = is_integral<T>::value and
                            is_integral<L>::value and
                            is_integral<R>::value;
};

template <typename T, typename L, typename R>
struct is_any_real {
  static bool const value = is_real<T>::value or
                            is_real<L>::value or
                            is_real<R>::value;
};


template <typename T, typename L, typename R>
typename std::enable_if<are_all_integral<T, L, R>::value, bool>::type
inRange(T x, L start, R end) {
  typedef typename std::common_type<T, L, R>::type common;
  std::cout << "  inRange(" << x << ", " << start << ", " << end << ") -> Integral\n";
  return static_cast<common>(x) >= static_cast<common>(start) and
         static_cast<common>(x) <= static_cast<common>(end);
}

template <typename T, typename L, typename R>
typename std::enable_if<is_any_real<T, L, R>::value, bool>::type
inRange(T x, L start, R end) {
  typedef typename std::common_type<T, L, R>::type common;
  std::cout << "  inRange(" << x << ", " << start << ", " << end << ") -> Real\n";
  return static_cast<common>(x) >= static_cast<common>(start) and
         static_cast<common>(x) <= static_cast<common>(end);
}

int main() {
  std::cout << "Pure cases\n";
  inRange(1, 2, 3);
  inRange(1.5, 2.5, 3.5);

  std::cout << "Mixed int/unsigned\n";
  inRange(1u, 2, 3);
  inRange(1, 2u, 3);
  inRange(1, 2, 3u);

  std::cout << "Mixed float/double\n";
  inRange(1.5f, 2.5, 3.5);
  inRange(1.5, 2.5f, 3.5);
  inRange(1.5, 2.5, 3.5f);

  std::cout << "Mixed int/double\n";
  inRange(1.5, 2, 3);
  inRange(1, 2.5, 3);
  inRange(1, 2, 3.5);

  std::cout << "Mixed int/double, with more doubles\n";
  inRange(1.5, 2.5, 3);
  inRange(1.5, 2, 3.5);
  inRange(1, 2.5, 3.5);
}

Run at ideone:

Pure cases
  inRange(1, 2, 3) -> Integral
  inRange(1.5, 2.5, 3.5) -> Real
Mixed int/unsigned
  inRange(1, 2, 3) -> Integral
  inRange(1, 2, 3) -> Integral
  inRange(1, 2, 3) -> Integral
Mixed float/double
  inRange(1.5, 2.5, 3.5) -> Real
  inRange(1.5, 2.5, 3.5) -> Real
  inRange(1.5, 2.5, 3.5) -> Real
Mixed int/double
  inRange(1.5, 2, 3) -> Real
  inRange(1, 2.5, 3) -> Real
  inRange(1, 2, 3.5) -> Real
Mixed int/double, with more doubles
  inRange(1.5, 2.5, 3) -> Real
  inRange(1.5, 2, 3.5) -> Real
  inRange(1, 2.5, 3.5) -> Real

Thanks Matthieu, that's introduced me to a whole bunch of stuff that I didn't know about! Logically, though, I want to enable the real-valued comparisons if any of the three args (value/start/end) are real-valued: is there a reasonable way to express that in terms of logical combinations in the first template arg of enable_if? e.g. is std::enable_if<is_integral<VAL>::value or is_integral<START>::value or is_integral<END>::value, bool> valid? (where hopefully my implicitly renamed template args are self-evident)
@andybuckley: yes, totally. The constants booleans can be manipulated with the regular booleans operators to form a new constantly evaluated boolean, no issue. However you then need to provide the reverse condition to the "Integral" case to avoid having both enabled at the same time, which would trigger an ambiguity. I'll cook that up, watch for the edit ;)

Nim · Accepted Answer · 2012-02-15 15:17:26Z

0

(Lazy approach:) use a function template - and let the compiler worry about it..

template <typename T1>
inline bool inRange(T1 x, T1 start, T1 end)
{
  // do stuff
}

This means you can pass in any object that supports operator<... And overload for the specific types where you want to do something different (say std::string, const char* etc.)

answered Feb 15, 2012 at 15:17

Nim

33.7k2 gold badges65 silver badges102 bronze badges

3 Comments

andybuckley Over a year ago

That's actually the implementation that we've had for a long time, but it borks with mixed types for x,start,end. Possibly this can be fixed with care, but after several attempts to build specialisations etc. around this I tried returning to the untemplated way... which produced this question! Thanks, though :)

Nim Over a year ago

@andybuckley, if there are mixed types, then you need to make each type a template argument, for example see: ideone.com/3j4xZ

andybuckley Over a year ago

I have a feeling that we then end up back in the ambiguity issue when trying partially specialise for doubles for each of the template arguments, or for longs on all of them. I'll try @Matthieu M's way, since SFINAE is fundamentally the sort of issue I'm trying to deal with here... and if I don't succeed there, I'll revisit this already-trodden way and see if your suggestions deal with all our use-cases: compiling the mass of code that depends on this has been an annoyingly good way to find situations we didn't think of...

Collectives™ on Stack Overflow

C++ implicit type conversion in argument lists

2 Answers 2

2 Comments

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related