什么是值类型，什么是引用类型

Dear 丶 2023-01-20 10:59 65阅读 0赞

概念：值类型直接存储其值，而引用类型存储对其值的引用。部署：托管堆上部署了所有引用类型。

引用类型：基类为Objcet

值类型：均隐式派生自System.ValueType：

<table> 
 <tbody> 
  <tr> 
   <td style="vertical-align:top;"> <p>值类型：</p> </td> 
   <td style="vertical-align:top;"> <p>byte，short，int，long，float，double，decimal，char，bool 和 struct 统称为值类型。</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;"> <p>引用类型：</p> </td> 
   <td style="vertical-align:top;"> <p>string 和 class统称为引用类型。</p> </td> 
  </tr> 
 </tbody> 
</table>

*  值类型变量声明后，不管是否已经赋值，编译器为其分配内存。
 *  引用类型当声明一个类时，只在栈中分配一小片内存用于容纳一个地址，而此时并没有为其分配堆上的内存空间。当使用 new 创建一个类的实例时，分配堆上的空间，并把堆上空间的地址保存到栈上分配的小片空间中。
 *  值类型的实例通常是在线程栈上分配的（静态分配），但是在某些情形下可以存储在堆中。
 *  引用类型的对象总是在进程堆中分配（动态分配）。

我们来看下面一段代码：

![6ab5b8b10eead8598b26c83c62d4a9fc.png][]

输出结果：

![29d944998a805740be726191f0f4c149.png][]

![430977759a65ac1cf736325a8ee0fa7a.png][]

值类型在栈内分配空间大小因变量类型而异；

引用类型在栈内的空间大小相同；

**1. ****通用类型系统**

C\#中，变量是值还是引用仅取决于其数据类型。

C\#的基本数据类型都以平台无关的方式来定义。C\#的预定义类型并没有内置于语言中，而是内置于.NET Framework中。.NET使用通用类型系统（CTS）定义了可以在中间语言（IL）中使用的预定义数据类型，所有面向.NET的语言都最终被编译为IL，即编译为基于CTS类型的代码。

例如，在C\#中声明一个int变量时，声明的实际上是CTS中System.Int32的一个实例。这具有重要的意义：

*  确保IL上的强制类型安全；
 *  实现了不同.NET语言的互操作性；
 *  所有的数据类型都是对象。它们可以有方法，属性，等。例如：

**int i;**

**i = 1;**

**string s;**

**s = i.ToString();**

以下关系图（[来自MSDN][MSDN]）说明了这几种类型是如何相关的。注意，类型的实例可以只是值类型或自描述类型，即使这些类型有子类别也是如此。

类型类别：

![9bd033377f334d1efa7ae492dde30dfd.png][]

**2.****值类型**

C\#的所有值类型均隐式派生自System.ValueType：

结构体：struct（直接派生于System.ValueType）；

数值类型：

**整型**：sbyte（System.SByte的别名），short（System.Int16），int（System.Int32），long（System.Int64），byte（System.Byte），ushort（System.UInt16），uint（System.UInt32），ulong（System.UInt64），char（System.Char）；

**浮点型**：float（System.Single），double（System.Double）；

用于财务计算的高精度decimal型：decimal（System.Decimal）。

**bool****型**：bool（System.Boolean的别名）；

用户定义的结构体（派生于System.ValueType）。

**枚举**：enum（派生于System.Enum）；

可空类型（派生于System.Nullable<T>泛型结构体，T?实际上是System.Nullable<T>的别名）。

每种值类型均有一个隐式的默认构造函数来初始化该类型的默认值。例如：

**int i = new int();**

等价于：

**Int32 i = new Int32();**

等价于：

**int i = 0;**

等价于：

**Int32 i = 0;**

引用类型和值类型都继承自System.Object类。不同的是，几乎所有的引用类型都直接从System.Object继承，而值类型则继承其子类，即 直接继承System.ValueType。System.ValueType直接派生于System.Object。即System.ValueType本身是一个类类型，而不是值类型。其关键在于ValueType重写了Equals()方法，从而对值类型按照实例的值来比较，而不是引用地址来比较。

可以用Type.IsValueType属性来判断一个类型是否为值类型：

**TestType testType = new TestType ();**

**if (testTypetype.GetType().IsValueType)**

**\{**

**     Console.WriteLine("\{0\} is value type.", testType.ToString());**

**\}**

**3.****引用类型**

C\#有以下一些引用类型：

数组（派生于System.Array）

用户用定义的以下类型：

类：class（派生于System.Object）；

接口：interface（接口不是一个“东西”，所以不存在派生于何处的问题。Anders在《C\# Programming Language》中说，接口只是表示一种约定\[contract\]）；

委托：delegate（派生于System.Delegate）。

object（System.Object的别名）；

字符串：string（System.String的别名）。

可以看出：

引用类型与值类型相同的是，结构体也可以实现接口；

引用类型可以派生出新的类型，而值类型不能；

引用类型可以包含null值，值类型不能（可空类型功能允许将 null 赋给值类型）；

引用类型变量的赋值只复制对对象的引用，而不复制对象本身。而将一个值类型变量赋给另一个值类型变量时，将复制包含的值。

对于最后一条，经常混淆的是string。我曾经在一本书的一个早期版本上看到String变量比string变量效率高；我还经常听说String是引用类型，string是值类型，等等。例如：

string s1 = "Hello, ";

string s2 = "world!";

string s3 = s1 + s2;//s3 is "Hello, world!"

这确实看起来像一个值类型的赋值。再如：

string s1 = "a";

string s2 = s1;

s1 = "b";//s2 is still "a"

改变s1的值对s2没有影响。这更使string看起来像值类型。实际上，这是运算符重载的结果，当s1被改变时，.NET在托管堆上为s1重新分配了内存。这样的目的，是为了将做为引用类型的string实现为通常语义下的字符串。

**4. ****值类型和引用类型在内存中的部署**

经常听说，并且经常在书上看到：值类型部署在栈上，引用类型部署在托管堆上。实际上并没有这么简单。

MSDN上说：托管堆上部署了所有引用类型。这很容易理解。当创建一个应用类型变量时：

object reference = new object();

关键字new将在托管堆上分配内存空间，并返回一个该内存空间的地址。左边的reference位于栈上，是一个引用，存储着一个内存地址；而这个地址指向的内存（位于托管堆）里存储着其内容（一个System.Object的实例）。下面为了方便，简称引用类型部署在托管推上。

再来看值类型。《C\#语言规范》上的措辞是“结构体不要求在堆上分配内存（However, unlike classes, structs are value types and do not require heap allocation）”而不是“结构体在栈上分配内存”。这不免容易让人感到困惑：值类型究竟部署在什么地方？

**4.1****数组**

考虑数组：

**int\[\] reference = new int\[100\];**

根据定义，数组都是引用类型，所以int数组当然是引用类型（即**reference.GetType().IsValueType**为false）。

而int数组的元素都是int，根据定义，int是值类型（即**reference\[i\].GetType().IsValueType**为true）。那么引用类型数组中的值类型元素究竟位于栈还是堆？

如果用WinDbg去看[reference\[i\]在内存中的具体位置][reference_i]，就会发现它们并不在栈上，而是在托管堆上。

实际上，对于数组：

**TestType\[\] testTypes = new TestType\[100\];**

如果TestType是值类型，则会一次在托管堆上为100个值类型的元素分配存储空间，并自动初始化这100个元素，将这100个元素存储到这块内存里。

如果TestType是引用类型，则会先在托管堆为testTypes分配一次空间，并且这时不会自动初始化任何元素（即testTypes\[i\]均为null）。等到以后有代码初始化某个元素的时候，这个引用类型元素的存储空间才会被分配在托管堆上。

**4.2****类型嵌套**

![4f92e73e3fdbaf4d03e1ef317ea0cb12.png][]

引用类型部署在托管堆上；

值类型总是分配在它声明的地方：作为字段时，跟随其所属的变量（实例）存储；作为局部变量时，存储在栈上。

从上下文看，**mc**是一个局部变量，所以部署在托管堆上，并被栈上的一个引用所持有；

值类型字段\_**value1**属于引用类型实例**mc**的一部分，所以跟随引用类型实例**mc**部署在托管堆上（有点类似于数组的情形）；

**value2**是值类型局部变量，所以部署在栈上。

而对于值类型实例，即**MyStruct**：

根据上下文，值类型实例**ms**本身是一个局部变量而不是字段，所以位于栈上；

其引用类型字段\_**object1**不存在跟随的问题，必然部署在托管堆上，并被一个引用所持有（该引用是**ms**的一部分，位于栈）；

其引用类型局部变量**\_object2**显然部署在托管堆上，并被一个位于栈的引用所持有。

所以，简单地说“值类型存储在栈上，引用类型存储在托管堆上”是不对的。必须具体情况具体分析

**在****C\#****中，我们用****struct/class****来声明一个类型为值类型****/****引用类型。考虑下面的例子：**

SomeType\[\] oneTypes = new SomeType\[100\];

如 果SomeType是值类型，则只需要一次分配，大小为SomeType的100倍。而如果SomeType是引用类型，刚开始需要100次分配，分配后 数组的各元素值为null，然后再初始化100个元素，结果总共需要进行101次分配。这将消耗更多的时间，造成更多的内存碎片。所以，如果类型的职责主 要是存储数据，值类型比较合适。

一般来说，值类型（不支持多态）适合存储供 C\#应用程序操作的数据，而引用类型（支持多态）应该用于定义应用程序的行为。通常我们创建的引用类型总是多于值类型。如果满足下面情况，那么我们就应该创建为值类型：

该类型的主要职责用于数据存储。

该类型的共有接口完全由一些数据成员存取属性定义。

该类型永远不可能有子类。

该类型不具有多态行为。

**5. ****辨明值类型和引用类型的使用场合**

在C\#中，我们用struct/class来声明一个类型为值类型/引用类型。考虑下面的例子：

SomeType\[\] oneTypes = new SomeType\[100\];

该类型的主要职责用于数据存储。

该类型的共有接口完全由一些数据成员存取属性定义。

该类型永远不可能有子类。

该类型不具有多态行为。

**值类型和引用类型的区别（小结）**

相同点：

引用类型可以实现接口，值类型当中的结构体也可以实现接口；

引用类型和值类型都继承自System.Object类。

1）范围方面

C\#的值类型包括：结构体（数值类型、bool型、用户定义的结构体），枚举，可空类型。

C\#的引用类型包括：数组，用户定义的类、接口、委托，object，字符串。

2）内存分配方面：

数组的元素不管是引用类型还是值类型，都存储在托管堆上。

引用类型在栈中存储一个引用，其实际的存储位置位于托管堆。简称引用类型部署在托管推上。而值类型总是分配在它声明的地方：作为字段时，跟随其所属的变量（实 例）存储；作为局部变量时，存储在栈上。（栈的内存是自动释放的，堆内存是.NET中会由GC来自动释放）

3）适用场合

值类型在内存管理方面具有更好的效率，并且不支持多态，适合用做存储数据的载体；引用类型支持多态，适合用于定义应用程序的行为。

引用类型可以派生出新的类型，而值类型不能，因为所有的值类型都是密封（seal）的；

引用类型可以包含null值，值类型不能（可空类型功能允许将 null 赋给值类型，如   int? a = null;  ）；

引用类型变量的赋值只复制对对象的引用，而不复制对象本身。而将一个值类型变量赋给另一个值类型变量时，将复制包含的值。

值得注意的是，引用类型和值类型都继承自System.Object类。不同的是，几乎所有的引用类型都直接从System.Object继承，而值类型则继承其子类，即 直接继承System.ValueType。即System.ValueType本身是一个类类型，而不是值类型。其关键在于ValueType重写了Equals()方法，从而对值类型按照实例的值来比较，而不是引用地址来比较。

【前言】  
     对于值类型和引用类型的学习现在不满足于只是停留基本的了解层面，慢慢深入到根据内存分析值类型和引用类型的使用及区别。

【正文】  
   值类型、引用类型、堆、栈的概念  
      值类型：表示复制一个当前变量传给方法，当你在这个方法中改变这个变量的值时，最初生命的变量的值不会变。

引用类型：表示你操作的数据是同一个，也就是说当你传一个参数给另一个方法时，你在另一个方法中改变这个变量的值，那么调用这个方法时传入的变量的值也将改变。

栈（stack) 和 堆（heap） ：在.NET中有两种类型的内存：栈内存和堆内存。当我们声明在函数中一个局部变量时int a ，系统会自动在栈中为b开辟空间。栈区由编译器自动分配释放，存放函数的参数值，局部变量等值。其操作方式类似于数据结构中的栈。

当我们创建一个对象int i =4 时，该行执行时，编译器在栈上创建了一个指针，真实的对象存储在另一个叫”堆”的内存中。堆需要程序员自己申请，并指明大小，并由程序员进行释放。

值类型和引用类型的种类

从代码中体会值类型和引用类型  
      上面的概念介绍是不是很抽象，别着急，都说实践出真知，咱们马上在例子中体会一下。

首先在类中声明一个class类和一个struct结构，如下：

namespace ObjectAndValueType  
\{  
    //定义一个类，类名为SomeClass  
    public class SomeClass  
    \{  
        //定义一个整数  
        public int NumberA;  
    \}  
\}      
      
                                     
                
   
namespace ObjectAndValueType  
\{  
     //定义一个结构，结构名为SomeValue  
     public struct SomeValue  
     \{  
         //定义一个整数  
         public int NumberA;  
           
     \}  
\}  
    
       并在程序的入口调用它们，如下

namespace ObjectAndValueType  
\{  
      class program  
      \{  
           static void Main(string\[\] args)  
           \{  
                //第一步：使用SomeClass类，创建一个名为s1的对象，并为对象中的变量赋值  
                SomeClass s1 = new SomeClass();  
                s1.NumberA = 12;  
                  
                  
                //第二步：使用SomeValue结构，创建一个名为r1的对象，并为对象中的变量赋值  
                SomeValue r1 = new SomeValue();  
                r1.NumberA = 16;  
            \}  
       \}  
\}         
         
         
         
           
       现在我们来看一下，他们在内容中的存储情况：

从上述图可以看出，class(类)实例化出来的对象，指向了内存堆中分配的空间；struct(结构)实例化出来的对象，是在内存栈中分配空间

接下来，我们再来在上面的程序中做些修改：

class program  
\{  
    static void Main(string\[\] args)  
    \{  
         //第一步：使用SomeClass类，创建一个名为s1的对象，并为对象中的变量赋值  
         SomeClass s1 = new SomeClass();  
         s1.NumberA = 12;  
           
        //定义一个class(类)对象为S2，把S1中的对象赋值给s1  
        SomeClass s2 = s1;  
        s2.NumberA = 222;  
          
        console.WriteLine("s1的值为：\{0\} \\t  s2的值为：\{1\}",s1.NumberA,s2.NumerA);  
          
         
        //第二步：使用SomeValue结构，创建一个名为r1的对象，并为对象中的变量赋值  
        SomeValue r2 = new SomeValue();  
        r1.NumberA = 16；  
        //定义一个struct(结构)对象为r1，把r1中的对象赋值给r2  
        SomeValue r2 = r1;  
        r2.NumberA = 666;  
          
        console.WriteLine("r1的值为;\{0\} \\t r2的值为：\{1\}"，r1.NumberA,r2.NumberA);  
        console.ReadLine();  
    \}  
\}  
                
       内存图：  
                 
                
      大家可以猜一下结果：？  
               
      恭喜你，答对了，正确答案是：s1的值为：222  s2的值为：222  
                                  r1的值为：16   r2的值为：666  
                  
     分析一下： 在执行r2 = r1语句时，变量r1中内容被复制了一份，然后放到了变量r2中，此时变量r1的值为16 ，r2的值为666, r1和r2的值不不干扰，完全独立，所以对于值类型，每个变量都有自己的值，因此对一个变量的操作不会影响到其他变量。  
                在执行s2=s1语句时，变量s1中内容也被复制了一份，然后放到了变量s2中，但是因为变量s1中存放的是一个类型实例（对象）的引用，因此这次赋值操作等同于把这个引用传递给了变量s2，结果就是变量s1和s2中的引用指向堆中同一个类型的实例(对象)。所以对于引用类型的变量，对一个变量的数据进行操作就是对这个变量在堆中的数据进行操作，如果两个引用类型的变量引用同一个对象，实际含义就是它们在对战中保存的对的堆的地址相同，因此对一个变量的操作就会影响到引用同一个对象的变量。  
     
    值类型和引用类型的区别

【小结】      
           上述内容通过代码深入内存，对值类型和引用类型进行对比分析，对于值类型和引用类型一句话总结网上有一句流传语：值类型就是现金，要用直接用；引用类型是存着，要用还要先去银行取现。大家肯定会有疑问：值类型和引用类型在什么时候用哪个比较好呢？当然答案不能太过于绝对，有的时候需要进行值类型到引用类型的转化，就是神奇的“装箱”，更多了解请持续关注后续博客，如有不足请提出您的宝贵意见~~

内容参考来自文章：

[值类型和引用类型，栈和堆的含义][Link 1]

[通用类型系统概述][MSDN]

[C\#详解值类型和引用类型区别][C]

[https://www.cnblogs.com/bakuhert/articles/5878086.html][https_www.cnblogs.com_bakuhert_articles_5878086.html]

https://blog.csdn.net/zt15732625878/article/details/54985339

[6ab5b8b10eead8598b26c83c62d4a9fc.png]: /images/20221021/b099b0a87a4e41878b991bbf9fe928bd.png
[29d944998a805740be726191f0f4c149.png]: /images/20221021/41c1ac58704746ba8ba9599ec050144d.png
[430977759a65ac1cf736325a8ee0fa7a.png]: /images/20221021/9c593efb92304adea3d2f5410a903887.png
[MSDN]: https://msdn.microsoft.com/zh-cn/library/2hf02550%28VS.80%29.aspx
[9bd033377f334d1efa7ae492dde30dfd.png]: /images/20221021/899feb3a8453401e93c29689722bdc4c.png
[reference_i]: http://eparg.spaces.live.com/blog/cns!59BFC22C0E7E1A76!2603.entry
[4f92e73e3fdbaf4d03e1ef317ea0cb12.png]: /images/20221021/afb57722cab1464897d4b6472565652e.png
[Link 1]: http://www.cnblogs.com/tonney/archive/2011/04/28/2032205.html
[C]: http://blog.csdn.net/qiaoquan3/article/details/51202926
[https_www.cnblogs.com_bakuhert_articles_5878086.html]: https://www.cnblogs.com/bakuhert/articles/5878086.html