Tutorial :To return a double, do I have to cast to double even if types are double in c#?

Question:

To return a double, do I have to cast to double even if types are double?

e.g.

``double a = 32.34;  double b = 234.24;    double result = a - b + 1/12 + 3/12;  ``

Do I have to cast (double) ?

Solution:1

No, you don't. However, your expression almost certainly doesn't do what you want it to.

The expressions 1/12 and 3/12 will be performed using integer arithmetic.

You probably want:

``double result = a - b + 1/12d + 3/12d;  ``

or

``double result = a - b + 1/(double) 12 + 3/(double) 12;  ``

Both of these will force the division to be performed using floating point arithmetic.

The problem here is that if both operands of an arithmetic operator are integers, then the operation is performed using integer arithmetic, even if it's part of a bigger expression which is of type `double`. Here, your expression is effectively:

``double result = a - b + (1 / 12) + (3 / 12);  ``

The addition and subtraction is okay, because the types of `a` and `b` force them to be performed using floating point arithmetic - but because division "binds more tightly" than addition and subtraction (i.e. it's like using the brackets above) only the immediate operands are considered.

Does that make sense?

EDIT: As it's so popular, it makes sense to include devinb's comment here too:

``double result = a - b + 1.0/12.0 + 3.0/12.0;  ``

It's all the same thing as far as the compiler is concerned - you just need to decide which is clearer for you:

``(double) 1  1.0  1d  ``

Solution:2

Nope, no casting is needed.

Solution:3

Of course, there's a clean way to do this without casting:

``double result = a - b + 1.0/12 + 3.0/12;  ``

Solution:4

That really depends on what you're asking about casting. Here are two different cases:

``double a = 32.34;  double b = 234.24;  double result1 = a - b + 1/12 + 3/12;  double result2 = a - b + (double)1/12 + (double)3/12;  Console.WriteLine(result1);  // Result: -201.9  Console.WriteLine(result2);  // Result: -201.566666666667  ``

Either way you're not going to get any complaints about assigning the value to result, but in the first case the division at the end is done using integers which resolve to 0.

Solution:5

Hmm - The way that I've done this for the integer division issue is to do something like:

``double result = a - b + 1/12.0 + 3/12.0  ``

Aside from those though, no casting would be needed.

Solution:6

You should not need to, although it's hard to tell from your question where the cast would be.

Solution:7

When doing math, C# will return the result as the type of whichever argument has the larger type.

As I recall, the order goes something like this (from largest to smallest):

1. decimal
2. double
3. float
4. long / int64
5. int / int32
6. short / int16
7. byte

Of course, this is skipping the unsigned versions of each of these.

Solution:8

In general no casting is needed, but in your example, the `1/12` and `3/12` are integer division, resulting in 0 for each expression. You would need to cast one of the numerator or denominator to `double`.

Solution:9

Casting is used to indicate whenever you want to change one datatype to another type. This is because changing the `type` usually involves a possible loss of data.

e.g.

``double a = 8.49374;    //casting is needed because the datatypes are different.  // a_int will end up with the value is 8, because the precision is lost.  int a_int = (int) a;     double b = (double) a_int;   ``

In that example 'b' will end up with the value of "8.00000..." this is because a_int does not contain ANY decimal information, and so b only has the integer related information at its disposal.

Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Previous
Next Post »