一、什么是值类型与引用类型?
值类型(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