【C++】函数入参 值传递和引用传递，与C语言的区别

在 C++ 中，函数的参数传递有值传递和引用传递两种方式。当函数的参数是 vector 类型时，可以选择使用 vector 或 vector& 作为参数类型，两者各有优劣：

vector vect1：这种方式使用了值传递，即在函数调用时会对传入的 vector 对象进行拷贝，函数内部对参数进行修改不会影响原始对象。如果在函数体内调用 vect1.push_back(1)，则是对函数内部的拷贝对象进行操作，不会影响原始对象。

void func1(vector<int> vect) {
    vect.push_back(1);
}

int main() {
    vector<int> originalVect;
    func1(originalVect);
    // originalVect.size() 仍然为 0，没有改变
    return 0;
}
1
2
3
4
5
6
7
8
9
10

vector& vect1：这种方式使用了引用传递，即在函数调用时不会进行拷贝，直接操作原始对象。如果在函数体内调用 vect1.push_back(1)，则会直接对原始对象进行操作。

void func2(vector<int>& vect) {
    vect.push_back(1);
}

int main() {
    vector<int> originalVect;
    func2(originalVect);
    // originalVect.size() 现在为 1，已经改变
    return 0;
}
1
2
3
4
5
6
7
8
9
10

因此，如果希望在函数内部修改传入的 vector
对象，并且希望这些修改能够影响到原始对象，那么应该使用引用传递（vector&）。如果只是需要在函数内部使用传入的 vector 对象而不修改原始对象，那么可以使用值传递（vector）。

需要注意的是，在使用引用传递时，需要注意函数内部对传入对象的修改可能会对原始对象造成意外的影响，因此在编写代码时需要慎重考虑传参方式，避免出现不可预期的结果。

在 C++ 中，对于 vector 对象来说，无论是通过引用传递还是值传递，都可以使用 vect.push_back(1) 这样的方式来对 vector 进行操作。这是因为 C++ 中的对象是面向对象的，其成员函数（比如 push_back）是通过对象直接调用的，而不需要通过指针来取得对象。

当你使用 vect.push_back(1) 时，编译器会根据 vect 的类型来自动调用对应的成员函数，让代码更加简洁和易读。

还可以通过指针传递方式将 vector 对象传递给函数。如果函数的参数是 vector* vect1，则表示该函数接受一个指向 vector 对象的指针作为参数。在函数内部，可以通过解引用操作符 * 来访问指针所指向的 vector 对象。

#include <iostream>
#include <vector>

void func(vector<int>* vect) {
    vect->push_back(1); // 使用箭头运算符 -> 访问指针指向的对象
}

int main() {
    vector<int> originalVect;
    func(&originalVect); // 传入指向 originalVect 的指针

    for (int num : originalVect) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在上面的代码中，func 函数接受一个指向 vector 对象的指针作为参数，然后通过箭头运算符 -> 来访问指针所指向的对象并调用 push_back 方法。在 main 函数中，我们将 originalVect 的地址传递给 func 函数，使得在函数内部可以修改原始对象。

通过指针传递 vector 对象，可以在函数内部修改原始对象的内容，并且不会发生对象的拷贝。需要注意的是，在使用指针传递时，需要确保指针有效性并注意内存管理，以避免出现悬空指针或内存泄漏等问题。

在 C 语言中，如果传入的是指针 vect，那么必须使用 *vect 来取得指针所指向的值，这是因为在 C 语言中，指针是一种特殊的数据类型，需要通过解引用操作符 * 才能获取指针指向的值。所以在 C 语言中，对于指针变量 vect，你需要使用 *vect 来获取其指向的值。

当在 C 语言中使用不同的参数传递方式时，可以通过值传递、引用传递和指针传递来访问和修改函数参数。以下是这三种方式的示例代码：

值传递（Pass by Value）示例：

#include <stdio.h>

// 值传递方式
void valuePass(int num) {
    num = 10; // 修改函数内的副本
}

int main() {
    int originalNum = 5;
    valuePass(originalNum); // 将 originalNum 的值传递给函数

    printf("Original number: %d\n", originalNum); // 输出 5，未被修改
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

引用传递（Pass by Reference）示例：
C 语言中并没有直接支持引用的概念，但可以通过指针来模拟引用传递的效果。

#include <stdio.h>

// 引用传递方式，使用指针模拟引用
void referencePass(int *num) {
    *num = 10; // 通过指针修改原始变量的值
}

int main() {
    int originalNum = 5;
    referencePass(&originalNum); // 将 originalNum 的地址传递给函数

    printf("Original number: %d\n", originalNum); // 输出 10，已被修改
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

指针传递（Pass by Pointer）示例：

#include <stdio.h>

// 指针传递方式
void pointerPass(int *num) {
    *num = 10; // 通过指针修改原始变量的值
}

int main() {
    int originalNum = 5;
    pointerPass(&originalNum); // 将 originalNum 的地址传递给函数

    printf("Original number: %d\n", originalNum); // 输出 10，已被修改
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这些示例中，可以看到不同的参数传递方式对原始变量的修改效果。值传递会修改函数内部的副本，而引用传递和指针传递可以直接修改原始变量的值。

值传递（Pass by Value）：
C 语言中的值传递： 在 C 语言中，所有参数传递都是按值传递的，即函数接收的是实际参数的副本，对形参的修改不会影响实参。
C++ 中的值传递： 在 C++ 中，也支持值传递。当参数通过值传递时，函数会创建参数的副本，对形参的修改不会影响实参。
引用传递（Pass by Reference）：
C 语言中的引用传递： 在 C 语言中并没有直接支持引用传递，但可以通过指针来模拟引用传递的效果。
C++ 中的引用传递： C++ 提供了引用传递的机制。通过引用传递，函数可以直接操作实参，而不是其副本。这样可以避免产生额外的副本，同时对形参的修改会影响到实参。
指针传递（Pass by Pointer）：
C 语言中的指针传递： 在 C 语言中，可以通过指针传递来修改实参的值。函数接收一个指向变量的指针，可以通过指针修改原始变量的值。
C++ 中的指针传递： C++ 同样支持指针传递。通过传递指针作为参数，函数可以直接修改原始变量的值。
总结：

C 语言中参数传递都是按值传递，可以通过指针来模拟引用传递的效果。
C++ 中支持值传递、引用传递和指针传递，其中引用传递可以让函数直接操作实参，而指针传递则需要使用指针来访问和修改实参的值。
使用引用传递可以避免产生额外的副本，提高效率，并且能够直接修改实参的值。