Type Casting and Coercion

• There is a complexity when evaluating expressions.
• We need to be concerned about the type of the result.
• If the operands are the same, the compiler will generally
  • Select the operator that matches the type of the operand
  • Produce a result of the same type.
  • This is usually the desired behavior.
• Some Examples

  int int1, int2, int3;
  float float1, float2, float3;
  
  cout << 3 + 4;      // both a are integer so the result is integer.
  cout << "hello" + " world";   // both are string ...
  
  int1 = int2 - int3;
  int1 = int2 / int3;
  
  float1 = float2 * float3; 

• But sometimes we want to change the result.

  • int average, points, totalPoints;
    ...
    average = points / totalPoints * 100; 

  • Why might this be a problem?
    • Assume points represents the points a student has scored in a class.
    • Assume totalPoints is the total available points.
    • What operation will be performed first?
    • What will the results be?
    • What will happen next?
    • What will average always hold?
• To overcome this, we will use a technique called type casting or just casting.
  • This converts data from one type to another.
  • three methods
    • (type) expression
    • type (expression)
    • static_cast<type>(expression)
  • The first is a c style cast, and DO NOT USE IT.
  • The second is an early c++ style cast
    • The book uses this.
    • a reference
    • This only works with single name data types

      float y;
      long double x;
      
      y = float(4); // is ok
      x = long double(3); // is not ok.  

    • But this is not the current standard.
  • The third is the preferred way to cast
    • A reference
    • It works for all data types.

    • float y;
      long double x;
      
      y = static_cast<float>(4);
      x = static_cast<long double>(3);  

• Casting up and down
  • Casting from a less generic type to a more generic type is seldom a problem.
  • A cast from an int to a float works just fine.
  • The other way is a problem.
  • A cast from a float to an int will "lose information".
    • the behavior is to truncate, not round.

    • int result;
      result = static_cast<int>(4.999); 

    • result will hold a 4.
• Rounding with casting
  • To round properly with a cast just add 0.5

  • int result;
    result = static_cast<int>(4.999 + 0.5); 

  • What happens here?
• If you do not cast, the compiler will do it for you.
  • This is called coercion
  • And is not the best thing.
  • We will add compiler flags in future assignments warn us when we are allowing coercion.
• When an operation with mixed types is encountered
  • The compiler will coerce to the most "generic" types and perform that operation.
  • If it is an assignment statement, it will coerce the left hand side to match the right hand side.
• All of this is a bit theoretical. Let's write a program to convert between temperatures in Fahrenheit and Celsius
  • $c = \frac{5}{9}(f-32) $
  • $f = \frac{9}{5}c + 32 $