C#中struct和class的区别详解 (转载)

本文详细分析了C#中struct和class的区别，对于C#初学者来说是有必要加以了解并掌握的。

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

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

● 类是引用类型，struct是值类型
● 在托管堆上创建类的实例，在栈上创建struct实例
● 类实例的赋值，赋的是引用地址，struct实例的赋值，赋的是值
● 类作为参数类型传递，传递的是引用地址，struct作为参数类型传递，传递的是值
● 类没有默认无参构造函数，struct有默认无参构造函数
● 类支持继承，struct不支持继承
● 类偏向于"面向对象",用于复杂、大型数据，struct偏向于"简单值"，比如小于16字节，结构简单
● 类的成员很容易赋初值，很难给struct类型成员赋初值
● 类的实例只能通过new SomeClass()来创建，struct类型的实例既可以通过new SomeStruct()来创建，也可以通过SomeStruct myStruct;来创建

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

class Program    {      static void Main( string [] args)      {        SizeClass sizeClass = new SizeClass(){Width = 10, Length = 10};        Console.WriteLine( "赋值前：width={0},length={1}" , sizeClass.Width, sizeClass.Length);          var copyOfSizeClass = sizeClass;        copyOfSizeClass.Length = 5;        copyOfSizeClass.Width = 5;        Console.WriteLine( "赋值后：width={0},length={1}" ,sizeClass.Width, sizeClass.Length);        Console.ReadKey();      }    }      public class SizeClass    {      public int Width { get ; set ; }      public int Length { get ; set ; }    }      public struct SizeStruct    {      public int Width { get ; set ; }      public int Length { get ; set ; }    }

运行结果如下图所示：

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class Program    {      static void Main( string [] args)      {        SizeStruct sizeStruct = new SizeStruct(){Length = 10, Width = 10};        Console.WriteLine( "赋值前：width={0},length={1}" , sizeStruct.Width, sizeStruct.Length);          var copyOfSizeStruct = sizeStruct;        copyOfSizeStruct.Length = 5;        copyOfSizeStruct.Width = 5;        Console.WriteLine( "赋值后：width={0},length={1}" , sizeStruct.Width, sizeStruct.Length);        Console.ReadKey();      }    }

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

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

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class Program    {      static void Main( string [] args)      {        List< string > temp = new List< string >(){ "my" , "god" };        temp.ForEach(t => Console.Write(t + " " ));        Console.ReadKey();      }        public static void ChangeReferenceType(List< string > list)      {        list = new List< string >(){ "hello" , "world" };      }    }

运行结果：my god

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

class Program    {      static void Main( string [] args)      {        List< string > temp = new List< string >(){ "my" , "god" };             ChangeReferenceType(temp);        temp.ForEach(t => Console.Write(t + " " ));        Console.ReadKey();      }        public static void ChangeReferenceType(List< string > list)      {        list.Clear();        list.Add( "hello" );        list.Add( "world" );      }    }

运行结果：hello world

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

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

值类型struct参数传递的是值

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

class Program    {      static void Main( string [] args)      {        Size s = new Size(){Length = 10, Width = 10};        ChangeStructType(s);        Console.Write( "Length={0},Width={1}" , s.Length,s.Width);        Console.ReadKey();      }        public static void ChangeStructType(Size size)      {        size.Length = 0;        size.Width = 0;      }    }      public struct Size    {      public int Length { get ; set ; }      public int Width { get ; set ; }    }

运行结果如下图所示：

为什么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类型的属性值呢？

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

class Program    {      static void Main( string [] args)      {        Room r = new Room()        {          TableSize = new Size(){Length = 100, Width = 80},          TvSize = new Size(){Length = 10, Width = 8}        };          r.TableSize.Length = 0;                Console.WriteLine( "table目前的尺寸是：length={0},width={1}" , r.TableSize.Length, r.TableSize.Width);        Console.ReadKey();      }    }      public struct Size    {      public int Length { get ; set ; }      public int Width { get ; set ; }    }      public struct Room    {      public Size TableSize { get ; set ; }      public Size TvSize { get ; set ; }    }

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

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

1	r.TableSize.Length = 0;

改成如下：

1	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类的属性值发生了改变。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

class Program    {      static void Main( string [] args)      {        var oneSize = new Size() {Length = 10, Width = 10};        var twoSize = oneSize;          oneSize.Changed += (s, e) => Console.Write( "Size发生了改变~~" );        oneSize.Length = 0;        Console.ReadKey();      }    }      public class Size    {      private int _length;      private int _width;        public event System.EventHandler Changed;        public int Length      {        get { return _length; }        set        {          _length = value;          OnChanged();        }      }        public int Width      {        get { return _width; }        set { _width = value; OnChanged(); }      }        private void OnChanged()      {        if (Changed != null )        {          Changed( this , new EventArgs());        }      }    }      public struct Room    {      public Size TableSize { get ; set ; }      public Size TvSize { get ; set ; }    }

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

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

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

class Program    {      static void Main( string [] args)      {        var size = new SizeStruct();        Console.WriteLine( "length={0},width={1}" , size.Length, size.Width);        Console.ReadKey();      }    }      public struct SizeStruct    {      public int Length { get ; set ; }      public int Width { get ; set ; }    }

运行结果如下图所示：

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

类不包含隐式无参构造函数

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

class Program    {      static void Main( string [] args)      {        var size = new SizeClass();        Console.WriteLine( "length={0},width={1}" , size.Length, size.Width);        Console.ReadKey();      }    }      public class SizeClass    {      public int Length { get ; set ; }      public int Width { get ; set ; }        public SizeClass( int length, int width)      {        Length = length;        Width = Width;      }    }

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

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

如果直接给字段赋初值。

1 2 3 4

public struct SizeStruct    {      public int _length = 10;    }

运行，报错：结构中不能有实例字段初始值设定项

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

1 2 3 4 5 6 7 8 9

public struct SizeStruct    {      public int _length;        public SizeStruct()      {        _length = 10;      }    }

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

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

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

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

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

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

本文详细分析了C#中struct和class的区别，对于C#初学者来说是有必要加以了解并掌握的。

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

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

● 类是引用类型，struct是值类型
● 在托管堆上创建类的实例，在栈上创建struct实例
● 类实例的赋值，赋的是引用地址，struct实例的赋值，赋的是值
● 类作为参数类型传递，传递的是引用地址，struct作为参数类型传递，传递的是值
● 类没有默认无参构造函数，struct有默认无参构造函数
● 类支持继承，struct不支持继承
● 类偏向于"面向对象",用于复杂、大型数据，struct偏向于"简单值"，比如小于16字节，结构简单
● 类的成员很容易赋初值，很难给struct类型成员赋初值
● 类的实例只能通过new SomeClass()来创建，struct类型的实例既可以通过new SomeStruct()来创建，也可以通过SomeStruct myStruct;来创建

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

class Program    {      static void Main( string [] args)      {        SizeClass sizeClass = new SizeClass(){Width = 10, Length = 10};        Console.WriteLine( "赋值前：width={0},length={1}" , sizeClass.Width, sizeClass.Length);          var copyOfSizeClass = sizeClass;        copyOfSizeClass.Length = 5;        copyOfSizeClass.Width = 5;        Console.WriteLine( "赋值后：width={0},length={1}" ,sizeClass.Width, sizeClass.Length);        Console.ReadKey();      }    }      public class SizeClass    {      public int Width { get ; set ; }      public int Length { get ; set ; }    }      public struct SizeStruct    {      public int Width { get ; set ; }      public int Length { get ; set ; }    }

运行结果如下图所示：

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class Program    {      static void Main( string [] args)      {        SizeStruct sizeStruct = new SizeStruct(){Length = 10, Width = 10};        Console.WriteLine( "赋值前：width={0},length={1}" , sizeStruct.Width, sizeStruct.Length);          var copyOfSizeStruct = sizeStruct;        copyOfSizeStruct.Length = 5;        copyOfSizeStruct.Width = 5;        Console.WriteLine( "赋值后：width={0},length={1}" , sizeStruct.Width, sizeStruct.Length);        Console.ReadKey();      }    }

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

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

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class Program    {      static void Main( string [] args)      {        List< string > temp = new List< string >(){ "my" , "god" };        temp.ForEach(t => Console.Write(t + " " ));        Console.ReadKey();      }        public static void ChangeReferenceType(List< string > list)      {        list = new List< string >(){ "hello" , "world" };      }    }

运行结果：my god

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

class Program    {      static void Main( string [] args)      {        List< string > temp = new List< string >(){ "my" , "god" };             ChangeReferenceType(temp);        temp.ForEach(t => Console.Write(t + " " ));        Console.ReadKey();      }        public static void ChangeReferenceType(List< string > list)      {        list.Clear();        list.Add( "hello" );        list.Add( "world" );      }    }

运行结果：hello world

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

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

值类型struct参数传递的是值

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

class Program    {      static void Main( string [] args)      {        Size s = new Size(){Length = 10, Width = 10};        ChangeStructType(s);        Console.Write( "Length={0},Width={1}" , s.Length,s.Width);        Console.ReadKey();      }        public static void ChangeStructType(Size size)      {        size.Length = 0;        size.Width = 0;      }    }      public struct Size    {      public int Length { get ; set ; }      public int Width { get ; set ; }    }

运行结果如下图所示：

为什么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类型的属性值呢？

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

class Program    {      static void Main( string [] args)      {        Room r = new Room()        {          TableSize = new Size(){Length = 100, Width = 80},          TvSize = new Size(){Length = 10, Width = 8}        };          r.TableSize.Length = 0;                Console.WriteLine( "table目前的尺寸是：length={0},width={1}" , r.TableSize.Length, r.TableSize.Width);        Console.ReadKey();      }    }      public struct Size    {      public int Length { get ; set ; }      public int Width { get ; set ; }    }      public struct Room    {      public Size TableSize { get ; set ; }      public Size TvSize { get ; set ; }    }

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

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

1	r.TableSize.Length = 0;

改成如下：

1	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类的属性值发生了改变。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

class Program    {      static void Main( string [] args)      {        var oneSize = new Size() {Length = 10, Width = 10};        var twoSize = oneSize;          oneSize.Changed += (s, e) => Console.Write( "Size发生了改变~~" );        oneSize.Length = 0;        Console.ReadKey();      }    }      public class Size    {      private int _length;      private int _width;        public event System.EventHandler Changed;        public int Length      {        get { return _length; }        set        {          _length = value;          OnChanged();        }      }        public int Width      {        get { return _width; }        set { _width = value; OnChanged(); }      }        private void OnChanged()      {        if (Changed != null )        {          Changed( this , new EventArgs());        }      }    }      public struct Room    {      public Size TableSize { get ; set ; }      public Size TvSize { get ; set ; }    }

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

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

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

class Program    {      static void Main( string [] args)      {        var size = new SizeStruct();        Console.WriteLine( "length={0},width={1}" , size.Length, size.Width);        Console.ReadKey();      }    }      public struct SizeStruct    {      public int Length { get ; set ; }      public int Width { get ; set ; }    }

运行结果如下图所示：

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

类不包含隐式无参构造函数

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

class Program    {      static void Main( string [] args)      {        var size = new SizeClass();        Console.WriteLine( "length={0},width={1}" , size.Length, size.Width);        Console.ReadKey();      }    }      public class SizeClass    {      public int Length { get ; set ; }      public int Width { get ; set ; }        public SizeClass( int length, int width)      {        Length = length;        Width = Width;      }    }

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

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

如果直接给字段赋初值。

1 2 3 4

public struct SizeStruct    {      public int _length = 10;    }

运行，报错：结构中不能有实例字段初始值设定项

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

1 2 3 4 5 6 7 8 9

public struct SizeStruct    {      public int _length;        public SizeStruct()      {        _length = 10;      }    }

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

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

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

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

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

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