一、什么是参数传递机制
参数传递机制(Parameter Passing Mechanisms)是编程语言在函数调用过程中,将调用方提供的实参(Argument)与被调用函数声明的形参(Parameter)建立关联的规则。
例如:
def add(a, b):
return a + b
result = add(10, 20)
这里:
a、b:形参(Parameter),函数定义时声明的变量。10、20:实参(Argument),函数调用时传入的值。- 参数传递:将实参与形参建立对应关系的过程。
参数传递不仅涉及数据如何传入,还决定了以下行为:
- 函数是否获得原始数据的副本。
- 函数能否修改调用方持有的数据。
- 函数内部的变量重新赋值是否影响调用方。
- 对象、指针和引用在调用过程中如何表现。
- 参数传递是否涉及复制、地址传递或别名关系。
需要特别注意:参数传递机制与参数本身的数据类型是两个不同维度。 同一种数据类型,在不同语言中可能采用不同的参数传递语义。
二、参数传递的基本过程
函数调用时,运行时需要完成实参求值、参数绑定、函数执行以及返回等操作。
flowchart TD
A["调用函数"] --> B["计算实参表达式"]
B --> C["建立形参与实参的关联"]
C --> D["创建或绑定函数执行环境"]
D --> E["执行函数体"]
E --> F{"是否返回"}
F -->|"是"| G["返回结果"]
F -->|"异常或提前退出"| H["结束当前调用"]
G --> I["调用方继续执行"]
H --> I
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:#E0F0FE,stroke:#93BCE8,color:#1E4976
style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style I fill:#E5F4EC,stroke:#A3CBB5,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
不同语言的实现细节可能不同:
- 编译型语言可能通过寄存器、栈或内存地址传递参数。
- 解释型语言可能通过运行时对象引用和调用帧完成参数绑定。
- 编译器可能对参数进行寄存器分配、复制消除和内联优化。
这些属于底层实现方式,不能直接等同于语言层面的参数传递语义。
三、值传递(Pass by Value)
值传递是指:函数接收实参的值,并将其绑定到独立的形参存储位置。
形参与实参在逻辑上相互独立。函数修改形参,不会直接修改调用方的变量。
3.1 基本示例
以 C 语言为例:
#include <stdio.h>
void change(int x) {
x = 100;
}
int main() {
int a = 10;
change(a);
printf("%d\n", a); // 10
return 0;
}
执行过程:
flowchart TD
A["调用 change(a)"] --> B["读取 a 的值:10"]
B --> C["将值复制到形参 x"]
C --> D["函数内部修改 x = 100"]
D --> E["形参 x 变为 100"]
E --> F["函数返回"]
F --> G["调用方 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:#E5F4EC,stroke:#A3CBB5,color:#334155
style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
3.2 内存关系
可以从逻辑上理解为两个独立变量:
| 变量 | 初始值 | 函数执行后 |
|---|---|---|
调用方 a |
10 | 10 |
形参 x |
10 | 100 |
修改 x 不会影响 a。
这里的独立是语言语义层面的独立,不意味着编译器必须为两个变量分配不同的物理内存位置。优化后的机器代码可能消除实际复制操作,只要程序可观察到的行为保持一致。
3.3 值传递的特点
- 形参拥有独立的变量绑定。
- 修改形参本身不会修改调用方变量。
- 通常需要复制实参的值,或通过等价方式实现值语义。
- 适用于基本数值、布尔值以及其他需要独立值语义的参数。
但值传递不代表一定复制整个对象。对于对象引用或指针类型,复制的可能只是引用值或地址值。
四、引用传递(Pass by Reference)
引用传递是指:形参与调用方的变量建立引用关系,函数通过形参访问的就是调用方对应的变量。
因此,函数通过形参修改变量,会直接影响调用方。
4.1 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;
}
其中:
void change(int& x)
int& 表示引用类型,x 是 a 的另一个访问名称。
执行关系:
flowchart TD
A["调用 change(a)"] --> B["形参 x 绑定到变量 a"]
B --> C["通过 x 修改变量"]
C --> D["a 的值变为 100"]
D --> E["函数返回"]
E --> F["调用方观察到 a = 100"]
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:#E8EDF2,stroke:#B8C3CE,color:#334155
style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
4.2 引用的关键特征
在 C++ 中:
- 引用必须在初始化时绑定到有效对象。
- 引用初始化后不能重新绑定到另一个对象。
- 通过引用修改对象,实际修改的是被引用对象。
- 引用本身不是一个独立的对象变量,语言语义上表现为原对象的别名。
例如:
int a = 10;
int b = 20;
int& ref = a;
ref = b;
执行后:
a == 20;
b == 20;
这里 ref = b 并不是让 ref 重新绑定到 b,而是将 b 的值赋给 ref 所引用的 a。
4.3 常量引用
C++ 还支持常量引用:
void print(const std::string& value) {
std::cout << value << std::endl;
}
const std::string& 具有两个重要特点:
- 避免复制大型对象。
- 不允许通过该引用修改对象。
它常用于只读参数,兼顾性能与接口安全性。
需要注意,const 限制的是通过当前引用进行的修改,不意味着对象在其他访问路径下绝对不可修改。
五、指针传递(Pointer Passing)
指针传递是通过指针变量保存的内存地址,让函数能够访问其他位置的数据。
需要区分一个重要概念:
在 C 语言中,指针参数本身仍然是值传递。
传递的是指针值,也就是地址的副本,而不是 C++ 意义上的引用传递。
5.1 通过指针修改变量
#include <stdio.h>
void change(int *p) {
*p = 100;
}
int main() {
int a = 10;
change(&a);
printf("%d\n", a); // 100
return 0;
}
这里:
&a:获取变量a的地址。p:接收地址值的指针形参。*p:通过地址访问对应的对象。
虽然指针参数是值传递,但指针副本和调用方传入的指针具有相同的目标地址,因此可以通过解引用修改原变量。
5.2 修改指针本身
#include <stdio.h>
void changePointer(int *p) {
int temp = 100;
p = &temp;
}
int main() {
int a = 10;
int *ptr = &a;
changePointer(ptr);
printf("%d\n", *ptr); // 10
return 0;
}
函数内部修改的是指针形参 p,而不是调用方的 ptr。
如果需要修改调用方的指针变量,需要传递指针的地址,即二级指针:
#include <stdio.h>
#include <stdlib.h>
void allocate(int **p) {
*p = malloc(sizeof(int));
if (*p != NULL) {
**p = 100;
}
}
int main() {
int *ptr = NULL;
allocate(&ptr);
if (ptr != NULL) {
printf("%d\n", *ptr); // 100
free(ptr);
}
return 0;
}
这里:
p是指向指针的指针。*p是调用方的指针变量。**p是调用方指针指向的整数对象。
指针传递与引用传递的差异不能只看是否能修改原数据,还需要判断修改的是数据本身,还是保存地址的变量。
六、共享对象传递(Pass by Sharing)
共享对象传递也称为对象共享传递(Call by Sharing),是一种在 Python、Java 等语言中经常遇到的参数行为。
其核心是:
函数获得对象引用值的副本,调用方与函数形参可以指向同一个对象,但两个变量绑定彼此独立。
这意味着:
- 可以通过形参修改共享对象的内部状态。
- 重新给形参赋值,不会改变调用方变量的绑定关系。
6.1 Python 示例
def modify(items):
items.append(100)
data = [1, 2, 3]
modify(data)
print(data) # [1, 2, 3, 100]
函数内部通过 items 修改了列表对象,因此调用方观察到了变化。
6.2 重新绑定参数
def modify(items):
items = [100, 200]
data = [1, 2, 3]
modify(data)
print(data) # [1, 2, 3]
这里 items = [100, 200] 创建了新的列表对象,并将局部变量 items 绑定到新对象。
调用方的 data 仍然指向原列表。
6.3 对象共享关系
flowchart TD
A["调用方变量 data"] --> C["列表对象"]
B["函数形参 items"] --> C
C --> D["共享对象内部状态"]
D --> E["append 修改对象"]
E --> F["调用方观察到变化"]
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
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
这里有两个独立的变量绑定:
data绑定到列表对象。items也绑定到同一个列表对象。
对象是共享的,变量绑定不是共享的。
6.4 Java 中的参数传递
Java 也采用值传递。
对于基本类型,复制的是基本类型的值:
public class Main {
static void change(int x) {
x = 100;
}
public static void main(String[] args) {
int a = 10;
change(a);
System.out.println(a); // 10
}
}
对于对象类型,复制的是对象引用值:
import java.util.ArrayList;
import java.util.List;
public class Main {
static void modify(List<Integer> list) {
list.add(100);
}
static void reassign(List<Integer> list) {
list = new ArrayList<>();
list.add(200);
}
public static void main(String[] args) {
List<Integer> data = new ArrayList<>();
data.add(1);
modify(data);
System.out.println(data); // [1, 100]
reassign(data);
System.out.println(data); // [1, 100]
}
}