111. Types

10char

11floating-point-type:

12 float

13double

14enum-type:

16All value types implicitly inherit from class object. It is not possible for any type to derive from a value

17type, and value types are thus implicitly sealed (§17.1.1.2).

18A variable of a value type always contains a value of that type. Unlike reference types, it is not possible for

19a value of a value type to be null, or to reference an object of a more derived type.

20Assignment to a variable of a value type creates a copy of the value being assigned. This differs from

21assignment to a variable of a reference type, which copies the reference but not the object identified by the

22reference.

2311.1.1 The System.ValueType type

24All value types implicitly inherit from the class System.ValueType, which, in turn, inherits from class

25object.

26Note that System.ValueType is not itself a value-type. Rather, it is a class-type from which all value-types

27are automatically derived.

2811.1.2 Default constructors

29All value types implicitly declare a public parameterless instance constructor called the default constructor.

30The default constructor returns a zero-initialized instance known as the default value for the value type:

31• For all simple-types, the default value is the value produced by a bit pattern of all zeros:

32o For sbyte, byte, short, ushort, int, uint, long, and ulong, the default value is 0.

33o For char, the default value is '\x0000'.

34o For float, the default value is 0.0f.

35o For double, the default value is 0.0d.

36o For decimal, the default value is 0m.

37o For bool, the default value is false.

38• For an enum-type E, the default value is 0.

39• For a struct-type, the default value is the value produced by setting all value type fields to their default

40value and all reference type fields to null.

41Like any other instance constructor, the default constructor of a value type is invoked using the new

42operator. [Note: For efficiency reasons, this requirement is not intended to actually have the implementation

43generate a constructor call. For value types, the default value expression (§14.5.13) produces the same result

106

C# LANGUAGE SPECIFICATION

1• Most simple types permit values to be created by writing literals (§9.4.4). [Example: 123 is a literal of

2type int and 'a' is a literal of type char. end example] C# makes no provision for literals of struct

3types in general.

4• When the operands of an expression are all simple type constants, the compiler evaluates the expression

5at compile-time. Such an expression is known as a constant-expression (§14.15). Expressions involving

6operators defined by other struct types are not considered to be constant expressions.

7• Through const declarations, it is possible to declare constants of the simple types (§17.3). It is not

8possible to have constants of other struct types, but a similar effect is provided by static readonly

9fields.

10• Conversions involving simple types can participate in evaluation of conversion operators defined by

11other struct types, but a user-defined conversion operator can never participate in evaluation of another

12user-defined conversion operator (§13.4.2).

1311.1.5 Integral types

14C# supports nine integral types: sbyte, byte, short, ushort, int, uint, long, ulong, and char. The

15integral types have the following sizes and ranges of values:

16• The sbyte type represents signed 8-bit integers with values from –128 to 127, inclusive.

17• The byte type represents unsigned 8-bit integers with values from 0 to 255, inclusive.

18• The short type represents signed 16-bit integers with values from –32768 to 32767, inclusive.

19• The ushort type represents unsigned 16-bit integers with values from 0 to 65535, inclusive.

20• The int type represents signed 32-bit integers with values from –2147483648 to 2147483647,

21inclusive.

22• The uint type represents unsigned 32-bit integers with values from 0 to 4294967295, inclusive.

23• The long type represents signed 64-bit integers with values from –9223372036854775808 to

249223372036854775807, inclusive.

25• The ulong type represents unsigned 64-bit integers with values from 0 to 18446744073709551615,

26inclusive.

27• The char type represents unsigned 16-bit integers with values from 0 to 65535, inclusive. The set of

28possible values for the char type corresponds to the Unicode character set. [Note: Although char has

29the same representation as ushort, not all operations permitted on one type are permitted on the other.

30end note]

31The integral-type unary and binary operators always operate with signed 32-bit precision, unsigned 32-bit

32precision, signed 64-bit precision, or unsigned 64-bit precision, as detailed in clause §14.

33The char type is classified as an integral type, but it differs from the other integral types in two ways:

34• There are no implicit conversions from other types to the char type. In particular, even though the

35sbyte, byte, and ushort types have ranges of values that are fully representable using the char type,

36implicit conversions from sbyte, byte, or ushort to char do not exist.

37• Constants of the char type shall be written as character-literals or as integer-literals in combination

38with a cast to type char. [Example: (char)10 is the same as '\x000A'. end example]

39The checked and unchecked operators and statements are used to control overflow checking for integral-

40type arithmetic operations and conversions (§14.5.12). In a checked context, an overflow produces a

41compile-time error or causes a System.OverflowException to be thrown. In an unchecked context,

42overflows are ignored and any high-order bits that do not fit in the destination type are discarded.

108