structure
Structure (struct) is a data structure that encapsulates data and functions. Compared with class (class), the biggest difference is that structure is a value type, while a class is a reference type. The general structure is used for objects that are simpler than classes.
Structure declaration and use
Like classes, structures can contain various members, such as: constructors, constants, fields, methods, properties, indexers, events, operators, and nested value types. At the same time, the structure can also implement interfaces. The type declaration format of the structure is as follows:
struct 结构名 [:接口名]
{
...
}
struct
The structure type is suitable for representing simple data structures such as points, matrices, and colors. E.g:
struct Point
{
public double x, y;
public Point (double x, double y) {
this.x = x;
this.y = y;
}
public double R () {
return Math.Sqrt (x * x + y * y);
}
}
class Program
{
static void Main (string[] args) {
Point[] points = new Point[100];
for (int i = 0; i < points.Length; i++) {
points[i] = new Point (i, i * i); // 数值的copy
Console.WriteLine (points[i].R ());
}
}
}
Using structures instead of classes for Point can make a big difference in the storage location of the members. In the above program, an array of 100 elements is created and initialized. If Point
implemented with a class, the program will take up 101 discrete objects, one for the array, and the other 100 for each element. However, if the structure is used to implement Point, the program will only occupy one object, that is, one array, which is more efficient.
Restrictions on the use of the structure
The structure does not support inheritance during use. When using the structure, you need to pay attention to the following points:
- Structures cannot be inherited from other types, only from interfaces. But all structures are implicitly inherited
Object
. - The structure cannot include parameterless construction methods. It is believed that any configuration, the system automatically provides a no-argument constructor, the constructor automatically assigned an initial value for each field (
0
,false
,null
etc.). - If there is a construction method, in the construction method, you must explicitly assign a value to each field so that each field is determined.
- When each field is defined, no initial value can be given. But the
const
constant must be assigned a value. - The structure cannot have a destructor method.
- Structure members cannot be modified by protected, as they
protected
are related to inheritance. - Variable structure type can not be used
==
to compare determined, unless the operator being defined==
.
When using a structure, the instantiation of the structure can be done without using new
operators. If not used new
, then all of the fields are the default initial value ( 0
, false
, null
etc.). If used new
, you can call the corresponding construction method. In short, the instantiation of the structure can be used new
or not new
, and the instantiation of the class must be used new
.
enumerate
Enumeration (enum) is used in situations where there are multiple choices. Enumeration types provide a type name for a set of symbolic constants. Each member in the enumeration is actually a symbolic constant. E.g:
enum LightColor
{
Red, Yellow, Green
}
It declares an enumerated type Color
that represents 3 possibilities: Red
, Yellow
, Green
. Here are three values are actually three integers 0
, , 1
, 2
but compared with integer, enum make better readability, and easy to detect errors.
Enumeration declaration
Declare enumeration types using keywords enum
. The basic format of the declaration is as follows:
enum 枚举名 [:基本类型名]
{
枚举成员 [ = 常数表达式],
...
}
Each enumeration type has a corresponding integer type, called the underlying type of the enumeration type. A statement can be enumerated explicitly declared byte
, sbyte
, short
, ushort
, int
, uint
, long
or ulong
a basic types. Note that char cannot be used as a basic type. If the basic type is not declared, the default is int
.
Implicit assignment determines the value according to the following rules:
enum Color
{
Red,
Green = 10,
Blue,
Max = Blue
}
Where Red
the value is 0
, Green
the value is 10
, Blue
the value is 11
, and Max
the value is 11
.
Modifiers cannot be explicitly used in front of enumeration members. Each enumeration member is implicitly const, and its value cannot be changed; each member is implicitly public
true, and its access control is unrestricted; each member is implicitly static
true, and the enumeration type name is used directly for access . E.g:
enum LightColor
{
Red, Yellow, Green
}
class TrafficLight
{
public static void WhatInfo(LightColor color) {
switch (color) {
case LightColor.Red:
Console.WriteLine("Stop!");
break;
case LightColor.Yellow:
Console.WriteLine("Warning!");
break;
case LightColor.Green:
Console.WriteLine("Go!");
break;
default:
break;
}
}
public static LightColor GetRandomColor() {
Random rng = new Random();
int num = rng.Next (3);
return (LightColor)num;
}
}
class Test
{
static void Main (string[] args) {
LightColor c = TrafficLight.GetRandomColor();
Console.WriteLine(c.ToString());
TrafficLight.WhatInfo(c);
}
}
Enumeration operations
Each enumerated type is automatically System.Enum
derived from the class . Therefore, Enum
the methods and properties of the class can be used on the value of an enumerated type. For enumerated type, the operator can use most of the integer type can be used, comprising: a ==, !=, <, >, <=, >=, +, -, ^, &, |, ~, ++, --, sizeof
.
The conversion between enumeration type and integer type should use coercive type conversion. A special case is that the constant 0 can be implicitly converted to any enumerated type.
Enumeration types can also be converted to and from strings. The ToString()
method of the enumeration type can get a string, which is the name of the corresponding enumeration member, as used in the above example Console.WriteLine(c.ToString());
.
System.Enum
The Parse()
method can convert the enumeration constant string into an equivalent enumeration object. Parse()
The method format is as follows:
public static object Parse(Type, string);
E.g:
Color c = (Color)Enum.Parse(typedef(Color), "Red");