返回专栏
· 13 分钟阅读

值类型与引用类型(Value Types & Reference Types)


一、什么是值类型与引用类型?

值类型(Value Type)和引用类型(Reference Type)是编程语言中描述数据行为的两种常见分类方式。

它们最核心的区别在于:变量在赋值和传递时,究竟复制的是数据本身,还是指向数据的引用。

1. 值类型(Value Type)

值类型的变量直接承载一个值。将一个值类型变量赋给另一个变量时,通常会复制该值。

两个变量拥有各自独立的值,修改其中一个变量,不会直接改变另一个变量。

例如:

a := 10
b := a

b = 20

fmt.Println(a) // 10
fmt.Println(b) // 20

赋值过程可以抽象为:

flowchart TD
    A["变量 a<br/>值为 10"] --> B["复制值"]
    B --> C["变量 b<br/>值为 10"]
    C --> D["修改 b 为 20"]

    A1["a 仍然为 10"]
    D --> A1

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style A1 fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

需要注意,值类型不一定意味着数据必须存储在栈上,也不意味着每次赋值都一定发生物理内存复制。

值类型描述的是语言层面的值语义,而不是具体的内存布局。

2. 引用类型(Reference Type)

引用类型的变量通常持有一个对象的引用。将一个引用类型变量赋给另一个变量时,通常复制的是引用,而不是对象本身。

因此,两个变量可能指向同一个对象。

例如:

class User {
    String name;
}

User a = new User();
a.name = "Alice";

User b = a;
b.name = "Bob";

System.out.println(a.name); // Bob
System.out.println(b.name); // Bob

赋值过程可以抽象为:

flowchart TD
    A["变量 a"] --> C["同一个对象"]
    B["变量 b"] --> C
    C --> D["修改对象属性"]
    D --> E["通过 a 访问:Bob"]
    D --> F["通过 b 访问:Bob"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

这里的关键不是两个变量共享了变量本身,而是两个变量持有的引用指向同一个对象。

二、值类型与引用类型的核心区别

对比维度 值类型 引用类型
赋值语义 通常复制值 通常复制引用
数据关系 通常形成独立副本 可能共享同一对象
修改影响 修改副本通常不影响原变量 修改共享对象可能影响其他引用
对象身份 通常关注值是否相等 通常还需要关注是否为同一对象
内存管理 取决于语言和实现 通常涉及对象生命周期管理
常见用途 数值、布尔值、结构化值 对象、集合、动态数据结构

这些区别是典型行为的概括,并非所有语言都严格采用同一套分类规则。

尤其需要注意:

  • 值类型也可能包含引用字段。
  • 引用类型也可以是不可变的。
  • 值类型不等于栈分配。
  • 引用类型不等于堆分配。
  • 引用类型的赋值不等于深拷贝。

三、赋值:复制值还是复制引用?

赋值是理解两种类型最重要的切入点。

1. 值类型赋值

假设变量 A 保存一个值,将 A 赋给 B:

A = 100
B = A

赋值完成后,A 和 B 分别拥有值为 100 的数据。

flowchart TD
    A["变量 A<br/>100"] --> C["赋值操作"]
    C --> B["变量 B<br/>100"]
    B --> D["修改 B = 200"]
    D --> E["A = 100"]
    D --> F["B = 200"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

2. 引用类型赋值

假设变量 A 引用一个对象,将 A 赋给 B:

A ──引用──> Object
B = A

赋值之后,A 和 B 持有指向同一对象的引用。

flowchart TD
    A["变量 A"] --> C["Object"]
    B["变量 B"] --> C
    C --> D["对象属性:name = Alice"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

此时有两种不同的操作,需要严格区分。

修改对象内容:

b.name = "Bob";

由于 A 和 B 指向同一个对象,通过 A 访问时也会看到修改结果。

修改变量本身的引用:

b = new User();

这会让 B 指向另一个对象,但不会改变 A 原来的引用。

flowchart TD
    A["变量 A"] --> C["原对象"]
    B["变量 B"] --> D["新对象"]
    C --> E["原对象继续存在"]
    D --> F["B 指向新对象"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

四、浅拷贝与深拷贝

值类型和引用类型的区别,在复合对象复制时会变得更加复杂。

1. 浅拷贝(Shallow Copy)

浅拷贝会创建一个新的顶层对象,并复制其字段值。

如果字段本身是引用,那么复制的通常仍然是引用,原对象和新对象可能共享内部对象。

例如:

class Address {
    String city;
}

class User {
    String name;
    Address address;
}

执行浅拷贝后:

User user1 = new User();
user1.name = "Alice";

user1.address = new Address();
user1.address.city = "Singapore";

User user2 = new User();
user2.name = user1.name;
user2.address = user1.address;

此时:

  • user1 和 user2 是两个不同的 User 对象。
  • 两个对象的 name 字段是独立的字符串引用。
  • 两个对象的 address 字段指向同一个 Address 对象。
flowchart TD
    A["user1"] --> B["User 对象 1"]
    C["user2"] --> D["User 对象 2"]
    B --> E["Address 对象"]
    D --> E

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

修改 user2 的 address.city,user1 的 address.city 也会发生变化。

但修改 user2.name,不会改变 user1.name 的引用。

2. 深拷贝(Deep Copy)

深拷贝不仅创建新的顶层对象,还会递归复制需要独立拥有的内部对象。

user1
  └── Address 对象 1

user2
  └── Address 对象 2

两个对象及其内部结构不再共享需要复制的可变对象。

flowchart TD
    A["user1"] --> B["User 对象 1"]
    C["user2"] --> D["User 对象 2"]
    B --> E["Address 对象 1"]
    D --> F["Address 对象 2"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

深拷贝并不意味着必须复制所有关联对象。对于不可变对象、共享资源、循环引用或需要保留对象身份的结构,通常需要定义明确的复制策略。

3. 浅拷贝与深拷贝对比

对比维度 浅拷贝 深拷贝
顶层对象 创建新对象 创建新对象
基本字段 复制字段值 复制字段值
引用字段 通常复制引用 按策略复制内部对象
内部可变对象 可能共享 通常独立
性能成本 通常较低 通常较高
实现复杂度 较低 较高

一个容易忽略的细节: 浅拷贝和深拷贝并不是值类型与引用类型的另一种说法。它们描述的是对象复制策略,而值类型与引用类型描述的是语言中的数据语义。

五、值类型与引用类型在不同语言中的表现

不同编程语言对值和引用的设计并不完全相同。不能仅凭变量是否指向内存地址,就判断一种语言采用了哪种类型语义。

1. Java:基本类型与引用类型

Java 明确区分基本数据类型和引用类型。

基本数据类型:

  • byte
  • short
  • int
  • long
  • float
  • double
  • char
  • boolean

基本类型变量直接保存对应的值。

int a = 10;
int b = a;

b = 20;

System.out.println(a); // 10

引用类型:

  • 类(Class)
  • 数组(Array)
  • 接口类型的引用
  • 枚举类型
  • String 等对象类型
int[] a = {1, 2, 3};
int[] b = a;

b[0] = 100;

System.out.println(a[0]); // 100

Java 的一个重要特征是:所有参数传递都是值传递(Pass by Value)。

对于基本类型,传递的是基本值的副本。

对于对象,传递的是引用值的副本。

class User {
    String name;
}

static void change(User user) {
    user.name = "Bob";
}

static void reassign(User user) {
    user = new User();
    user.name = "Charlie";
}

调用:

User u = new User();
u.name = "Alice";

change(u);
System.out.println(u.name); // Bob

reassign(u);
System.out.println(u.name); // Bob

原因:

  • change 接收到引用副本,但该副本和原变量指向同一个对象,因此修改对象属性会影响原对象。
  • reassign 只修改了方法内部的引用副本,原变量 u 仍然指向原对象。

Java 并不存在传统意义上的引用传递。引用本身作为一个值被复制后传入方法。

2. C++:值语义与引用语义更加明确

C++ 同时支持值类型、指针和引用,能够显式控制参数传递方式。

值传递:

void change(int x) {
    x = 20;
}

int main() {
    int a = 10;
    change(a);

    // a 仍然是 10
}

函数接收参数副本,修改副本不会影响调用方变量。

引用传递:

void change(int& x) {
    x = 20;
}

int main() {
    int a = 10;
    change(a);

    // a 变成 20
}

int& 声明的是引用参数,函数操作的是调用方原变量。

指针传递:

void change(int* p) {
    if (p != nullptr) {
        *p = 20;
    }
}

int main() {
    int a = 10;
    change(&a);

    // a 变成 20
}

指针保存对象地址,通过解引用可以访问和修改目标对象。

需要注意,C++ 中引用不是普通指针的语法别名。引用一旦绑定到对象,通常不能重新绑定到另一个对象;指针则可以改变其指向。

C++ 的类和结构体默认采用值语义,但也可以通过指针、引用、智能指针等方式实现共享对象。

3. Python:对象模型与名称绑定

Python 不采用 Java 式的基本类型和引用类型二分法。

Python 中变量更准确地说是对象的名称绑定(Name Binding)。

变量名绑定到对象,赋值通常是让另一个名称也绑定到同一个对象。

a = [1, 2, 3]
b = a

b.append(4)

print(a)  # [1, 2, 3, 4]
print(b)  # [1, 2, 3, 4]

这里 a 和 b 都绑定到同一个列表对象。

但对于整数:

a = 10
b = a

b = 20

print(a)  # 10
print(b)  # 20