*These are some very helpful comments I came across from Stack Overflow. Thanks to Martin York and Adam Liss for providing these useful and concise comments.*

Comment1*:*

Question 1: Float division

`int a = 2, b = 3;`

float c = static_cast(a) / b; // need to convert 1 operand to a float

Question 2: How the compiler works

Five rules of thumb to remember:

* Arithmetic operations are always performed on values of the same type.

* The result type is the same as the operands (after promotion)

* The smallest type arithmetic operations are performed on is int.

* ANSCI C (and thus C++) use value preserving integer promotion.

* Each operation is done in isolation.

The ANSI C rules are as follows:

Most of these rules also apply to C++ though not all types are officially supported (yet).

* If either operand is a long double the other is converted to a long double.

* If either operand is a double the other is converted to a double.

* If either operand is a float the other is converted to a float.

* If either operand is a unsigned long long the other is converted to unsigned long long.

* If either operand is a long long the other is converted to long long.

* If either operand is a unsigned long the other is converted to unsigned long.

* If either operand is a long the other is converted to long.

* If either operand is a unsigned int the other is converted to unsigned int.

* Otherwise both operands are converted to int.

Overflow

Overflow is always a problem. Note. The type of the result is the same as the input operands so all the operations can overflow, so yes you do need to worry about it (though the language does not provide any explicit way to catch this happening.

As a side note:

Unsigned division can not overflow but signed division can.

std::numeric_limits::max() / -1 // No Overflow

std::numeric_limits::min() / -1 // Will Overflow

==============================================================

Comment2:

In general, if operands are of different types, the compiler will promote all to the largest or most precise type:

If one number is… And the other is… The compiler will promote to…

——————- ——————- ——————————-

char int int

signed unsigned unsigned

char or int float float

float double double

Examples:

char + int ==> int

signed int + unsigned char ==> unsigned int

float + int ==> float

Beware, though, that promotion occurs only as required for each intermediate calculation, so:

**4.0 + 5/3 = 4.0 + 1 = 5.0**

This is because the integer division is performed first, then the result is promoted to float for the addition.