返回专栏
· 11 分钟阅读

参数传递机制(Parameter Passing Mechanisms)


一、什么是参数传递机制

参数传递机制(Parameter Passing Mechanisms)是编程语言在函数调用过程中,将调用方提供的实参(Argument)与被调用函数声明的形参(Parameter)建立关联的规则。

例如:

def add(a, b):
    return a + b

result = add(10, 20)

这里:

  • a、b:形参(Parameter),函数定义时声明的变量。
  • 10、20:实参(Argument),函数调用时传入的值。
  • 参数传递:将实参与形参建立对应关系的过程。

参数传递不仅涉及数据如何传入,还决定了以下行为:

  1. 函数是否获得原始数据的副本。
  2. 函数能否修改调用方持有的数据。
  3. 函数内部的变量重新赋值是否影响调用方。
  4. 对象、指针和引用在调用过程中如何表现。
  5. 参数传递是否涉及复制、地址传递或别名关系。

需要特别注意:参数传递机制与参数本身的数据类型是两个不同维度。 同一种数据类型,在不同语言中可能采用不同的参数传递语义。

二、参数传递的基本过程

函数调用时,运行时需要完成实参求值、参数绑定、函数执行以及返回等操作。

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& 具有两个重要特点:

  1. 避免复制大型对象。
  2. 不允许通过该引用修改对象。

它常用于只读参数,兼顾性能与接口安全性。

需要注意,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]
    }
}