Coercion and Type Casting

• When expressions involve different types, caution is needed.
• Going from a less general type to a more general type is not a problem
  • Assigning an int into a float is not a problem.
    • The int type is a subset of float type. (Sort of)
    • This is a form of coercion, and we will talk about this soon
  • Assigning a short into an int is not a problem.
    • The shot type is a subset of the int type.
    • This is called promotion and is not a problem.
    • Promotion is discussed in chapter 7.
• Going from a superset to a subset can cause problems.
  • Going from an int to a short can cause strange results

    • int i;
      short s;
      
      i = 1024*1024+1
      s = i
      cout << " i  = " << i << ", s = " << s << endl;
      
      produces
      i  = 1048577, s = 1
      	  

    • This is called demotion and the top order bits are discarded.
    • Demotion is discussed in chapter 9.
  • Going from a float to an int, the decimal bits are discarded.

    • int i;
      float f;
      
      f = 7.0/2.0 ;
      
      cout << " i = " << i << ", f = " << f << endl;
      
      Will Produce
       i = 3, f = 3.5
      	     

    • Notice the .5 is discarded, not rounded up.
    • This is coercion.
• Coercion is the automatic conversion from one type to another.
  • Coercion is done by the compiler automatically.
  • We (here at EUP at least) do not like coercion.
• Type conversion or type casting or casting is where the programmer explicitly converts a value from one type to another.
  • Two ways to do this (C, C++)
    • a = type(x)
    • a = (type) x
  • I prefer the first, but you see both.
  • It does not change the results if your expressions are properly formed.
  • But it does document that a type change is occurring.
  • And you should do it.
• Some things to look out for
  • Integer division
    • 5/9 IS 0
  • intVar = int(floatVar + 0.5)
    • This is a way to round up.
    • There are others, but this will do.
  • floatvar = int / int
    • f = 7/3;
    • This will evaluate int 7 divided by int 3, so the results will be 2.
    • Then the 2 will coerced to a 2.0
    • f = float(7/3) will do the same thing.
    • f = 7.0/3 will do the right thing.
    • f = 7/3.0 will as well.
    • f = float(7) / float(3) is good too.
    • f = 7.0/3.0 is probably the best.
    • f = intA/intB has the same problem.
    • f = float(intA)/float(intB)