11.1.3 Simple types

最新推荐文章于 2021-09-07 12:33:50 发布

原创最新推荐文章于 2021-09-07 12:33:50 发布 · 889 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#types #constants #struct #literals #compiler #string

c#/c++ 专栏收录该内容

333 篇文章

订阅专栏

本文介绍了C#中的简单类型，它是预定义的结构体类型，通过保留字识别，是System命名空间中预定义结构体类型的别名。简单类型有成员，允许通过字面量创建值，编译器可在编译时计算常量表达式，能声明常量，其转换可参与其他结构体类型转换运算符的计算。

11.1.3 Simple types
C# provides a set of predefined struct types called the simple types. The
simple types are identified through
reserved words, but these reserved words are simply aliases for predefined
struct types in the System
namespace, as described in the table below.
Reserved word Aliased type
sbyte System.SByte
byte System.Byte
short System.Int16
ushort System.UInt16
int System.Int32
uint System.UInt32
long System.Int64
ulong System.UInt64
char System.Char
float System.Single
double System.Double
bool System.Boolean
decimal System.Decimal
Because a simple type aliases a struct type, every simple type has members.
[Example: For example, int
has the members declared in System.Int32 and the members inherited from
System.Object, and the
following statements are permitted:
int i = int.MaxValue; // System.Int32.MaxValue constant
string s = i.ToString(); // System.Int32.ToString() instance method
string t = 123.ToString(); // System.Int32.ToString() instance method
end example] The simple types differ from other struct types in that they
permit certain additional
operations:
?Most simple types permit values to be created by writing literals (?.4.4).
[Example: For example, 123
is a literal of type int and 抋?is a literal of type char. end example] C#
makes no provision for literals
of struct types in general, and non-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, the
compiler evaluates the expression
at compile-time. Such an expression is known as a constant-expression (?4.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 (?7.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 (?3.4.2).