C#详解struct和class的区别

简单来说，struct是值类型，创建一个struct类型的实例被分配在栈上。class是引用类型，创建一个class类型实例被分配在托管堆上。但struct和class的区别远不止这么简单。

概括来讲，struct和class的不同体现在：

● class是引用类型，struct是值类型，所有他有值类型和引用类型的区别特征，参见《C#值类型和引用类型的区别》
● class的实例创建是在托管堆上，struct实例创建是在栈上
● class实例的赋值，赋的是引用地址，struct实例的赋值，赋的是值
● class作为参数类型传递，传递的是引用地址，struct作为参数类型传递，传递的是值

● class 的默认访问权限是private，而struct的的默认访问权限public
● struct不能显式地声明无参数构造函数（默认构造函数）或析构函数，也就是struct声明的构造函数必须带有参数；而class可以显式声明无参数构造函数。（由于struct的副本由编译器自动创建和销毁，因此不需要使用默认构造函数和析构函数。实际上，编译器通过为所有字段赋予默认值（参见默认值表（C# 参考））来实现默认构造函数）

● 如果class中只声明了一个有参数的构造函数，则用new关键字创建实例时不能再无参数构造函数（默认构造函数），否则会出现”XXX不包含0个参数的构造函数"的编译错误，这句话的意思表明class中除非没有一个构造函数，否则声明了什么构造函数，就只能用什么构造函数。

而struct中由于只能声明带参数的构造函数，当创建实例时

● class创建实例必须用new关键字，而struct可以用new，也可以不用new，区别在于用new生成的struct中，struct的成员函数是有初始值的。例子如下：

[csharp] view plain copy

1. struct Point  
2. {  
3.     float  x;  
4.     float y;  
5. }  
6. Point p = new Point();p是值类型所以应该在栈上为其分配空间  
7. float a = p.x;  //编译通过,使用new 语句，C#结构体中的成员已经得到初始化,a的值为0  
8. Point p;  
9. foalt a = p.x;  //编译不过,编译器认为p的字段未得到初始化，是未知的  

● class支持继承，struct不支持继承，但支持接口。
● class偏向于"面向对象",用于复杂、大型数据，struct偏向于"简单值"，比如小于16字节，结构简单
● class的成员变量可以在声明的时候赋初值，而在struct声明中，除非字段被声明为 const 或 static，否则无法初始化。

一、从赋值的角度体验struct和class的不同

引用类型赋值，是把地址赋值给了变量

[csharp] view plain copy

1. class Program  
2.   {  
3.     static void Main(string[] args)  
4.     {  
5.       SizeClass sizeClass = new SizeClass(){Width = 10, Length = 10};  
6.       Console.WriteLine("赋值前：width={0},length={1}", sizeClass.Width, sizeClass.Length);  
7.    
8.       var copyOfSizeClass = sizeClass;  
9.       copyOfSizeClass.Length = 5;  
10.       copyOfSizeClass.Width = 5;  
11.       Console.WriteLine("赋值后：width={0},length={1}",sizeClass.Width, sizeClass.Length);  
12.       Console.ReadKey();  
13.     }  
14.   }  
15.    
16.   public class SizeClass  
17.   {  
18.     public int Width { get; set; }  
19.     public int Length { get; set; }  
20.   }  
21.    
22.   public struct SizeStruct  
23.   {  
24.     public int Width { get; set; }  
25.     public int Length { get; set; }  
26.   }  

运行结果如下图所示：

以上，当把sizeClass赋值给copyOfSize变量的时候，是把sizeClass所指向的地址赋值给了copyOfSize变量，2个变量同时指向同一个地址。所以，当改变copyOfSizeClass变量的值，也相当于改变了sizeClass的值。

struct类型赋值，是完全拷贝，在栈上多了一个完全一样的变量

[csharp] view plain copy

1. class Program  
2.   {  
3.     static void Main(string[] args)  
4.     {  
5.       SizeStruct sizeStruct = new SizeStruct(){Length = 10, Width = 10};  
6.       Console.WriteLine("赋值前：width={0},length={1}", sizeStruct.Width, sizeStruct.Length);  
7.    
8.       var copyOfSizeStruct = sizeStruct;  
9.       copyOfSizeStruct.Length = 5;  
10.       copyOfSizeStruct.Width = 5;  
11.       Console.WriteLine("赋值后：width={0},length={1}", sizeStruct.Width, sizeStruct.Length);  
12.       Console.ReadKey();  
13.     }  
14.   }  

程序运行结果如下图所示：

以上，当把sizeStruct赋值给copyOfSizeStruct变量的时候，是完全拷贝，改变copyOfSizeStruct的值不会影响到sizeStruct。

二、从参数传值角度体验struct和class的不同

引用类型参数传递的是地址

[csharp] view plain copy

1. class Program  
2.   {  
3.     static void Main(string[] args)  
4.     {  
5.       List<string> temp = new List<string>(){"my","god"};  
6.       ChangeReferenceType(temp);  
7.       temp.ForEach(t => Console.Write(t + " "));  
8.       Console.ReadKey();  
9.     }  
10.    
11.     public static void ChangeReferenceType(List<string> list)  
12.     {  
13.       list = new List<string>(){"hello", "world"};  
14.     }  
15.   }  

运行结果：my god

为什么不是hello world？
→栈上的temp指向托管堆上的一个集合实例
→当temp放到ChangeReferenceType(temp)方法中，本质是把temp指向的地址赋值给了变量list
→在ChangeReferenceType(List<string> list)方法内部，又把变量list的指向了另外一个集合实例地址
→但temp的指向地址一直没有改变

我们再来改变ChangeReferenceType(List<string> list)内部实现方式，其它不变。

[csharp] view plain copy

1. class Program  
2.   {  
3.     static void Main(string[] args)  
4.     {  
5.       List<string> temp = new List<string>(){"my","god"};       
6.       ChangeReferenceType(temp);  
7.       temp.ForEach(t => Console.Write(t + " "));  
8.       Console.ReadKey();  
9.     }  
10.    
11.     public static void ChangeReferenceType(List<string> list)  
12.     {  
13.       list.Clear();  
14.       list.Add("hello");  
15.       list.Add("world");  
16.     }  
17.   }  

运行结果：hello world

为什么不是my god？ 
→栈上的temp指向托管堆上的一个集合实例
→当temp放到ChangeReferenceType(temp)方法中，本质是把temp指向的地址赋值给了变量list
→在ChangeReferenceType(List<string> list)方法内部，把temp和list共同指向的实例清空，又添加"hello"和"world"2个元素
→由于list和temp指向的实例是一样的，所以改变list指向的实例就等同于改变temp指向的实例

以上，很好地说明了：引用类型参数传递的是地址。

值类型struct参数传递的是值

[csharp] view plain copy

1. class Program  
2.   {  
3.     static void Main(string[] args)  
4.     {  
5.       Size s = new Size(){Length = 10, Width = 10};  
6.       ChangeStructType(s);  
7.       Console.Write("Length={0},Width={1}", s.Length,s.Width);  
8.       Console.ReadKey();  
9.     }  
10.    
11.     public static void ChangeStructType(Size size)  
12.     {  
13.       size.Length = 0;  
14.       size.Width = 0;  
15.     }  
16.   }  
17.    
18.   public struct Size  
19.   {  
20.     public int Length { get; set; }  
21.     public int Width { get; set; }  
22.   }  

运行结果如下图所示：

为什么Length和Width不是0呢？
→在栈上变量size
→当通过ChangeStructType(size)，把s变量赋值给ChangeStructType(Size size)中的size变量，其本质是在栈上又创建了一个变量size，size的值和s是完全一样的
→在ChangeStructType(Size size)内部改变size的值，与变量s毫无关系

三、从struct类型的struct类型属性和struct引用类型属性体验struct和class的不同

假设有一个struct，它有struct类型的属性

以下， struct类型Room有struct类型的属性TableSize和TvSize，我们如何通过Room实例来修改其struct类型的属性值呢？

[csharp] view plain copy

1. class Program  
2.   {  
3.     static void Main(string[] args)  
4.     {  
5.       Room r = new Room()  
6.       {  
7.         TableSize = new Size(){Length = 100, Width = 80},  
8.         TvSize = new Size(){Length = 10, Width = 8}  
9.       };  
10.    
11.       r.TableSize.Length = 0;  
12.          
13.       Console.WriteLine("table目前的尺寸是：length={0},width={1}", r.TableSize.Length, r.TableSize.Width);  
14.       Console.ReadKey();  
15.     }  
16.   }  
17.    
18.   public struct Size  
19.   {  
20.     public int Length { get; set; }  
21.     public int Width { get; set; }  
22.   }  
23.    
24.   public struct Room  
25.   {  
26.     public Size TableSize { get; set; }  
27.     public Size TvSize { get; set; }  
28.   }  

以上，r.TableSize.Length = 0；此处会报错：不能修改r.TableSize的值，因为不是变量。的确，r.TableSize只是Size的一份拷贝，而且也没有赋值给其它变量，所以r.TableSize是临时的，会被自动回收，对其赋值也是没有意义的。

 如果要修改r.TableSize，只需把

r.TableSize.Length = 0;

改成如下：

r.TableSize = new Size(){Length = 0, Width = 0};

运行结果如下图所示：

可见，改变struct类型的struct类型属性的某个属性是行不通的，因为像以上r.TableSize只是一份拷贝，是临时的，会被自动回收的。要改变struct类型的struct类型属性，就需要像上面一样，给r.TableSize赋上一个完整的Size实例。

假设有一个struct，它有引用类型的属性呢？

以下，struct类型的Room有引用类型属性，TableSize和TvSize,如何通过Room实例来修改其引用类型的属性值呢？并且，我们在类Size中定义了一个事件，当给Size的属性赋值时就触发事件，提示size类的属性值发生了改变。

[csharp] view plain copy

1. class Program  
2.   {  
3.     static void Main(string[] args)  
4.     {  
5.       var oneSize = new Size() {Length = 10, Width = 10};  
6.       var twoSize = oneSize;  
7.    
8.       oneSize.Changed += (s, e) => Console.Write("Size发生了改变~~");  
9.       oneSize.Length = 0;  
10.       Console.ReadKey();  
11.     }  
12.   }  
13.    
14.   public class Size  
15.   {  
16.     private int _length;  
17.     private int _width;  
18.    
19.     public event System.EventHandler Changed;  
20.    
21.     public int Length  
22.     {  
23.       get { return _length; }  
24.       set  
25.       {  
26.         _length = value;  
27.         OnChanged();  
28.       }  
29.     }  
30.    
31.     public int Width  
32.     {  
33.       get { return _width; }  
34.       set { _width = value; OnChanged(); }  
35.     }  
36.    
37.     private void OnChanged()  
38.     {  
39.       if (Changed != null)  
40.       {  
41.         Changed(this, new EventArgs());  
42.       }  
43.     }  
44.   }  
45.    
46.   public struct Room  
47.   {  
48.     public Size TableSize { get; set; }  
49.     public Size TvSize { get; set; }  
50.   }  

运行，显示：Size发生了改变~~

对oneSize.Length的修改，实际上修改的是oneSize.Length指向托管堆上的实例。

四、从构造函数体验struct和class的不同

struct类型包含隐式的默认无参构造函数

[csharp] view plain copy

1. class Program  
2.   {  
3.     static void Main(string[] args)  
4.     {  
5.       var size = new SizeStruct();  
6.       Console.WriteLine("length={0},width={1}", size.Length, size.Width);  
7.       Console.ReadKey();  
8.     }  
9.   }  
10.    
11.   public struct SizeStruct  
12.   {  
13.     public int Length { get; set; }  
14.     public int Width { get; set; }  
15.   }  

运行结果如下图所示：

为什么我们没有给SizeStruct定义无参构造函数，而没有报错？
--因为，struct类型有一个隐式的无参构造函数，并且给所有的成员赋上默认值,int类型属性成员的默认值是0。

而如果显式声明struct的默认构造函数，则会报错，

[csharp] view plain copy

1. public struct SizeStruct  
2. {  
3.     public SizeStruct() { } //编译错误，提示结构不能包含显式的无参数构造函数  
4.     public int Length { get; set; }  
5.     public int Width { get; set; }  
6. }  

但是可以声明struct的带参数的构造函数

[csharp] view plain copy

1. public struct SizeStruct  
2. {  
3.     public SizeStruct(int a) { }   
4.     public int Length { get; set; }  
5.     public int Width { get; set; }  
6. }  

一般情况下，如果类中没有声明任何构造函数，那么系统会默认创建一个无参的构造函数，而当你定义了带参数的构造函数以后，系统不会创建无参构造函数，这时候，如果你还想允许无参构造，就必须显式的声明一个

[csharp] view plain copy

1. class Program  
2.   {  
3.     static void Main(string[] args)  
4.     {  
5.       var size = new SizeClass();  
6.       Console.WriteLine("length={0},width={1}", size.Length, size.Width);  
7.       Console.ReadKey();  
8.     }  
9.   }  
10.    
11.   public class SizeClass  
12.   {  
13.     public int Length { get; set; }  
14.     public int Width { get; set; }  
15.    
16.     public SizeClass(int length, int width)  
17.     {  
18.       Length = length;  
19.       Width = Width;  
20.     }  
21.   }  

运行，报错：SizeClass不包含0个参数的构造函数

五、从给类型成员赋初值体验struct和class的不同

如果直接给字段赋初值。

[csharp] view plain copy

1. public struct SizeStruct  
2. {  
3.     public int _length = 10;  
4. }  

运行，报错：结构中不能有实例字段初始值设定项。除非定义的变量是static或者const类型的

如果通过构造函数给字段赋初值。

[csharp] view plain copy

1. public struct SizeStruct  
2.   {  
3.     public int _length;  
4.    
5.     public SizeStruct()  
6.     {  
7.       _length = 10;  
8.     }  
9.   }  

运行，报错：结构中不能包含显式无参数构造函数

可见，给struct类型成员赋初值是不太容易的，而给class成员赋初值,no problem。

何时使用struct，何时使用class?

在多数情况下，推荐使用class类，因为无论是类的赋值、作为参数类型传递，还是返回类的实例，实际拷贝的是托管堆上引用地址，也就大概4个字节，这非常有助于性能的提升。

而作为struct类型，无论是赋值，作为参数类型传递，还是返回struct类型实例，是完全拷贝，会占用栈上的空间。根据Microsoft's Value Type Recommendations，在如下情况下，推荐使用struct：

● 小于16个字节
● 偏向于值，是简单数据，而不是偏向于"面向对象"
● 希望值不可变