返回专栏
· 11 分钟阅读

值传递与引用传递(Pass by Value vs. Pass by Reference)


一、值传递与引用传递的基本概念

函数调用时,调用方通过实参向被调用函数提供数据,函数通过形参接收这些数据。

根据形参与实参之间的关联方式,常见的参数传递语义可以分为值传递和引用传递。

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;
}

这里发生的是:

  1. 调用方获取变量 a 的地址。
  2. 将地址值传递给函数。
  3. 函数通过指针形参 p 访问原变量。
  4. 解引用后修改原变量。

关键点:

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&&:右值引用,常用于移动语义和完美转发。