11.1.4 Integral types
C# supports nine integral types: sbyte, byte, short, ushort, int, uint,
long, ulong, and char. The
integral types have the following sizes and ranges of values:
?The sbyte type represents signed 8-bit integers with values between .128
and 127.
C# LANGUAGE SPECIFICATION
92
?The byte type represents unsigned 8-bit integers with values between 0
and 255.
?The short type represents signed 16-bit integers with values between
.32768 and 32767.
?The ushort type represents unsigned 16-bit integers with values between 0
and 65535.
?The int type represents signed 32-bit integers with values between
.2147483648 and 2147483647.
?The uint type represents unsigned 32-bit integers with values between 0
and 4294967295.
?The long type represents signed 64-bit integers with values between
.9223372036854775808 and
9223372036854775807.
?The ulong type represents unsigned 64-bit integers with values between 0
and
18446744073709551615.
?The char type represents unsigned 16-bit integers with values between 0
and 65535. The set of possible
values for the char type corresponds to the Unicode character set. [Note:
Although char has the same
representation as ushort, not all operations permitted on one type are
permitted on the other. end note]
The integral-type unary and binary operators always operate with signed
32-bit precision, unsigned 32-bit
precision, signed 64-bit precision, or unsigned 64-bit precision:
?For the unary + and ~ operators, the operand is converted to type T,
where T is the first of int, uint,
long, and ulong that can fully represent all possible values of the
operand. The operation is then
performed using the precision of type T, and the type of the result is T.
?For the unary . operator, the operand is converted to type T, where T is
the first of int and long that
can fully represent all possible values of the operand. The operation is
then performed using the
precision of type T, and the type of the result is T. The unary . operator
cannot be applied to operands of
type ulong.
?For the binary +, ., *, /, %, &, ^, |, ==, !=, >, <, >=, and <=
operators, the operands are converted to
type T, where T is the first of int, uint, long, and ulong that can fully
represent all possible values of
both operands. The operation is then performed using the precision of type
T, and the type of the result is
T (or bool for the relational operators). It is not permitted for one
operand to be of type long and the
other to be of type ulong with the binary operators.
?For the binary << and >> operators, the left operand is converted to type
T, where T is the first of int,
uint, long, and ulong that can fully represent all possible values of the
operand. The operation is then
performed using the precision of type T, and the type of the result is T.
The char type is classified as an integral type, but it differs from the
other integral types in two ways:
?There are no implicit conversions from other types to the char type. In
particular, even though the
sbyte, byte, and ushort types have ranges of values that are fully
representable using the char type,
implicit conversions from sbyte, byte, or ushort to char do not exist.
?Constants of the char type must be written as character-literals or as
integer-literals in combination
with a cast to type char. [Example: For example, (char)10 is the same as 抃x0
00A? end example]
The checked and unchecked operators and statements are used to control
overflow checking for integraltype
arithmetic operations and conversions (?4.5.12). In a checked context, an
overflow produces a
compile-time error or causes an System.OverflowException to be thrown. In
an unchecked context,
overflows are ignored and any high-order bits that do not fit in the
destination type are discarded.