Why Does C# Allow `short = short` But Not `short = short short`?

C# Short Integer Arithmetic: Understanding = vs. =

C# exhibits seemingly contradictory behavior when adding short integers. Direct assignment (short = short short) fails compilation, while compound assignment (short = short) succeeds. This article clarifies this behavior.

Why short short Results in int

The sum of two short integers is implicitly promoted to an int. This design choice prevents potential overflow errors. Overflow occurs when the result of an arithmetic operation exceeds the maximum value representable by the data type.

Consider this example:

<code class="language-csharp">short[] prices = { 10000, 15000, 11000 };
short average = (prices[0] + prices[1] + prices[2]) / 3; // Compile-time error</code>

Without implicit promotion to int, the addition would overflow, leading to an inaccurate average.

The = Operator's Implicit Cast

The = operator differs from direct assignment. The C# language specification dictates that compound assignment operators perform an implicit cast to the type of the left-hand operand.

For a = b, where a and b are short, the compiler effectively translates this into:

<code class="language-csharp">a = (short)(a + b);</code>

This implicit cast handles potential overflow by truncating the int result back to a short. Note that this truncation can lead to data loss if the sum exceeds the short range.

In Summary

The addition of two short values yields an int to avoid overflow. The = operator's implicit cast allows for concise code while mitigating, but not eliminating, the risk of data loss due to potential overflow during the operation. This provides flexibility, enabling calculations that would otherwise result in compilation errors.

The above is the detailed content of Why Does C# Allow `short = short` But Not `short = short short`?. For more information, please follow other related articles on the PHP Chinese website!