c#中struct和class的区别

2018-06-22 06:32:51来源：未知阅读 ()

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

■ 概括来讲
■ 从赋值的角度体验struct和class的不同
■ 从参数传值角度体验struct和class的不同
■ 从struct类型的struct类型属性和struct引用类型属性体验struct和class的不同
■ 从构造函数体验struct和class的不同
■ 从给类型成员赋初值体验struct和class的不同
■ 何时使用struct，何时使用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指向托管堆上的一个集合实例
→当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是完全一样的
→在ChangeStructType(Size size)内部改变size的值，与变量s毫无关系

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

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

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

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，只需把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类的属性值发生了改变。

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类型包含隐式的默认无参构造函数

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。

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

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

如果直接给字段赋初值。

public struct SizeStruct
    {
        public int _length = 10;
    }

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

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

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# Fundamentals: The Differences Between Struct and Class
Difference between class and struct in C# .Net
Difference Between Class and Structure

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：学C#你应该熟练使用ILDasm和Reflector【带视频教程】

下一篇：优化字符串拼接之二:非托管内存应用

IDC资讯：主机资讯注册资讯托管资讯 vps资讯网站建设

网站运营：建站经验策划盈利搜索优化网站推广免费资源

网站联盟：联盟新闻联盟介绍联盟点评网赚技巧

行业资讯：搜索引擎网络游戏电子商务广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器安全防护

软件技巧：其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识：网络协议网络安全网络管理组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条

最新资讯

热门关注

热门标签