一、值传递与引用传递的基本概念
函数调用时,调用方通过实参向被调用函数提供数据,函数通过形参接收这些数据。
根据形参与实参之间的关联方式,常见的参数传递语义可以分为值传递和引用传递。
1. 值传递(Pass by Value)
值传递是指:函数接收实参值的副本,并将其绑定到形参。
形参与调用方变量是两个独立的变量。函数内部修改形参本身,不会直接改变调用方变量。
#include <stdio.h>
void change(int x) {
x = 100;
}
int main() {
int a = 10;
change(a);
printf("%d\n", a); // 10
return 0;
}
执行结果:
10
调用 change(a) 时,函数获得 a 当前值的副本。
函数内部修改 x,只会影响形参 x,不会改变调用方的 a。
2. 引用传递(Pass by Reference)
引用传递是指:形参与调用方的变量建立直接引用关系,函数通过形参访问的就是调用方对应的变量。
函数内部通过形参修改变量,会直接影响调用方。
C++ 示例:
#include <iostream>
using namespace std;
void change(int& x) {
x = 100;
}
int main() {
int a = 10;
change(a);
cout << a << endl; // 100
return 0;
}
执行结果:
100
这里的 x 是 a 的引用。通过 x 修改值,实际上就是修改 a。
3. 两者的核心区别
| 对比维度 | 值传递 | 引用传递 |
|---|---|---|
| 参数关系 | 独立变量绑定 | 形参关联调用方变量 |
| 是否复制值 | 语义上获得值的副本 | 不复制被引用变量的值作为独立形参 |
| 修改形参 | 不直接影响原变量 | 影响原变量 |
| 重新赋值形参 | 不影响原变量 | 会修改被引用变量 |
| 数据共享 | 取决于传递的值 | 直接访问同一变量 |
| 典型语言示例 | C、Java | C++、C# 的 ref 参数 |
需要注意:这里讨论的是语言层面的参数传递语义,不是寄存器、栈或内存地址等底层实现细节。
二、值传递的工作原理
2.1 变量副本
假设调用方有一个变量:
int a = 10;
调用函数:
change(a);
函数接收参数:
void change(int x) {
x = 100;
}
从逻辑上看,函数执行期间存在两个独立变量:
| 变量 | 初始值 | 修改后 |
|---|---|---|
a |
10 | 10 |
x |
10 | 100 |
二者拥有相同的初始值,但修改其中一个不会改变另一个。
2.2 执行过程
flowchart TD
A["调用方变量 a = 10"] --> B["调用 change(a)"]
B --> C["读取 a 的值"]
C --> D["创建形参 x 的独立值绑定"]
D --> E["函数内部执行 x = 100"]
E --> F["x 变为 100"]
F --> G["函数返回"]
G --> H["调用方 a 仍然为 10"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
2.3 值传递不一定复制整个对象
这是理解值传递时非常重要的一个问题。
值传递复制的是参数值,但参数值不一定是完整对象,也可能是:
- 整数、浮点数等基本值。
- 指针地址。
- 对象引用。
- 切片描述符。
- 其他包含间接引用关系的数据结构。
例如:
void change(int *p) {
*p = 100;
}
调用:
int a = 10;
change(&a);
这里传递的是地址值的副本。函数通过地址访问原变量,因此可以修改 a。
所以:
值传递不等于函数只能修改副本中的数据。它只能说明形参接收的是实参值的副本。
如果这个值本身包含指向共享对象的地址或引用,函数仍然可能修改共享对象。
三、引用传递的工作原理
3.1 引用与原变量建立关联
C++ 中可以通过引用参数实现引用传递:
void change(int& x) {
x = 100;
}
调用:
int a = 10;
change(a);
函数内部的 x 与调用方的 a 关联。
从语言语义上看,x 是 a 的另一个名称,而不是一个拥有独立值的普通变量。
3.2 执行过程
flowchart TD
A["调用方变量 a = 10"] --> B["调用 change(a)"]
B --> C["形参 x 绑定到变量 a"]
C --> D["通过 x 执行赋值"]
D --> E["原变量 a 被修改"]
E --> F["a 的值变为 100"]
F --> G["函数返回"]
G --> H["调用方读取到 100"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
3.3 引用的几个重要特性
以 C++ 左值引用为例:
特性一:引用必须初始化
int a = 10;
int& ref = a;
不能声明一个未初始化的普通左值引用:
int& ref; // 编译错误
特性二:引用初始化后不能重新绑定
int a = 10;
int b = 20;
int& ref = a;
ref = b;
执行后:
a == 20;
b == 20;
ref = b 是赋值操作,不是引用重新绑定。
ref 仍然引用 a,只是将 b 的值赋给了 a。
特性三:引用可以限制修改权限
void print(const int& value) {
// value = 100; // 不允许通过该引用修改
std::cout << value << std::endl;
}
const int& 常用于大型对象的只读参数传递,可以避免不必要的复制,同时限制函数对对象的修改。
四、指针传递与引用传递的区别
指针和引用经常被放在一起讨论,但二者并不是同一种机制。
4.1 C 语言中的指针参数
#include <stdio.h>
void change(int *p) {
*p = 100;
}
int main() {
int a = 10;
change(&a);
printf("%d\n", a); // 100
return 0;
}
这里发生的是:
- 调用方获取变量
a的地址。 - 将地址值传递给函数。
- 函数通过指针形参
p访问原变量。 - 解引用后修改原变量。
关键点:
C 语言中的指针参数仍然采用值传递,复制的是指针所保存的地址值。
4.2 指针本身也会被复制
void changePointer(int *p) {
int temp = 100;
p = &temp;
}
这里修改的是函数内部的指针变量 p。
调用方的指针变量不会因此改变。
如果需要修改调用方的指针变量,可以使用二级指针:
#include <stdlib.h>
void allocate(int **p) {
*p = malloc(sizeof(int));
if (*p != NULL) {
**p = 100;
}
}
4.3 指针与引用对比
| 对比维度 | 指针 | C++ 引用 |
|---|---|---|
| 本质 | 保存地址值的变量 | 对已有对象的别名 |
| 是否可以为空 | 可以使用空指针表示无对象 | 普通引用不能合法地绑定到空对象 |
| 是否可以重新指向 | 可以 | 初始化后不能重新绑定 |
| 访问对象 | 需要解引用 | 可以直接使用 |
| 是否支持多级间接访问 | 支持 | 不直接支持指针式多级间接访问 |
| 参数传递 | 指针值传递 | 引用参数实现引用传递 |
需要注意,C++ 引用底层可能通过地址实现,但不能因此认为引用与指针在语言语义上完全相同。
五、对象参数:为什么值传递也能修改原对象
这是 Java、Python、JavaScript 等语言中最容易产生误解的地方。
当函数参数是对象类型时,复制的可能不是对象本身,而是对象引用值。
调用方和函数形参可能持有不同的引用值副本,但这些引用指向同一个对象。
5.1 Java 示例
import java.util.ArrayList;
import java.util.List;
public class Main {
static void modify(List<Integer> list) {
list.add(100);
}
public static void main(String[] args) {
List<Integer> data = new ArrayList<>();
data.add(1);
modify(data);
System.out.println(data); // [1, 100]
}
}
为什么 modify 能修改调用方的数据?
因为 list 与 data 指向同一个列表对象。
Java 传递的仍然是值,只不过这个值是对象引用。
5.2 重新赋值不会改变调用方引用
static void replace(List<Integer> list) {
list = new ArrayList<>();
list.add(200);
}
调用:
List<Integer> data = new ArrayList<>();
data.add(1);
replace(data);
System.out.println(data); // [1]
list 被重新绑定到了新的列表对象,但 data 仍然指向原来的列表。
5.3 对象引用关系
flowchart TD
A["调用方变量 data"] --> C["原列表对象"]
B["函数形参 list"] --> C
C --> D["共享对象状态"]
D --> E["通过 list 修改对象"]
E --> F["data 观察到修改结果"]
G["函数内部重新赋值 list"] --> H["新列表对象"]
H --> I["仅改变局部变量绑定"]
I --> J["data 仍指向原列表对象"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style I fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style J fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
因此,需要区分:
- 修改对象:通过引用访问对象内部状态。
- 修改变量:改变变量自身保存的值或绑定关系。
前者可能影响调用方,后者通常只影响函数内部的形参。
六、不同编程语言中的实现
6.1 C 语言
C 语言的函数参数采用值传递。
void func(int x);
void func(int *p);
两者都是值传递:
int x:复制整数值。int *p:复制指针地址值。
C 语言没有 C++ 那种直接的引用参数语法。
6.2 C++
C++ 同时支持值参数和引用参数。
void func1(int x); // 值参数
void func2(int& x); // 左值引用参数
void func3(const int& x); // 常量左值引用参数
void func4(int&& x); // 右值引用参数
需要区分:
T:按值接收对象。T&:通过左值引用访问对象。const T&:通过只读左值引用访问对象。T&&:右值引用,常用于移动语义和完美转发。