Compile time error on addition of two short variable [C#]

Question

Possible Duplicate:
Integer summing blues, short += short problem

I have summarized my problem into following code snippet.I have two short vaiable and I am adding these two variable into another short variable,but I am getting compile time error.Why is it so?

 1.short x = 1, y = 1;
 2.short z = x + y;   

Compile time error at line 2 EDIT:

If short+short=int

then why int+int !=long

Answer 1

By specification short + short -> int. Do short z = (short)(x + y);

Best answer is given by Eric Lippert here: Integer summing blues, short += short problem

Answer 2

There is no addition operator defined for short. The compiler will automatically convert those values to int to do the addition. Therefore, the type of the expression x + y will be int. When assigning an int expression to a variable of type short a cast is required. Like this:

short z = (short)(x + y);

NOTE The following information is usually unnecessary.

If you are concerned about overflows in a checked context, do this:

short z = unchecked((short)(x + y));

This is usually not necessary, though, since unchecked is the default setting for most (or all) C# compilers, and that setting is hardly ever changed. If the assignment appears inside a checked statement, then presumably the person writing the code knows what they're doing.

Answer 3

This is documented behaviour

You need to cast short z = (short)(x + y);

Answer 4

It's a "feature". Seriously, I posted a similar question to Microsoft regarding byte math a while back. I don't know if you can see my posting without logging in, but the reply was:

https://connect.microsoft.com/VisualStudio/feedback/details/92880/byte-bit-wise-and-math-requires-work-around#details

It is by design, and is due to the rules around numeric promotion, and there not being predefined operators for byte. (It tripped me up too, when I first encountered it. ;-)

Here is relevant portion of the Language Specification. Though the example is for multiply, the same holds for plus.

hope it helps

Santosh

14.2.6 Numeric promotions This subclause is informative. Numeric promotion consists of automatically performing certain implicit conversions of the operands of the predefined unary and binary numeric operators. Numeric promotion is not a distinct mechanism, but rather an effect of applying overload resolution to the predefined operators. Numeric promotion specifically does not affect evaluation of user-defined operators, although user-defined operators can be implemented to exhibit similar effects. As an example of numeric promotion, consider the predefined implementations of the binary * operator: int operator *(int x, int y); uint operator *(uint x, uint y); long operator *(long x, long y); ulong operator *(ulong x, ulong y); void operator *(long x, ulong y); void operator *(ulong x, long y); float operator *(float x, float y); double operator *(double x, double y); decimal operator *(decimal x, decimal y); When overload resolution rules (§14.4.2) are applied to this set of operators, the effect is to select the first of the operators for which implicit conversions exist from the operand types. [Example: For the operation b * s, where b is a byte and s is a short, overload resolution selects operator *(int, int) as the best operator. Thus, the effect is that b and s are converted to int, and the type of the result is int. Likewise, for the operation i * d, where i is an int and d is a double, overload resolution selects operator *(double, double) as the best operator. end example] End of informative text.

Answer 5

Two Shorts CAN make an INT so it is not possible to implicitly cast X + Y as a short. change it to

int z = x + y; 

and it will run

Based on comments I am adding the following code sample to clear up some issues:

    class BasicMath
   {

         short s_max = short.MaxValue; // the max value for a short (or an Int16) is 32767
         int i_max = int.MaxValue; // the max value for an int (or an Int32) is 2,147,483,647
         long l_max = long.MaxValue; // the max value for a long (Int64) is 9,223,372,036,854,775,807

      public int AddingShorts(short x, short y)
      {


         short addedvalues = (short)(x + y);
         //yes this will compile and run, but the result of 32767 + 32767 = -2

         //short addedShorts = (short)s_max + s_max;

         int addedInts = i_max + i_max;
         //No, this doesn't require a cast, but it also achieves the spectaclar result of 
         //2,147,483,647 + 2,147,483,647 = -2
         return addedvalues;
         //casting a short to an int works implicitly (note the return type here is int, not short)
         //still if you pass in values of exceeding 32767 you will end up with -2 because attempting
         //cast as a short a value of greater than 32767 results in -2. 
      }


   }

Why does the compiler require short + short to be (at least) an int and does not apply the same rule to ints? Ask Anders... The fact is this is 'the rule the compiler enforces' on all days ending in "Y"

If you attempt to simply CAST the sum of two shorts as a short, yes it will compile but it is also prone to produce a result you will not be happy with.

Cheers

Answer 6

That's because the sum of two Int16s is an Int32 so you might need a cast:

 short z = (short)(x + y);