第六阶段：值类型与引用类型 

QcrTiMo 发布于 9 天前 7 次阅读

内存中的两大区域：栈 (Stack) 与 堆 (Heap)

为了理解值类型和引用类型的区别，我们需要对程序运行时内存的两个主要区域有一个简单的概念（注意：这是简化模型，实际情况更复杂，但足以帮助理解）：

  • 栈 (Stack):
    • 想象成一叠盘子，后放上去的先拿出来 (LIFO - Last In, First Out)。
    • 用于存储值类型的实例，以及引用类型变量的引用本身 (地址)。
    • 内存管理非常高效，由系统自动分配和释放。当一个方法执行完毕，它在栈上使用的内存会自动“弹出”并清理。
    • 空间相对较小。
  • 堆 (Heap):
    • 想象成一个巨大的、没有固定顺序的仓库。
    • 用于存储引用类型的实际对象实例。
    • 内存分配和释放相对复杂（需要找到合适的空闲空间）。
    • 由 .NET 的垃圾回收器 (Garbage Collector, GC) 负责自动管理。GC 会定期检查堆上的对象，找出哪些不再被任何变量引用，然后回收它们占用的内存。这个过程比栈的管理开销大。
    • 空间相对较大。

值类型 (Value Types)

  • 定义: 值类型的变量直接包含其数据值。
  • 存储: 变量及其数据通常都存储在栈 (Stack) 上。（例外：如果值类型是某个引用类型对象的一部分，比如类的字段，那么它会存储在堆上那个对象内部）。
  • 常见的值类型:
    • 基本数值类型: int, double, float, decimal, long, short, byte, sbyte, uint, ulong, ushort
    • 布尔类型: bool
    • 字符类型: char
    • 结构体 (Struct): 包括系统定义的结构体如 DateTime, TimeSpan, 以及用户自定义的 struct。
    • 枚举 (Enum): 我们刚学过的枚举类型。

值类型的特点 (以 int 为例)：

nt a = 10;
int b = a; // 赋值操作
// 内存示意 (简化):
// 栈 (Stack):
// +-------+-------+
// | b: 10 |       | <-- 将 a 的值 10 复制一份给 b
// +-------+-------+
// | a: 10 |       | <-- a 直接存储值 10
// +-------+-------+
  • 赋值 = 复制值: 当你将一个值类型变量赋给另一个值类型变量时 (b = a;)，系统会完整地复制变量所包含的值。此时 a 和 b 是两个完全独立的副本，它们在栈上占用各自的内存空间。
  • 修改互不影响: 修改其中一个变量的值，不会影响另一个变量。
Console.WriteLine($"初始时: a = {a}, b = {b}"); // 输出: 初始时: a = 10, b = 10
b = 20; // 修改 b 的值
Console.WriteLine($"修改 b 后: a = {a}, b = {b}"); // 输出: 修改 b 后: a = 10, b = 20 (a 没有改变)

引用类型 (Reference Types)

  • 定义: 引用类型的变量存储的不是实际数据，而是存储实际数据所在的内存地址的引用 (Reference)。可以把它想象成存储着仓库里货物存放位置的“地址牌”。
  • 存储:
    • 实际的对象实例存储在堆 (Heap) 上。
    • 变量本身 (存储引用的地址牌) 存储在栈 (Stack) 上 (或者如果它是类的成员，也可能在堆上)。
  • 常见的引用类型:
    • 类 (Class): 包括系统定义的类如 string, object, Array, List<T>, 以及所有用户自定义的 class。
    • 数组 (Array): 所有类型的数组，如 int[], string[], Student[]。
    • 接口 (Interface)
    • 委托 (Delegate)
    • dynamic
    • object (所有类型的基类)
    • string: (字符串是特殊的引用类型，它表现出一些“不可变”的特性，但本质上还是引用类型)。

引用类型的特点 (以数组 int[] 为例)：

int[] arr1 = new int[] { 1, 2, 3 }; // new 在堆上创建数组对象
int[] arr2 = arr1; // 赋值操作
// 内存示意 (简化):
// 栈 (Stack):                 堆 (Heap):
// +----------+           +-------------------+
// | arr2: ref|---------->| int[] { 1, 2, 3 } | &lt;-- 实际数组对象
// +----------+           +-------------------+
// | arr1: ref|-----+
// +----------+     |
//                  +-------> (指向同一个堆地址)
  • 赋值 = 复制引用 (地址): 当你将一个引用类型变量赋给另一个引用类型变量时 (arr2 = arr1;)，系统只复制存储在变量中的引用 (内存地址)。此时 arr1 和 arr2 这两个“地址牌”虽然是独立的（在栈上），但它们都指向堆上的同一个对象实例。
  • 修改互相影响: 因为 arr1 和 arr2 指向同一个对象，所以通过任何一个变量去修改堆上对象的内容，都会影响到通过另一个变量访问该对象的结果。
Console.WriteLine($"初始时 arr1[0]: {arr1[0]}"); // 输出: 1
Console.WriteLine($"初始时 arr2[0]: {arr2[0]}"); // 输出: 1
// 通过 arr2 修改堆上数组的内容
arr2[0] = 99;
Console.WriteLine("修改 arr2[0] 为 99 后:");
Console.WriteLine($"arr1[0]: {arr1[0]}"); // 输出: 99 (arr1 也受影响了!)
Console.WriteLine($"arr2[0]: {arr2[0]}"); // 输出: 99

string 的特殊性:

字符串 (string) 是引用类型，但 C# 对它做了一些特殊处理，让它表现得有点像值类型（称为不可变性 Immutability）。当你试图“修改”一个字符串时，实际上是创建了一个新的字符串对象，原来的字符串对象并没有改变。

string s1 = "hello";
string s2 = s1;
Console.WriteLine($"s1: {s1}, s2: {s2}"); // s1: hello, s2: hello
Console.WriteLine(object.ReferenceEquals(s1, s2)); // True (指向同一个 "hello")
s2 = "world"; // 这并没有修改堆上 "hello" 对象，而是让 s2 指向了一个新的 "world" 对象
Console.WriteLine($"修改 s2 后: s1: {s1}, s2: {s2}"); // s1: hello, s2: world (s1 不受影响)
Console.WriteLine(object.ReferenceEquals(s1, s2)); // False (指向不同对象了)
string s3 = "hello"; // C# 字符串驻留机制可能让 s3 指向与 s1 最初相同的 "hello"
Console.WriteLine(object.ReferenceEquals(s1, s3)); // 通常为 True

方法参数传递

理解了值类型和引用类型后，我们就能更好地理解方法参数传递：

  • 传递值类型参数: 当你将一个值类型变量传递给方法时，方法接收到的是该变量值的副本。在方法内部对这个参数的任何修改，都不会影响到方法外部的原始变量。
static void ModifyValue(int valueParam)
{
    valueParam = 100; // 修改的是副本
    Console.WriteLine($"方法内部: valueParam = {valueParam}"); // 输出 100
}
static void Main(string[] args)
{
    int originalValue = 5;
    Console.WriteLine($"调用前: originalValue = {originalValue}"); // 输出 5
    ModifyValue(originalValue);
    Console.WriteLine($"调用后: originalValue = {originalValue}"); // 输出 5 (原始值未改变)
}

传递引用类型参数: 当你将一个引用类型变量传递给方法时，方法接收到的是该变量引用的副本 (地址的副本)。这意味着方法内部的参数和方法外部的原始变量指向堆上的同一个对象。因此，如果在方法内部通过这个引用修改了堆上对象的内容，那么方法外部的原始变量也能观察到这个变化。

static void ModifyReference(int[] arrayParam)
{
    if (arrayParam != null &amp;&amp; arrayParam.Length > 0)
    {
        arrayParam[0] = 100; // 通过引用副本修改了堆上对象的内容
        Console.WriteLine($"方法内部: arrayParam[0] = {arrayParam[0]}"); // 输出 100
    }
    // 如果在方法内部让参数指向一个新对象，不会影响外部变量
    // arrayParam = new int[] { 4, 5, 6 }; // 这只改变了方法内部的参数引用，不影响外部
}
static void Main(string[] args)
{
    int[] originalArray = { 1, 2, 3 };
    Console.WriteLine($"调用前: originalArray[0] = {originalArray[0]}"); // 输出 1
    ModifyReference(originalArray);
    Console.WriteLine($"调用后: originalArray[0] = {originalArray[0]}"); // 输出 100 (原始数组的内容被改变了!)
}
特性值类型 (Value Types)引用类型 (Reference Types)
存储内容直接包含数据值存储数据的内存地址 (引用)
存储位置通常在栈 (Stack)引用在栈，实际对象在堆 (Heap)
赋值操作复制值，创建独立副本复制引用，指向同一对象
修改影响修改一个副本不影响其他副本通过一个引用修改对象会影响其他引用
参数传递传递值的副本传递引用的副本 (指向同一对象)
内存管理栈自动管理，高效堆由垃圾回收器(GC)管理，有开销
null 值不能为 null (除非是可空类型 int?)可以为 null (表示不引用任何对象)
常见例子int, double, bool, char, struct, enumstring, object, Array, List, class

思考一下：

  • 为什么 string 虽然是引用类型，但在很多操作中表现得像值类型？（提示：不可变性）
  • 如果你有一个 Student 类（引用类型）的对象 studentA，然后执行 Student studentB = studentA;，再执行 studentB.Age = 20;，那么 studentA.Age 会是多少？为什么？
  • 如果你有一个方法 void ResetScore(int score)，在方法内部将 score 设置为 0，这会影响调用该方法时传入的 int 变量吗？
  • 如果你有一个方法 void ClearList(List<string> names)，在方法内部调用 names.Clear();，这会影响调用该方法时传入的 List<string> 变量吗？
斯哈斯哈斯哈，佳代子啊啊啊啊啊啊ᕕ(◠ڼ◠)ᕗᕕ(◠ڼ◠)ᕗᕕ(◠ڼ◠)ᕗᕕ(◠ڼ◠)ᕗᕕ(◠ڼ◠)ᕗ
最后更新于 2025-05-19