X hits on this document

1362 views

0 shares

0 downloads

0 comments

89 / 396

C# LANGUAGE SPECIFICATION

default values of other struct types are ultimately always created through instance constructors of those struct types.

When the operands of an expression are all simple type constants, it is possible for the compiler to evaluate the expression at compile-time. Such an expression is known as a constant-expression (§‎7.15). Expressions involving operators defined by other struct types are not considered to be constant expressions.

Through const declarations it is possible to declare constants of the simple types (§‎10.3). It is not possible to have constants of other struct types, but a similar effect is provided by static readonly fields.

Conversions involving simple types can participate in evaluation of conversion operators defined by other struct types, but a user-defined conversion operator can never participate in evaluation of another user-defined operator (§‎6.4.2).

4.1.5 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.

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.

76Copyright Microsoft Corporation 1999-2003. All Rights Reserved.

Document info
Document views1362
Page views1362
Page last viewedSun Jan 22 06:35:23 UTC 2017
Pages396
Paragraphs9401
Words133190

Comments