【C语言入门】函数调用：传值调用（值传递）

1. 前置知识：函数与参数传递的基本概念

在 C 语言中，函数是程序的基本组成单元，用于封装特定功能的代码块。一个函数通常由 “函数名”“参数列表”“函数体” 和 “返回值” 组成。例如：

int add(int a, int b) {  // 函数定义：参数a和b是“形参”（形式参数）
    return a + b;
}

int main() {
    int x = 3, y = 5;
    int sum = add(x, y);  // 调用add函数时，x和y是“实参”（实际参数）
    return 0;
}

这里的 “参数” 是函数与外部交互的桥梁。当我们调用函数（如add(x, y)）时，需要将外部的数据（x和y）传递给函数内部使用。这个传递过程涉及两个关键概念：

• 实参（实际参数）：调用函数时传递的原始数据（如x和y）。
• 形参（形式参数）：函数定义时声明的参数（如a和b），用于接收实参传递的数据。

而 “参数传递方式” 则决定了实参如何传递给形参。C 语言中最常用的传递方式是 “传值调用”（Value Passing），此外还有 “传址调用”（Address Passing，通过指针实现）。本文将聚焦 “传值调用”。

2. 传值调用的定义与核心特征

传值调用的定义：
当函数被调用时，实参会将自身的值复制一份传递给形参。函数内部操作的是这个 “复制后的值”（形参），而原始的实参不会被函数内部的操作影响。

核心特征：

• 单向复制：数据从实参单向传递给形参，形参是实参的 “副本”。
• 隔离性：函数内部对形参的修改不会影响实参（因为操作的是副本）。
• 适用广泛：C 语言中默认的参数传递方式（除数组外，数组传参本质是传址，后文会详细说明）。

3. 传值调用的底层实现：内存视角

要理解传值调用的本质，需要从内存的角度分析。

在 C 程序运行时，内存会被划分为多个区域，其中 “栈区” 用于存储函数的局部变量和参数。当函数被调用时，系统会为该函数分配一块 “栈帧”（Stack Frame），用于存放形参、函数内部的局部变量等。

3.1 实参与形参的内存关系

假设我们有如下代码：

void modify(int num) {  // 形参num
    num = num + 10;     // 修改形参
}

int main() {
    int x = 5;          // 实参x
    modify(x);          // 调用modify函数
    printf("x = %d\n", x);  // 输出x的值
    return 0;
}

运行这段代码，输出结果是：

x = 5

为什么x的值没有被修改？我们通过内存视角分析：

1. main函数运行时，在栈区为局部变量x分配内存，地址假设为0x1000，存储值为5。
2. 调用modify(x)时，系统为modify函数分配栈帧：
   • 将实参x的值（5）复制到形参num的内存空间（地址假设为0x2000）。
   • modify函数内部操作的是num（地址0x2000），将其值改为15。
3. modify函数执行结束后，其栈帧被销毁（num的内存被释放）。
4. main函数中的x（地址0x1000）始终未被修改，因此输出5。

关键结论：
传值调用的本质是 “实参值的拷贝”，形参和实参在内存中是两个独立的变量，拥有不同的内存地址。函数内部对形参的修改仅影响形参的内存空间，与实参无关。

3.2 不同数据类型的拷贝过程

传值调用的 “拷贝” 行为对不同数据类型的处理方式相同，但拷贝的 “代价”（时间和空间）可能不同：

3.2.1 基本数据类型（如 int、char）

基本数据类型的大小固定（如int通常占 4 字节，char占 1 字节），拷贝过程非常高效。例如：

void func(int a, char b) {  // 形参a（4字节）、b（1字节）
    // 操作a和b...
}

int main() {
    int x = 10;     // 4字节
    char y = 'A';   // 1字节
    func(x, y);     // 拷贝x的值（10）给a，拷贝y的值（'A'）给b
    return 0;
}

3.2.2 结构体类型（struct）

结构体由多个成员组成，其大小是所有成员大小的总和（需考虑内存对齐）。传值调用时，会拷贝整个结构体的所有成员。例如：

struct Student {
    char name[20];  // 20字节
    int age;        // 4字节（假设内存对齐后总大小为24字节）
};

void print_student(struct Student s) {  // 形参s是结构体的拷贝
    printf("Name: %s, Age: %d\n", s.name, s.age);
}

int main() {
    struct Student stu = {"Alice", 20};  // 实参stu
    print_student(stu);                  // 拷贝整个stu结构体给形参s
    return 0;
}

此时，print_student函数的形参s是stu的完整拷贝（24 字节）。如果结构体很大（例如包含数组或多个成员），拷贝操作会消耗较多内存和时间，这也是为什么 C 语言中常用 “结构体指针” 传递大结构体（本质是传址调用，后文对比）。

3.2.3 数组类型（特殊情况）

在 C 语言中，数组作为函数参数时，会 “退化为指针”，因此数组传参本质是传址调用，而非传值调用。这是初学者容易混淆的点。例如：

void modify_array(int arr[]) {  // 本质是int* arr
    arr[0] = 100;  // 修改数组第一个元素
}

int main() {
    int a[3] = {1, 2, 3};
    modify_array(a);  // 传递数组首元素地址（而非数组的拷贝）
    printf("a[0] = %d\n", a[0]);  // 输出100
    return 0;
}

这里modify_array函数的形参arr实际上是一个指针（int*），接收的是数组a的首元素地址。因此，函数内部对arr[0]的修改会直接影响原始数组a。这说明：数组传参不是传值调用，而是隐式的传址调用。

4. 传值调用的典型示例与验证

为了更直观地理解传值调用的 “隔离性”，我们通过几个示例验证。

示例 1：尝试通过传值调用交换两个整数的值

目标：编写一个函数swap，通过传值调用交换两个整数x和y的值。

代码实现：

#include <stdio.h>

// 传值调用的swap函数（错误版本）
void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;  // 仅交换形参a和b的值
}

int main() {
    int x = 10, y = 20;
    printf("交换前：x = %d, y = %d\n", x, y);  // 输出10, 20

    swap(x, y);  // 调用swap函数（传值调用）

    printf("交换后：x = %d, y = %d\n", x, y);  // 输出10, 20（未交换）
    return 0;
}

输出结果：

交换前：x = 10, y = 20
交换后：x = 10, y = 20

原因分析：
swap函数的形参a和b是x和y的拷贝（值传递）。函数内部交换了a和b的值，但这只是修改了 “拷贝”，原始的x和y未被影响。因此，main函数中的x和y值不变。

示例 2：传值调用中修改指针变量（容易混淆的场景）

假设我们有一个指针变量p，指向一个整数。如果通过传值调用将p传递给函数，能否修改原始指针的指向？

代码实现：

#include <stdio.h>
#include <stdlib.h>

// 传值调用：尝试修改指针的指向（错误版本）
void modify_ptr(int* ptr) {
    int new_value = 100;
    ptr = &new_value;  // 修改形参ptr的指向（指向new_value的地址）
}

int main() {
    int x = 5;
    int* p = &x;  // p指向x的地址（0x1000）

    printf("修改前p指向的地址：%p，值：%d\n", p, *p);  // 输出0x1000, 5

    modify_ptr(p);  // 传值调用：拷贝p的值（0x1000）给形参ptr

    printf("修改后p指向的地址：%p，值：%d\n", p, *p);  // 输出0x1000, 5（未修改）
    return 0;
}

输出结果：

修改前p指向的地址：0x1000，值：5
修改后p指向的地址：0x1000，值：5

原因分析：
modify_ptr函数的形参ptr是指针变量p的拷贝（传值调用）。函数内部将ptr指向了new_value的地址，但这只是修改了 “拷贝的指针”，原始指针p的指向（0x1000）并未改变。因此，main函数中的p仍然指向x。

关键结论：
即使参数是指针类型，传值调用的本质仍是 “拷贝”。函数内部对指针形参的修改（如改变指向）不会影响原始指针实参。

5. 传值调用的优缺点分析

传值调用是 C 语言的默认传递方式，其设计有明确的优势，但也存在局限性。

5.1 优点：数据隔离与安全性

传值调用的核心优势是 “数据隔离”：函数只能操作实参的拷贝，无法修改原始数据。这在以下场景中非常有用：

5.1.1 保护原始数据

当需要确保原始数据不被函数意外修改时，传值调用是天然的保护机制。例如，一个计算平均值的函数，不需要修改原始数据，只需使用其值即可：

double average(int nums[], int len) {  // 注意：数组传参是传址，这里仅举例
    int sum = 0;
    for (int i = 0; i < len; i++) {
        sum += nums[i];  // 使用数组元素的值，不修改原始数组
    }
    return (double)sum / len;
}

5.1.2 避免副作用（Side Effect）

函数的 “副作用” 指函数在计算结果之外对外部数据的修改。传值调用通过隔离形参和实参，减少了副作用的可能性，使函数更符合 “纯函数”（输入决定输出，无外部依赖）的设计原则，提高代码的可维护性和可测试性。

5.2 缺点：大对象传递的低效性

传值调用的主要缺点是拷贝大对象时的性能开销。例如，传递一个包含 1000 个元素的结构体时，需要拷贝整个结构体的内存，这会消耗较多时间和内存。

示例：大结构体传值调用的性能问题

#include <stdio.h>
#include <time.h>

#define ARRAY_SIZE 10000

// 大结构体：包含一个大数组
struct BigStruct {
    int data[ARRAY_SIZE];
};

// 传值调用：接收结构体的拷贝
void process_struct(struct BigStruct s) {
    // 简单操作：修改第一个元素
    s.data[0] = 100;
}

int main() {
    struct BigStruct bs;
    // 初始化数组（填充0）
    for (int i = 0; i < ARRAY_SIZE; i++) {
        bs.data[i] = 0;
    }

    // 计时开始
    clock_t start = clock();

    // 调用1000次process_struct（每次拷贝大结构体）
    for (int i = 0; i < 1000; i++) {
        process_struct(bs);
    }

    // 计时结束
    clock_t end = clock();
    double time_used = (double)(end - start) / CLOCKS_PER_SEC;

    printf("耗时：%f 秒\n", time_used);
    return 0;
}

运行结果（不同机器可能不同）：

耗时：0.123 秒

如果将process_struct改为传址调用（通过指针传递结构体），性能会显著提升：

// 传址调用：接收结构体指针（仅拷贝8字节指针，而非整个结构体）
void process_struct(struct BigStruct* s) {
    s->data[0] = 100;  // 通过指针修改原始结构体
}

// main函数中调用：
process_struct(&bs);  // 传递结构体地址

此时，每次函数调用仅需拷贝指针（通常 8 字节），而非整个大结构体（ARRAY_SIZE * 4字节），性能提升明显。

6. 传值调用与传址调用的对比

为了更清晰地理解传值调用，我们将其与 C 语言中另一种常见的传递方式 ——“传址调用”（通过指针实现）进行对比。

6.1 定义对比

• 传值调用：实参的值被拷贝给形参，形参和实参是独立的变量。
• 传址调用：实参的地址被传递给形参（形参是指针），形参通过地址直接操作实参的内存空间。

6.2 内存操作对比

特征	传值调用	传址调用
数据传递方式	实参值的拷贝	实参地址的传递
形参与实参的关系	独立的变量（不同内存地址）	形参指向实参的内存地址
函数能否修改实参	否（仅修改拷贝）	是（直接修改实参的内存）
典型应用场景	小对象传递、保护原始数据	大对象传递、需要修改实参

6.3 示例对比：交换两个整数（正确版本）

通过传址调用实现swap函数，可以真正交换两个整数的值：

代码实现：

#include <stdio.h>

// 传址调用：接收指针（实参的地址）
void swap(int* a, int* b) {
    int temp = *a;  // 解引用指针，获取实参的值
    *a = *b;        // 通过指针修改实参的内存
    *b = temp;
}

int main() {
    int x = 10, y = 20;
    printf("交换前：x = %d, y = %d\n", x, y);  // 输出10, 20

    swap(&x, &y);  // 传递x和y的地址（传址调用）

    printf("交换后：x = %d, y = %d\n", x, y);  // 输出20, 10（成功交换）
    return 0;
}

输出结果：

交换前：x = 10, y = 20
交换后：x = 20, y = 10

原因分析：
swap函数的形参a和b是指针，分别存储了x和y的地址（&x和&y）。通过解引用操作（*a和*b），函数直接修改了x和y的内存空间，因此main函数中的x和y值被交换。

7. 传值调用的常见误区与注意事项

初学者在使用传值调用时，容易陷入以下误区：

误区 1：认为数组传参是传值调用

如前所述，C 语言中数组作为函数参数时会退化为指针，因此数组传参本质是传址调用。例如：

void func(int arr[]) {  // 等价于int* arr
    arr[0] = 100;  // 修改原始数组的第一个元素
}

int main() {
    int a[3] = {1, 2, 3};
    func(a);  // 传递数组首元素地址
    printf("a[0] = %d\n", a[0]);  // 输出100（被修改）
    return 0;
}

误区 2：认为指针传参是传值调用的例外

指针本身是变量，存储的是内存地址。当通过传值调用传递指针时，形参是指针的拷贝（地址值的拷贝），但指针指向的内存空间是共享的。例如：

void modify(int* ptr) {  // 传值调用：ptr是指针的拷贝
    *ptr = 100;  // 通过拷贝的指针修改原始内存（*ptr与实参指向同一地址）
}

int main() {
    int x = 5;
    int* p = &x;
    modify(p);  // 传递指针p的值（x的地址）
    printf("x = %d\n", x);  // 输出100（被修改）
    return 0;
}

这里modify函数的形参ptr是指针p的拷贝（传值调用），但ptr和p指向同一个地址（&x）。因此，通过*ptr修改的是x的内存空间，x的值会被改变。这说明：传值调用的指针本身无法被修改，但指针指向的内存可以被修改。

注意事项：

• 避免对大对象使用传值调用：传递大结构体或大数组时，传值调用的拷贝操作会导致性能问题，应改用指针传址调用。
• 明确函数意图：如果函数需要修改实参，必须使用传址调用；如果仅需使用实参的值，应使用传值调用以保护原始数据。

8. 传值调用在实际编程中的应用场景

传值调用因其 “数据隔离” 的特性，在以下场景中被广泛使用：

8.1 数学计算函数

例如，计算两个数的和、差、积、商等，函数只需使用实参的值，无需修改原始数据：

int multiply(int a, int b) {  // 传值调用
    return a * b;
}

8.2 数据查询函数

例如，查询数组中的最大值、字符串的长度等，函数只需读取实参的值：

int find_max(int nums[], int len) {  // 数组传参是传址，但函数意图是查询
    int max = nums[0];
    for (int i = 1; i < len; i++) {
        if (nums[i] > max) {
            max = nums[i];
        }
    }
    return max;
}

8.3 保护关键数据

当需要确保关键数据（如配置参数、只读数据）不被函数意外修改时，传值调用是天然的保护机制。例如：

void print_config(struct Config conf) {  // 传值调用：拷贝conf结构体
    printf("Port: %d\n", conf.port);
    printf("Timeout: %d\n", conf.timeout);
    // 即使函数内部误操作修改了conf，原始数据也不会被影响
}

9. 扩展知识：传值调用的底层实现细节（编译与链接视角）

要深入理解传值调用，还需要了解其在编译和链接阶段的底层实现。

9.1 函数调用的栈帧结构

在 C 语言中，函数调用时会在栈区创建 “栈帧”，用于存储以下内容：

• 形参（传值调用时是实参的拷贝）。
• 函数内部的局部变量。
• 返回地址（调用函数后需要返回的指令位置）。

以modify(x)函数调用为例，栈帧结构如下（假设x的地址是0x1000，num的地址是0x2000）：

内存地址	内容	说明
0x1000	5	实参 x 的值
...	...	...
0x2000	5	形参 num 的值（x 的拷贝）
0x2004	0x3000（返回地址）	modify 函数执行完后返回 main 的位置

9.2 汇编指令视角

编译器会将传值调用转换为具体的汇编指令，主要涉及 “压栈”（push）操作。例如，modify(x)的调用在汇编中可能表现为：

push x      ; 将x的值压入栈（拷贝到形参的位置）
call modify ; 调用modify函数

9.3 不同编译器的优化

现代编译器可能会对传值调用进行优化，例如 “寄存器传递”（将小对象的值直接存入寄存器，而非栈区），以提高效率。但无论如何优化，传值调用的本质（实参值的拷贝）不会改变。

10. 总结

传值调用是 C 语言中最基础、最常用的参数传递方式，其核心是 “实参值的拷贝”。通过本文的学习，你可以总结出以下关键点：

• 传值调用的形参是实参的 “副本”，函数内部操作不影响实参。
• 传值调用适用于小对象传递和需要保护原始数据的场景。
• 大对象传递时，传值调用的拷贝操作可能导致性能问题，需改用传址调用。
• 数组传参和指针传参是特殊情况，需注意区分传值调用与传址调用的本质。

形象生动的解释：用 “借笔记” 理解 “传值调用”

你可以把 “传值调用” 想象成校园里的一个生活场景：

假设你有一本特别珍贵的笔记本（这是你的 “实参”，也就是实际参与函数调用的原始数据）。某天，你的同学小明跑过来，说他需要参考你笔记本上的内容（相当于函数需要使用你的数据）。这时候，你有两种选择：

1. 直接把笔记本原件借给他（类似 “传址调用”，后面会对比）；
2. 复印一份笔记本的内容给他（这就是 “传值调用”）。

在 “传值调用” 的场景里，你选择了第二种方式：复印一份一模一样的内容给小明。小明拿到复印件后，可以在上面涂涂画画、做标记（相当于函数内部修改形参），但无论他怎么改，你的原件笔记本都不会受到任何影响（实参不会被修改）。等小明用完复印件，他可能随手扔掉或者保存，但这都和你的原件无。

这个过程的核心是：函数调用时，实参会 “复制一份” 传给函数的形参，函数内部操作的是 “复印件”，和原始的 “原件” 没有直接关联。这就是 “传值调用” 最形象的理解方式。