Warm Up

For a general introduction of overflow, please read the relevant section. Do execute the code shared in this section:

using System;

class Program
{
    static void Main()
    {
        uint n1,
            n2;

        Console.WriteLine("Enter the requested loan amount for the first person:");
        n1 = uint.Parse(Console.ReadLine());

        Console.WriteLine("Enter the requested loan amount for the second person:");
        n2 = uint.Parse(Console.ReadLine());

        if (n1 + n2 < 10000)
        {
            Console.WriteLine($"Pay ${n1} to the first person");
            Console.WriteLine($"Pay ${n2} to the second person");
        }
        else
        {
            Console.WriteLine("Error: the sum of the loans exceeds the maximum allowance.");
        }
    }
}

Make sure you have a general understanding of what overflowing means before proceeding. If you are unsure, reading about integer overflow on wikipedia can help.

We will now enter a surprising world where

• a number can be equal to itself plus one,
• a number plus one can be less than the number itself, and
• a number multiplied by two and then divided by two is the same as the number multiplied by two.

Now, download, execute the “Overflow” solution, and answer the following questions:

• What is the maximum value that can be stored in an int?
• What should be the result of adding one to the maximum value that can be stored in an int?
• What is the result actually displayed by C#?

Then, answer the same questions for the float and double datatypes.

C#’s Checks

We will now study some of the safeguards against overflowing that are implemented in C#. Note that some of those checks have been deactivated by the unchecked command at the beginning of our project. Make sure to complete the following section outside of unchecked’s scope (i.e., after it).

1. Enter the following statements in your program:

   int int_max_value_plus_one_bis = int.MaxValue + 1;

   You should receive an error message. Reads it and try to understand what C# is warning you against.

2. Isn’t that weird that C# let go

   int int_max_value_ter = int.MaxValue;
   int int_max_value_plus_one_ter = int_max_value_ter + 1;

   (even outside an unchecked environment, you can try it) not the previous statement? This is because, by default, arithmetic operations on int are “unchecked”. To check it, use

   int int_max_value = int.MaxValue; 
   int int_max_value_plus_one = checked(int_max_value + 1); // Note the "checked(…)".

   What happens when you try to compile and run this program?

3. Note that our program does not give the result of adding one to the maximum value that can get assigned to a decimal. Try to display on the screen the result of adding one to decimal.MaxValue (both inside and outside the unchecked environment).

Strange Mathematical Properties

Circling back to our prompt in the warm-up section, enter in the following table the value(s) and datatype(s) for x, y, and z:

Note that int.MinValue can similarly be used to produce strange mathematical properties of the same kind.

As funny or interesting as that strange behavior may seem, overflow errors actually caused death and millions of dollars of losses repeatedly, as you can read for instance in this blog post.