C# Calculator given code

Question

I'm working on homework and in this assignment I was given starter code. We are working with classes which I have done before and seem to get overwhelmed by. The starter code is confusing me, I personally would have rather just started the assignment by myself. I have a couple of questions about it and I was wondering if someone could help me interpret it so I could get this assignment cranked out.

The biggest question that I have is pretty simple. If you have a calculator you have your first number, then your second number. So if the user enters 1 + 1 then you basically have your numbers. The code we were given doesn't have like a firstNumber and secondNumber. Instead if I am understanding this correctly it has displayValue and currentValue (?) I'm not entirely sure how these values are being stored, and I believe they already are?

That's really what I am trying to find out, and then whether or not I am coding my class properly since I'm hung up on what my actual numbers are that are entered are being stored as in the program.

Here is the code that was provided.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace Calculator
{
public partial class frmCalculator : Form
{
    public frmCalculator()
    {
        InitializeComponent();
    }

    // The following fields are used to store the value that's currently
    // displayed by the calculator. displayString is a string value that's
    // constructed as the user clicks numeric keys and the decimal and +/-
    // key. The Convert.ToDecimal method is then used to convert this to a decimal
    // field that's stored in displayValue.
    private string displayString;
    private decimal displayValue;

    // The following bool fields are used to control numeric entry.
    // newValue indicates whether the calculator is ready to receive a
    // new numeric value. Once the user clicks a digit button, newValue is
    // set to false. When the user clicks a button that "enters" the value, 
    // such as Add or Equals, newValue is set to true so the user can enter 
    // another value.
    // decimalEntered is used to restrict the entry to a single decimal point.
    // It is set to true whenever newValue is set to true, and it is set to 
    // false whenever the user clicks the decimal point button.
    private bool newValue;
    private bool decimalEntered;

    private Calculator calc = new Calculator();

    private void Form1_Load(object sender, System.EventArgs e)
    {
        displayValue = 0;
        displayString = displayValue.ToString();
        newValue = true;
        decimalEntered = false;
    }

    // This method handles the 0 through 9 keys, appending the digit clicked
    // to the displayString field. 
    private void btnNumber_Click(object sender, System.EventArgs e)
    {
        if (newValue)
        {
            displayString = "";
            newValue = false;
        }
        displayString += ((Button)sender).Tag.ToString();
        displayValue = Convert.ToDecimal(displayString);
        txtDisplay.Text = displayValue.ToString();
    }

    // This method removes the last character from the displayString field.
    private void btnBackSpace_Click(object sender, System.EventArgs e)
    {
        if (displayString.Length > 1)
        {
            displayString = displayString.Substring(0, displayString.Length - 1);
            displayValue = Convert.ToDecimal(displayString);
            txtDisplay.Text = displayValue.ToString();
        }
        else
        {
            displayString = "";
            displayValue = 0;
            txtDisplay.Text = displayValue.ToString();
        }

    }

    private void btnClear_Click(object sender, System.EventArgs e)
    {
        calc.Clear();
        displayString = "";
        displayValue = 0;
        txtDisplay.Text = displayValue.ToString();
        newValue = true;
        decimalEntered = false;
    }

    // This method appends a decimal point to the displayString field if the
    // user has not already entered a decimal point.
    private void btnDecimal_Click(object sender, System.EventArgs e)
    {
        if (newValue)
        {
            displayString = "0";
            newValue = false;
        }
        if (!decimalEntered)
        {
            displayString += ".";
            displayValue = Convert.ToDecimal(displayString);
            txtDisplay.Text = displayValue.ToString();
            decimalEntered = true;
        }
    }

    private void btnSign_Click(object sender, System.EventArgs e)
    {
        displayValue = -displayValue;
        txtDisplay.Text = displayValue.ToString();
    }

    private void btnAdd_Click(object sender, System.EventArgs e)
    {
        calc.Add(displayValue);
        newValue = true;
        decimalEntered = false;
        displayValue = calc.CurrentValue;
        txtDisplay.Text = displayValue.ToString();
    }

    private void btnSubtract_Click(object sender, System.EventArgs e)
    {
        calc.Subtract(displayValue);
        newValue = true;
        decimalEntered = false;
        displayValue = calc.CurrentValue;
        txtDisplay.Text = displayValue.ToString();
    }

    private void btnMultiply_Click(object sender, System.EventArgs e)
    {
        calc.Multiply(displayValue);
        newValue = true;
        decimalEntered = false;
        displayValue = calc.CurrentValue;
        txtDisplay.Text = displayValue.ToString();
    }

    private void btnDivide_Click(object sender, System.EventArgs e)
    {
        calc.Divide(displayValue);
        newValue = true;
        decimalEntered = false;
        displayValue = calc.CurrentValue;
        txtDisplay.Text = displayValue.ToString();
    }

    //private void btnSqrt_Click(object sender, System.EventArgs e)
    //{
      //  calc.SquareRoot(displayValue);
        //displayValue = calc.CurrentValue;
        //txtDisplay.Text = displayValue.ToString();
    //}

    //private void btnReciprocal_Click(object sender, System.EventArgs e)
    //{
      //  try
       // {
         //   calc.Reciprocal(displayValue);
           // displayValue = calc.CurrentValue;
            //txtDisplay.Text = displayValue.ToString();
        //}
        //catch (DivideByZeroException)
        //{
          //  displayValue = 0;
           // txtDisplay.Text = "Cannot divide by zero.";
            //newValue = true;
            //decimalEntered = false;
        //}
    }

    private void btnEquals_Click(object sender, System.EventArgs e)
    {
        try
        {
            if (newValue)
                calc.Equals();
            else
                calc.Equals(displayValue);
            displayValue = calc.CurrentValue;
            txtDisplay.Text = displayValue.ToString();
            newValue = true;
            decimalEntered = false;
        }
        catch (DivideByZeroException)
        {
            displayValue = 0;
            txtDisplay.Text = "Cannot divide by zero.";
            newValue = true;
            decimalEntered = false;
        }
    }

}
}

Then a sample from my class (to save space and time I will only do one of my operands)

 namespace Calculator
{
public class Calculator
{

    public Decimal displayValue;
    public Decimal currentValue;
    public Decimal firstNumber;
    public Decimal secondNumber;

     public decimal Add(Decimal displayValue)
    {

     return displayValue + currentValue;

    }

and then I'm assuming since there isn't a currentValue and that comes from the class I'm assuming it would be reference displayValue? Although I'm not sure if that goes back to what the user just entered, or if it will basically repeat itself? (if that makes sense... but I mean you can see how I am confused by this part).

So really yeah, I'm just looking for someone to interpret that and just let me know if I am understanding that correctly and going in the right direction... otherwise I guess I'm screwed....

Thanks in advance.

Answer 1

You have to store the result in current Value variable as this is later used in the code. Also, the usage of the methods of the calculator suggest that they should not return any values.

public void Add(Decimal displayValue) 
{ 
    currentValue += display Value;
}

The reason for making it like that is the following line from btnAdd_Click:

displayValue = calc.CurrentValue;

It expects CurrentValue property to hold the current value.

Answer 2

The reason for the current value and display value is because you actually don't have a first number and second number. In a real calculator, you can usually continue adding values as long as you wish - so the key presses could go something like 2 + 2 = + 3 = +3 + 3 +3 or something. Trying to store that would be wasteful, and using just a first number second number limiting. What happens therefore is that when an operator is pressed, you can tell the code to get the value displayed, and set that as the current value. Then, when you press a number after the operator, that value is the display value, and you perform the calculation based on the operator.

So, for example, you press

2

then you press

+

. What you can do is take the display value - 2 - and hold it is as the currentValue. Then you might choose to press

3

, and then

=

. It will perform the action of + on the specified numbers - 2 + 3, and give the answer - 5.

The benefit of this is that you don't have to stop there. You can then press

 + 5

and then

 =

and you would get a value of 10. And so you could continue doing this for as long as needed, without having huge amounts of memory usage.

If you want the complete code for a calculator, then I had to make one a while back for a project, and so you can ask for it and I'll add the code on into this reply.

Answer 3

The code in question is part of a complete process to emulate a scientific calculator.

You have a displayValue and you have a currentValue, among other variables.

If you think about the way that a real calculator works, when you enter a number, it shows up on the display. When you enter a second number, it pushes the number already there to the left, and sticks the new number in the singles place. So if you enter a 1, you have 1. If you next press 0, now you have 10. This is being handled by the click methods already, so displayValue is always the numbers you have typed in sequence. When you hit the + - * / then these should be executing the missing methods for add, subtract, multiply, divide.

The "display" portion of your calculator was done, so you can focus on how those calculation methods work. They should take the displayValue and perform their operations against currentValue, updating current value in the process.