When you work with unsigned types, modular arithmetic (also known as "wrap around" behavior) is taking place. To understand this modular arithmetic , just have a look at these clocks:

9 + 4 = 1 ( 13 mod 12 ), so to the other direction it is: 1 - 4 = 9 ( -3 mod 12 ). The same principle is applied while working with unsigned types. If the result type is `unsigned`, then modular arithmetic takes place.

Now look at the following operations storing the result as an `unsigned int`:

``````unsigned int five = 5, seven = 7;
unsigned int a = five - seven;      // a = (-2 % 2^32) = 4294967294

int one = 1, six = 6;
unsigned int b = one - six;         // b = (-5 % 2^32) = 4294967291``````

When you want to make sure that the result is `signed`, then stored it into `signed` variable or cast it to `signed`. When you want to get the difference between numbers and make sure that the modular arithmetic will not be applied, then you should consider using `abs()` function defined in `stdlib.h`:

``````int c = five - seven;       // c = -2
int d = abs(five - seven);  // d =  2``````

Be very careful, especially while writing conditions, because:

``````if (abs(five - seven) < seven)  // = if (2 < 7)
// ...

if (five - seven < -1)          // = if (-2 < -1)
// ...

if (one - six < 1)              // = if (-5 < 1)
// ...

if ((int)(five - seven) < 1)    // = if (-2 < 1)
// ...``````

but

``````if (five - seven < 1)   // = if ((unsigned int)-2 < 1) = if (4294967294 < 1)
// ...

if (one - six < five)   // = if ((unsigned int)-5 < 5) = if (4294967291 < 5)
// ...``````