CODEWITHSUNDEEP
c++ccasting
Benny K
Benny K

Reputation: 2087

Explicit casting in C/C++

After reading several SO posts on the subject I am still confused, mainly concerning to integer and boolean variables/expressions.

A. Integer expressions

Suppose I want to use modulo expression in a floating point computation, what, if any, is the most correct of the following? Is there any difference between C and C++? or should I just trust the compiler to make the correct conversion?

double sign;
int num = rand() % 100;
//want to map odd num to -1.0 and even num to 1.0
//A
sign = -2 * (num % 2) + 1;
//B
sign = -2.0 * (num % 2) + 1;
//C
sign = -2.0 * (num % 2) + 1.0;
//D
sign = -2 * (num % 2) + 1.0;
//E
sign = -2 * (double)(num % 2) + 1;
//F
sign = -2.0 * (double)(num % 2) + 1;
//G
sign = -2.0 * (double)(num % 2) + 1.0;
//H
sign = -2 * (double)(num % 2) + 1.0;

B. Boolean expressions

Can I use a boolean expression, safely, as an element in floating / integer computations without explicit casting? Is there a difference between C and C++?

double d_res = 1.0;
int i_res = 1;
int num = rand() % 10;
d_res = d_res + (num > 5);//or d_res = d_res + (double)(num > 5)?
i_res += (num > 5);//or i_res += (int)(num > 5)?

Upvotes: 4

Views: 282

Answers (1)

Steve Summit
Steve Summit

Reputation: 47925

A. The initialization

double sign = -2 * (num % 2) + 1;

is perfectly well-defined. That's what I'd use; I don't think there's any need to complicate things with extra casts or anything.

C and C++ are well-defined and convenient in their implicit conversions between integer and floating-point types. Explicit conversions are usually not needed. In my experience there are only three things to worry about:

  • Code like double ratio = 1 / 3 doesn't do what you want; you need to force one of the operands to / to be floating-point. (This has nothing to do with your question, but it's an extremely easy mistake to make.)
  • Overflow, if one type or the other can't represent the value. (Also not a problem for your example.)
  • Overzealous compilers. Many compilers will "helpfully" warn you that you might lose precision when converting from double to float, or from a floating-point type to an integer. So you may need explicit casts to silence those warnings.

B. Asking for the numeric value of a Boolean is perfectly well-defined (is guaranteed to give you a nice, clean, 1 or 0), so your second fragment should be fine also. (I know this is true for C, and per a comment below, it's true for C++ also.)

Upvotes: 6

Related Questions