short (C# Reference)
The short keyword denotes an integral data type that stores values according to the size and range shown in the following table.
Type |
Range |
Size |
.NET Framework type |
|---|---|---|---|
short |
-32,768 to 32,767 |
Signed 16-bit integer |
Literals
You can declare and initialize a short variable like this example:
short x = 32767;
In the preceding declaration, the integer literal 32767 is implicitly converted from int to short. If the integer literal does not fit into a short storage location, a compilation error will occur.
A cast must be used when calling overloaded methods. Consider, for example, the following overloaded methods that use short and int parameters:
public static void SampleMethod(int i) {}
public static void SampleMethod(short s) {}
Using the short cast guarantees that the correct type is called, for example:
SampleMethod(5); // Calling the method with the int parameter
SampleMethod((short)5); // Calling the method with the short parameter
Conversions
There is a predefined implicit conversion from short to int, long, float, double, or decimal.
You cannot implicitly convert nonliteral numeric types of larger storage size to short (see Integral Types Table (C# Reference) for the storage sizes of integral types). Consider, for example, the following two short variables x and y:
short x = 5, y = 12;
The following assignment statement will produce a compilation error, because the arithmetic expression on the right-hand side of the assignment operator evaluates to int by default.
short z = x + y; // Error: no conversion from int to short
To fix this problem, use a cast:
short z = (short)(x + y); // OK: explicit conversion
It is possible though to use the following statements, where the destination variable has the same storage size or a larger storage size:
int m = x + y;
long n = x + y;
There is no implicit conversion from floating-point types to short. For example, the following statement generates a compiler error unless an explicit cast is used:
short x = 3.0; // Error: no implicit conversion from double
short y = (short)3.0; // OK: explicit conversion
For information on arithmetic expressions with mixed floating-point types and integral types, see float and double.
For more information on implicit numeric conversion rules, see the Implicit Numeric Conversions Table (C# Reference).
C# Language Specification
For more information, see the C# Language Specification. The language specification is the definitive source for C# syntax and usage.
See Also
Reference
Integral Types Table (C# Reference)
Built-In Types Table (C# Reference)
Implicit Numeric Conversions Table (C# Reference)
Explicit Numeric Conversions Table (C# Reference)