C#中struct和class的区别详解

C#中struct和class的区别详解

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

struct是值类型,创建一个struct类型的实例被分配在栈上。
class是引用类型,创建一个class类型实例被分配在托管堆上。

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

 

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

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

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类型赋值,是完全拷贝,在栈上多了一个完全一样的变量

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的不同

 

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

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指向托管堆上的一个集合实例List<string>
→当temp放到ChangeReferenceType(temp)方法中,本质是把temp指向的地址赋值给了变量list
→在ChangeReferenceType(List<string> list)方法内部,又把变量list的指向了另外一个集合实例地址
→但temp的指向地址一直没有改变

 

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

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参数传递的是值

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是完全一样的
(我自己以为是老的size传进去,对老的Size进行更改(这个是引用类型的想法);没想到是在栈创建了一个变量size,)
→在ChangeStructType(Size size)内部改变size的值,与变量s毫无关系

 

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

如果直接给字段赋初值。
public struct SizeStruct
  {
    public int _length = 10;
  }
运行,报错:结构中不能有实例字段初始值设定项(这个是真的)

如果通过构造函数给字段赋初值。
public struct SizeStruct
  {
    public int _length; 
    public SizeStruct()
    {
      _length = 10;
    }
  }
运行,报错:结构中不能包含显式无参数构造函数
可见,给struct类型成员赋初值是不太容易的,而给class成员赋初值,no problem。

但是在项目中:加个const就可以赋值了,这个const那么叼的嘛????

public struct Label
    {
        public const string aa = "aaa";
        public const string bb= "bbb";       
    }
用的时候:
case Label.aa: {
Method1(Label.bb);
}

 

何时使用struct,何时使用class?
在多数情况下,推荐使用class类,因为无论是类的赋值、作为参数类型传递,还是返回类的实例,实际拷贝的是托管堆上引用地址,也就大概4个字节,这非常有助于性能的提升。
而作为struct类型,无论是赋值,作为参数类型传递,还是返回struct类型实例,是完全拷贝,会占用栈上的空间。
根据Microsoft's Value Type Recommendations,在如下情况下,推荐使用struct:
● 小于16个字节
● 偏向于值,是简单数据,而不是偏向于"面向对象"
希望值不可变

 

posted @ 2020-11-25 11:27  ProZkb  阅读(509)  评论(0编辑  收藏  举报