c++ 函数之间传递向量_将向量传递给C ++中的函数

川长思鸟来 2023-03-05 12:44 14阅读 0赞

c++ 函数之间 传递向量

Passing an argument can be of two types generally:

传递参数通常可以分为两种类型：

1.  Pass by value
    
    传递价值
2.  Pass by reference
    
    通过参考

In the case of passing a vector as a parameter in any function of C++, the things are not different. We can pass a vector either by value or by reference.

在C ++的任何函数中将向量作为参数传递的情况下，情况没有什么不同。 我们可以通过值或引用来传递向量。

In the following section, we will discuss when we should use what kind of passing and what's difference b/w them.

在下一节中，我们将讨论何时应该使用哪种传递方式以及它们之间的区别。

## 1)通过值传递向量 **(**1) Passing a vector by value**)** ##

Below is an example of **passing the vector by value**. In the below example, we have tried to figure out that if we pass a vector by value, whether local changes in the function reflects the original vector in main or not.

下面是**通过值传递向量**的示例。 在下面的示例中，我们试图弄清楚，如果我们按值传递向量，则函数中的局部更改是否会反映main中的原始向量。

Let's see the example first, then we will detail what happened and why.

首先让我们看一下示例，然后我们将详细说明发生了什么以及为什么。

#include <bits/stdc++.h>
    using namespace std;
    
    void print(vector<int> arr)
    { //paseed by value
    
        //printing the vector which has been passed
        cout << "In the print function...\n";
    
        cout << "Printing the array that has been passed by value\n";
        for (auto i : arr)
            cout << i << " ";
        cout << endl;
    
        cout << "changes made in array...\n";
        for (int i = 0; i < arr.size(); i++)
            arr[i] = i + arr[i];
    
        cout << "printing after making the changes\n";
        for (auto i : arr)
            cout << i << " ";
        cout << endl;
    }
    
    int main()
    {
        //initialize the vector with size 5 and element 1
        vector<int> a(5, 1);
    
        //to print we will use function
        print(a);
    
        //again print here to check
        //whether the change made in print is 
        //reflecting here or not
        cout << "printing in main\n";
        for (auto it : a) {
            cout << it << " ";
        }
        cout << endl;
    
        cout << "change not reflected\n";
    
        return 0;
    }

**Output:**

**输出：**

In the print function...
    Printing the array that has been passed by value
    1 1 1 1 1
    changes made in array...
    printing after making the changes
    1 2 3 4 5
    printing in main
    1 1 1 1 1
    change not reflected

So, we found that the changes we made in the print function is not reflected in the main. It's similar to other datatypes for the call by value.

因此，我们发现我们在打印功能中所做的更改未反映在主体中。 与按值调用的其他数据类型相似。

**What happens when we pass the vector by value?**

**当我们按值传递向量时会发生什么？**

When we pass the vector into the function by value then it simply makes a deep copy of the vector to a new location and the function operates on the new copy of the vector. That's why the changes made are not reflected back to the main vector as it's a deep copy.

当我们按值将向量传递给函数时，它仅将向量的深层副本复制到新位置，然后函数对向量的新副本进行操作。 这就是为什么所做的更改不会复制回主向量的原因，因为它是深拷贝。

Also, since it copies the vector, thus it's time-consuming.

另外，由于它复制矢量，因此很费时间。

**When we should pass by value?**

**什么时候应该传递价值？**

When we need to ensure that the function that operates on the vector argument makes changes but that shouldn't interfere with the original vector then we must use pass by value. To details when we need to keep our original vector unchanged throughout the function execution we can pass by value. The vector remains unmodified till the end.

当我们需要确保对vector参数进行操作的函数进行更改，但不应干扰原始矢量时，则必须使用按值传递。 要详细说明何时需要在函数执行过程中保持原始矢量不变，我们可以按值传递。 载体直到最后都保持不变。

## 2)通过参考传递矢量 **(**2) Pass a vector by reference**)** ##

Below is an example of passing the vector by reference. In the below example, we have tried to figure out that if we pass a vector by reference, whether local changes in the function reflects back to the original vector in main or not.

下面是通过引用传递矢量的示例。 在下面的示例中，我们试图弄清楚，如果通过引用传递向量，则函数中的局部更改是否会反射回main中的原始向量。

Let's see the example first, then we will detail what happened and why.

首先让我们看一下示例，然后我们将详细说明发生了什么以及为什么。

#include <bits/stdc++.h>
    using namespace std;
    
    void print(vector<int>& arr)
    { //passed by reference
    
        //printing the vector which has been passed
        cout << "In the print function...\n";
    
        cout << "Printing the array that has been passed by reference\n";
        for (auto i : arr)
            cout << i << " ";
        cout << endl;
    
        cout << "changes made in array...\n";
        for (int i = 0; i < arr.size(); i++)
            arr[i] = i + arr[i];
    
        cout << "printing after making the changes\n";
        for (auto i : arr)
            cout << i << " ";
        cout << endl;
    }
    
    int main()
    {
        //initialize the vector with size 5 and element 1
        vector<int> a(5, 1);
    
        //to print we will use function
        print(a);
    
        //again print here to check
        //whether the change made in print is 
        //reflecting here or not
        cout << "printing in main\n";
        for (auto it : a) {
            cout << it << " ";
        }
        cout << endl;
    
        cout << "change is reflected\n";
    
        return 0;
    }

**Output:**

**输出：**

In the print function...
    Printing the array that has been passed by reference
    1 1 1 1 1
    changes made in array...
    printing after making the changes
    1 2 3 4 5
    printing in main
    1 2 3 4 5
    change is reflected

So we found that the changes we made in the print function is reflected in the main. It's similar to other datatypes for the call by reference.

因此，我们发现在打印功能中所做的更改反映在主体中。 通过引用进行调用与其他数据类型相似。

**What happens when we pass the vector by reference?**

**当我们通过引用传递矢量时会发生什么？**

When we pass the vector into the function by reference then it doesn't make any new copy of the vector, rather the function operates on the same the vector, same memory location.

当我们通过引用将向量传递给函数时，它不会产生向量的任何新副本，而是函数在相同的向量，相同的内存位置上运行。

That is what passing reference means. It simply means the same copy is passed. That's why the changes made in the printf function is reflected back to the main vector.

那就是通过参考的意思。 这只是意味着传递了相同的副本。 这就是为什么在printf函数中所做的更改会反映回主向量的原因。

Also, since it doesn't make any new copy it's faster.

另外，由于它不会产生任何新副本，因此速度更快。

**When we should pass by reference?**  
When we need the vector to be modified by the function, we have to pass the vector by reference. Otherwise, changes made in the function won't be reflected.

**什么时候应该通过引用？**  
当我们需要通过函数修改矢量时，必须通过引用传递矢量。 否则，将不会反映在函数中所做的更改。

Below is the detailed use cases about when we should pass the vector by value and when we should pass the vector by reference.

以下是有关何时应该按值传递向量以及何时应按引用传递向量的详细用例。

1.  Vector needs to be modified via function: pass by reference
    
    向量需要通过函数进行修改：通过引用传递
2.  Vector can't be modified via function, but there is some modification operation in the function: pass by value
    
    向量无法通过函数进行修改，但是函数中存在一些修改操作：按值传递
3.  Function not doing any kind of modification: either pass by value or pass by reference. But pass by reference is a better option since it's faster.
    
    函数未做任何修改：按值传递或按引用传递。 但是通过引用传递是一个更好的选择，因为它更快。

> 翻译自: [https://www.includehelp.com/stl/passing-vector-to-a-function-in-cpp.aspx][https_www.includehelp.com_stl_passing-vector-to-a-function-in-cpp.aspx]

c++ 函数之间 传递向量

[https_www.includehelp.com_stl_passing-vector-to-a-function-in-cpp.aspx]: https://www.includehelp.com/stl/passing-vector-to-a-function-in-cpp.aspx