The cast converting conceptually comparable types to each other is:
                      hi(static_cast<type>(expression))
                     centt(static_cast<type>(expression))
    This type of cast is used to convert, e.g., a tt(double) to an tt(int):
both are numbers, but as the tt(int) has no fractions precision is potentially
reduced. But the converse also holds true. When the quotient of 
two tt(int) values must be assigned to a tt(double) the fraction part of the
division will get lost unless a cast is used.

Here is an example of such a cast is (assuming tt(quotient) is of type
tt(double) and tt(lhs) and tt(rhs) are tt(int)-typed variables):
        centt(quotient = static_cast<double>(lhs) / rhs;)
    If the cast is omitted, the division operator will ignore the remainder as
its operands are tt(int) expressions. Note that the division should be put
outside of the cast expression. If the division is put inside (as in
tt(static_cast<double>(lhs / rhs))) an em(integer division) will have been
performed em(before) the cast has had a chance to convert the type of an
operand to tt(double).  

    Another nice example of code in which it is a good idea to use the
tt(static_cast<>())-operator is in situations where the arithmetic assignment
operators are used in mixed-typed exprressions. Consider the following
expression (assume tt(doubleVar) is a variable of type tt(double)):
        centt(intVar += doubleVar;)
This statement actually evaluates to:
     centt(intVar = static_cast<int>(static_cast<double>(intVar) +
doubleVar);)
    Here tt(IntVar) is first promoted to a tt(double), and is then added as a
tt(double) value to tt(doubleVar). Next, the sum is cast back to an tt(int).
These two casts are a bit overdone. The same result is obtained by
explicitly casting tt(doubleVar) to an tt(int), thus obtaining an
tt(int)-value for the right-hand side of the expression:
        centt(intVar += static_cast<int>(doubleVar);)