I can't figure out how to use switches in combination with an enum. Could you please tell me what I'm doing wrong, and how to fix it? I have to use an enum to make a basic calculator.
public enum Operator
{
PLUS, MINUS, MULTIPLY, DIVIDE
}
public double Calculate(int left, int right, Operator op)
{
int i = (int) op;
switch(i)
{
case 0:
{
return left + right;
}
case 1:
{
return left - right;
}
case 2:
{
return left * right;
}
case 3:
{
return left / right;
}
default:
{
return 0.0;
}
}
}
The end result should be something like this:
Console.WriteLine("The sum of 5 and 5 is " + Calculate(5, 5, PLUS))
Output: The sum of 5 and 5 is 10
Could you guys please tell me how I'm messing up?
This question is related to
c#
enums
switch-statement
switch-expression
Since C# 8.0 introduced a new switch expression for enums you can do it even more elegant:
public double Calculate(int left, int right, Operator op) =>
op switch
{
Operator.PLUS => left + right,
Operator.MINUS => left - right,
Operator.MULTIPLY => left * right,
Operator.DIVIDE => left / right,
_ => 0
}
Ref. https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8
All the other answers are correct, but you also need to call your method correctly:
Calculate(5, 5, Operator.PLUS))
And since you use int
for left
and right
, the result will be int
as well (3/2 will result in 1
). you could cast to double
before calculating the result or modify your parameters to accept double
Your code is fine. In case you're not sure how to use Calculate function, try
Calculate(5,5,(Operator)0); //this will add 5,5
Calculate(5,5,Operator.PLUS);// alternate
Default enum values start from 0 and increase by one for following elements, until you assign different values. Also you can do :
public enum Operator{PLUS=21,MINUS=345,MULTIPLY=98,DIVIDE=100};
In case you don't want to use return statement for each case, try this:
Calculate(int left, int right, Operator op)
{
int result = 0;
switch(op)
{
case Operator.PLUS:
{
result = left + right;;
}
break;
....
}
return result;
}
Two things. First, you need to qualify the enum reference in your test - rather than "PLUS", it should be "Operator.PLUS". Second, this code would be a lot more readable if you used the enum member names rather than their integral values in the switch statement. I've updated your code:
public enum Operator
{
PLUS, MINUS, MULTIPLY, DIVIDE
}
public static double Calculate(int left, int right, Operator op)
{
switch (op)
{
default:
case Operator.PLUS:
return left + right;
case Operator.MINUS:
return left - right;
case Operator.MULTIPLY:
return left * right;
case Operator.DIVIDE:
return left / right;
}
}
Call this with:
Console.WriteLine("The sum of 5 and 5 is " + Calculate(5, 5, Operator.PLUS));
You should not cast to integer. And for the division, you need to cast left to double first, if not you will be doing an integer divide.
public enum Operator
{
PLUS, MINUS, MULTIPLY, DIVIDE
}
public double Calculate(int left, int right, Operator op)
{
double sum = 0.0;
switch(op)
{
case Operator.PLUS:
sum = left + right;
return sum;
case Operator.MINUS:
sum = left - right;
return sum;
case Operator.MULTIPLY:
sum = left * right;
return sum;
case Operator.DIVIDE:
sum = (double)left / right;
return sum;
default:
return sum;
}
return sum;
}
simply don't cast to int
switch(operator)
{
case Operator.Plus:
//todo
public enum Operator
{
PLUS, MINUS, MULTIPLY, DIVIDE
}
public class Calc
{
public void Calculate(int left, int right, Operator op)
{
switch (op)
{
case Operator.DIVIDE:
//Divide
break;
case Operator.MINUS:
//Minus
break;
case Operator.MULTIPLY:
//...
break;
case Operator.PLUS:
//;;
break;
default:
throw new InvalidOperationException("Couldn't process operation: " + op);
}
}
}
The correct answer is already given, nevertheless here is the better way (than switch):
private Dictionary<Operator, Func<int, int, double>> operators =
new Dictionary<Operator, Func<int, int, double>>
{
{ Operator.PLUS, ( a, b ) => a + b },
{ Operator.MINUS, ( a, b ) => a - b },
{ Operator.MULTIPLY, ( a, b ) => a * b },
{ Operator.DIVIDE ( a, b ) => (double)a / b },
};
public double Calculate( int left, int right, Operator op )
{
return operators.ContainsKey( op ) ? operators[ op ]( left, right ) : 0.0;
}
No need to convert. You can apply conditions on Enums inside a switch. Like so,
public enum Operator
{
PLUS,
MINUS,
MULTIPLY,
DIVIDE
}
public double Calculate(int left, int right, Operator op)
{
switch (op)
{
case Operator.PLUS: return left + right;
case Operator.MINUS: return left - right;
case Operator.MULTIPLY: return left * right;
case Operator.DIVIDE: return left / right;
default: return 0.0;
}
}
Then, call it like this:
Console.WriteLine("The sum of 5 and 5 is " + Calculate(5, 5, Operator.PLUS));
Source: Stackoverflow.com