# 4.1.5 Integral types

**Visual Studio .NET 2003**

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. - 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. Although`char`

has the same representation as`ushort`

, not all operations permitted on one type are permitted on the other.

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`

. For example,`(char)10`

is the same as`'\x000A'`

.

The `checked`

and `unchecked`

operators and statements are used to control overflow checking for integral-type arithmetic operations and conversions (Section 7.5.12). In a `checked`

context, an overflow produces a compile-time error or causes a `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.