C++ casting between numeric types

Question

I am aware that the different casting operators in C++ have already been discussed here many times but my question is specifically about casting between numeric types, not about the general differences between C style and C++ style operators. I consider this a completely different topic than casting within a class hierarchy.

Say I want to cast an int i to a double, some of the options I have are

static_cast<double>(i)
(double) i
double(i)

Personally I prefer the constructor-like style in the 3rd line in this case because I like to express that this is not a cast beteen class types, where I would certainly use static_cast or dynamic_cast.

Except from making it difficult to find this type of cast when searching in a text editor, are there any drawbacks of my choice?

@Karoly Horvath: Good question, I always try to avoid casts, but typical cases where I do this is within calculations or when passing function arguments. — Frank Puffer, Feb 18 '16 at 12:11
"difficult to find this type of cast" is a reason enough to never use it. — n. m. could be an AI, Feb 18 '16 at 12:17
It's extremely easy to find it... if you know what you're looking for. — Karoly Horvath, Feb 18 '16 at 12:25
Maybe you find this answer helpful: [Regular cast vs. static_cast vs. dynamic_cast](http://stackoverflow.com/questions/28002/regular-cast-vs-static-cast-vs-dynamic-cast) — ttuna, Feb 18 '16 at 12:32
At least, if you send an int into a fcn taking a double, the best thing is to do nothing and just let the automatic conversion take place. Same thing with e.g 'double circumference = diameter * PI' (where diameter is an int). — Erik Alapää, Feb 18 '16 at 12:33

Bathsheba · Accepted Answer · 2016-02-18T12:30:34.667

4

static_cast<double>(i) is certainly the clearest expression of your intent in this particular case.

When casting between numeric types, you are often a stone's throw away from undefined behaviour. So be careful in general. Although your cast is defined for every possible value of i, casting a double to an int could overflow the int, and that behaviour is undefined in C++.

I would always advise your checking if the destination type can accommodate the source type. std::numeric_limits<>::max() etc. can help here.

The C++ standard does not specify a maximum size of int (although 16, 32, and 64 bit 2's complement are common), so, potentially it might not be representable as a double.

In my code I have a namespace containing

  template<
        typename T/*the desired type*/,
        typename/*the source type*/ Y
    > T integral_cast(const Y& y)
    {
        static_assert(false, "undefined integral_cast");
    }

which I specialise for every numeric cast I need.

edited Feb 18 '16 at 12:30

answered Feb 18 '16 at 12:16

Bathsheba

231,907
34
361
483

2

`static_cast` will not defend you from undefined behavior here. And the OP gave a very good point for their preferred cast for in this particular case. – StoryTeller - Unslander Monica Feb 18 '16 at 12:18
Indeed, but it is a very clear way of writing it. But note that casting from an `int` to a `double` is *always* defined. – Bathsheba Feb 18 '16 at 12:18
That is opinion based. It certainly stands out more, but the notion of constructing a new `double` from an `int` is also very clear. – StoryTeller - Unslander Monica Feb 18 '16 at 12:19
It's defined, but the hyperbole of checking numeric limits was mentioned by you. – StoryTeller - Unslander Monica Feb 18 '16 at 12:20
how to use your code snippet above? how could that be useful? – james Feb 18 '16 at 12:56
The idea is that you specialise it for every case you need and use it in place of `static_cast`. – Bathsheba Feb 18 '16 at 13:00

score 3 · Answer 2 · answered Feb 18 '16 at 12:19

One major drawback of those approaches is the cast is not safe against overflows, and other numeric errors.

Using static_cast is the immediate sane solution and this method is not flagged by static code analysts tools like PVS studio. the (double)i approach generates a warning.

Probably the safest approach is to have your own cast let's say numeric_cast<T>()

template <class OT, class ST>
OT numeric_cast(const ST value)
{
    return static_cast<OT>(value);
}

The advantage of this function is that you can do bound checks and other numeric checks to ensure that the cast is legitimate and does not return (or get) junk values.

There is another way of dealing with numbers but it only work with constant compile-time values. For this check user defined string literals

C++ casting between numeric types

2 Answers2