【C++】容器对象作为函数参数传递时，如何保证外部容器对象不被修改（以vector为例）

已于 2023-07-25 21:40:32 修改
阅读量1.1k 收藏 16
点赞数 5
文章标签： c++ 开发语言
于 2023-07-25 21:27:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pang_Yue__Fairy/article/details/131924288
版权

几种传参方式简单对比

  1. 传值
    1.1 参数形式：void fun(vector<int> v);
    1.2 函数调用：fun(v);
    1.3 函数内使用：cout << v[1];
    1.4 是否可以改变函数外对象的值：否
    1.5 是否会调用拷贝构造函数：是
  2. 传指针
    2.1 参数形式：void fun(vector<int>* p);
    2.2 函数调用：fun(&v);
    2.3 函数内使用：cout << (*p)[1];
    2.4 是否可以改变函数外对象的值：是
    2.5 是否会调用拷贝构造函数：否
  3. const+传指针
    3.1 参数形式：void fun(const vector<int>* p);
    3.2 函数调用：fun(&v);
    3.3 函数内使用：cout << (*p)[1];
    3.4 是否可以改变函数外对象的值：否
    3.5 是否会调用拷贝构造函数：否
  4. 传引用
    4.1 参数形式：void fun(vector<int>& v);
    4.2 函数调用：fun(v);
    4.3 函数内使用：cout << v[1];
    4.4 是否可以改变函数外对象的值：是
    4.5 是否会调用拷贝构造函数：否
  5. const+传引用
    5.1 参数形式：void fun(const vector<int>& v);
    5.2 函数调用：fun(v);
    5.3 函数内使用：cout << v[1];
    5.4 是否可以改变函数外对象的值：否
    5.5 是否会调用拷贝构造函数：否

结合代码对比

下面，我们来探讨，各种方式是否会修改到函数外部的v。
如果会，那我就把它定性为一种有风险的行为。如果不会，我就把它定性为一种安全的行为。

一、传值

#include <iostream>
#include<vector>

void changeValue(std::vector<int> v) {
    //修改v里面的值
    v[0] = 2;
    std::cout << "修改值之后的第一个元素(函数内): " << v[0] << std::endl;
}
void changeReference(std::vector<int> v) {
    //修改v的指向
    std::vector<int> c;
    c.push_back(3);
    v = c;
    std::cout << "修改指向之后的第一个元素(函数内): " << v[0] << std::endl;
}


int main()
{
    std::vector<int> v;
    v.push_back(1);
    std::cout << "原本的第一个元素: " << v[0] << std::endl;
    changeValue(v);
    std::cout << "修改值后的第一个元素(函数外): " << v[0] << std::endl;
    v[0] = 1;
    std::cout << "\n原本的第一个元素: " << v[0] << std::endl;
    changeReference(v);
    std::cout << "修改指向之后的第一个元素(函数外): " << v[0] << std::endl;
}

在这里插入图片描述
可见，传值的话，如果在函数内修改了v的值或者指向，函数外的v也不会受到任何影响。因此是一种安全的行为。

二、传指针

#include <iostream>
#include<vector>

void changeValue(std::vector<int>* p) {
    //修改v里面的值
    (*p)[0] = 2;
    std::cout << "修改值之后的第一个元素(函数内): " << (*p)[0] << std::endl;
}
void changeReferenced(std::vector<int>* p) {
    //修改v的指向的指向
    std::vector<int> c;
    c.push_back(3);
    p = &c;
    std::cout << "修改指向之后的第一个元素(函数内): " << (*p)[0] << std::endl;
}
void changeReferencedReference(std::vector<int>* p) {
    //修改v的指向
    std::vector<int> c;
    c.push_back(3);
    *p = c;
    std::cout << "修改指向的对象的指向之后的第一个元素(函数内): " << (*p)[0] << std::endl;
}


int main()
{
    std::vector<int> v;
    v.push_back(1);
    std::cout << "原本的第一个元素: " << v[0] << std::endl;
    changeValue(&v);
    std::cout << "修改值后的第一个元素(函数外): " << v[0] << std::endl;
    v[0] = 1;
    std::cout << "\n原本的第一个元素: " << v[0] << std::endl;
    changeReferenced(&v);
    std::cout << "修改指向之后的第一个元素(函数外): " << v[0] << std::endl;
    v[0] = 1;
    std::cout << "\n原本的第一个元素: " << v[0] << std::endl;
    changeReferencedReference(&v);
    std::cout << "修改指向的对象的指向之后的第一个元素(函数外): " << v[0] << std::endl;
}

在这里插入图片描述

  • 由changeValue的结果可见，传指针的话，如果在函数内修改了p对应的元素的值，函数外的v会受到一样的影响；
  • 由changeReferenced的结果可见，如果在函数内修改了p的指向，则函数外的v不会受到任何影响，因为此时的p已经不再关联外部的v了。
  • 然而，由changeReferencedReference的结果可见，如果不是修改p的指向，而是修改了p指向的对象的指向，那么结果就会相反，此时函数外的v也会受到一样影响！
  • 所有，传递指针，是有影响到外部的v的风险的，是一种有风险的行为。

三、const+传指针

#include <iostream>
#include<vector>

void changeValue(const std::vector<int>* p) {
    //修改v里面的值
    (*p)[0] = 2;
    std::cout << "修改值之后的第一个元素(函数内): " << (*p)[0] << std::endl;
}
void changeReferenced(const std::vector<int>* p) {
    //修改v的指向
    std::vector<int> c;
    c.push_back(3);
    p = &c;
    std::cout << "修改指向之后的第一个元素(函数内): " << (*p)[0] << std::endl;
}
void changeReferencedReference(const std::vector<int>* p) {
    //修改v的指向的指向
    std::vector<int> c;
    c.push_back(3);
    *p = c;
    std::cout << "修改指向的对象的指向之后的第一个元素(函数内): " << (*p)[0] << std::endl;
}


int main()
{
    std::vector<int> v;
    v.push_back(1);
    std::cout << "原本的第一个元素: " << v[0] << std::endl;
    changeValue(&v);
    std::cout << "修改值后的第一个元素(函数外): " << v[0] << std::endl;
    v[0] = 1;
    std::cout << "\n原本的第一个元素: " << v[0] << std::endl;
    changeReferenced(&v);
    std::cout << "修改指向之后的第一个元素(函数外): " << v[0] << std::endl;
    v[0] = 1;
    std::cout << "\n原本的第一个元素: " << v[0] << std::endl;
    changeReferencedReference(&v);
    std::cout << "修改指向的对象的指向之后的第一个元素(函数外): " << v[0] << std::endl;
}

在这里插入图片描述

  • 由图可知，我们无法修改p指向的容器的值，也无法修改p指向的容器的指向，因此这两种情况都不会导致外部的v被改变。
  • 但是，我们此时可以修改p的指向，那么我们有没有可能改变函数外的v呢。由上一条实验三我们知道，修改了p的指向之后，并不会影响到外部的v，因为此时p已经脱离了和v的关联了。所以修改p的指向，是不会影响到外部的v的风险的。
  • 综上，const+传指针的方式，是不会影响到外部的v的，是一种安全的行为。

四、传引用

#include <iostream>
#include<vector>

void changeValue(std::vector<int>& v) {
    //修改v里面的值
    v[0] = 2;
    std::cout << "修改值之后的第一个元素(函数内): " << v[0] << std::endl;
}
void changeReference(std::vector<int>& v) {
    //修改v的指向
    std::vector<int> c;
    c.push_back(3);
    v = c;
    std::cout << "修改指向之后的第一个元素(函数内): " << v[0] << std::endl;
}


int main()
{
    std::vector<int> v;
    v.push_back(1);
    std::cout << "原本的第一个元素: " << v[0] << std::endl;
    changeValue(v);
    std::cout << "修改值后的第一个元素(函数外): " << v[0] << std::endl;
    v[0] = 1;
    std::cout << "\n原本的第一个元素: " << v[0] << std::endl;
    changeReference(v);
    std::cout << "修改指向之后的第一个元素(函数外): " << v[0] << std::endl;
}

在这里插入图片描述
可见，传引用的话，如果在函数内修改了v的值或者指向，函数外的v也会受到一样的影响。因此是一种有风险的行为。

五、const+传引用

#include <iostream>
#include<vector>

void changeValue(const std::vector<int>& v) {
    //修改v里面的值
    v[0] = 2;
    std::cout << "修改值之后的第一个元素(函数内): " << v[0] << std::endl;
}
void changeReference(const std::vector<int>& v) {
    //修改v的指向
    std::vector<int> c;
    c.push_back(3);
    v = c;
    std::cout << "修改指向之后的第一个元素(函数内): " << v[0] << std::endl;
}


int main()
{
    std::vector<int> v;
    v.push_back(1);
    std::cout << "原本的第一个元素: " << v[0] << std::endl;
    changeValue(v);
    std::cout << "修改值后的第一个元素(函数外): " << v[0] << std::endl;
    v[0] = 1;
    std::cout << "\n原本的第一个元素: " << v[0] << std::endl;
    changeReference(v);
    std::cout << "修改指向之后的第一个元素(函数外): " << v[0] << std::endl;
}

在这里插入图片描述
如图，由于const，我们无法修改v的元素的值，也无法修改v的指向。所以我们不会改变到函数外的v。也是一种安全的行为。

总结
如果我们想要安全（不修改函数外的v的值），只有以下三种方式：

  1. 传值
  2. const+传指针
  3. const+传引用。
  • 这几种方法中，如果从是否调用拷贝构造函数的角度考虑，应该选择 const+指针 ，或者const+引用因为他们是不调用拷贝构造函数的。
  • 但是如果从书写的方便性来说，应该选择 传值 和 const+传引用 这两种方式，他们比const+传指针要更加便于书写，因为这两者只需要用v就可以代表传进来的vector对象，而const+传指针需要用(*p)的方式来代表，多了一个*，而且有时候还要加括号()，防止优先级有问题，比如要用[ ]取值的时候，必须写成类似(*p)[0]，而不能是*p[0]这样的。
  • 实际使用中，似乎更多人用 const+传引用 。

const+引用是否调用拷贝构造函数

文章 C++（笔记）容器(vector)作为函数参数如何传参 中却认为，const+传引用会调用拷贝构造函数。我认为这应该是错误的。因为大多数其他的文章都认为， const+传引用不会调用拷贝构造函数**。如 C++拷贝构造函数（复制构造函数）详解、C++ 中的 const & （常引用）参数 、C++ 基础之 “引用形参” 和 “利用const引用避免复制” & 等等。所以还是服从多数，const+引用不会调用拷贝构造函数。这也是它相比于直接传值的重要优势。

不调用拷贝构造函数的好处

具体可以学习C++拷贝构造函数（复制构造函数）详解这一篇文章。
我总结一下，好处可能有两个：

  1. 可以减少空间开销。
  2. 可以避免在类中定义了一个不好的拷贝构造函数，从而导致了形参和实参不一致。

补充：使用 const+引用/指针 比单独使用 引用/指针 作为参数的好处

  1. 更加安全。这一点毋庸置疑。加了const以后，不管是指针还是引用都不用担心更改到外部的对象的内容。
  2. 使得函数可以接受常量对象作为参数。除此之外，还有一个很重要的，就是，哪怕你在函数内仔细控制，保证不会修改引用/指针指向的外部对象，也建议加一个const。那是因为，这样就可以向函数传递常量对象，而直接使用 引用/指针 作为参数的话，是无法向函数传递常量对象的。（这里我还是参考了C++拷贝构造函数（复制构造函数）详解这篇文章，虽然文章里只是对拷贝构造函数的参数写法进行的建议，但是我认为道理其实是通用的）

如下，如果我使用 vector<int>& v作为参数（没有加const），那么我是无法传递一个常量vector对象进去的。
在这里插入图片描述
然而，如果我使用了 const vector<int>& v作为参数（加了const），我就可以传递一个常量vector对象。

#include <iostream>
#include<vector>

void printValue(const std::vector<int>& v) {
    std::cout << v[0];
}

int main()
{
    const std::vector<int> v = { 1, 2, 3 };
    printValue(v);
}

在这里插入图片描述
可以接受常量对象的话，整个函数的可用性会更加强。

参考链接

C++拷贝构造函数（复制构造函数）详解
C++中vector作为参数的三种传参方式（传值 && 传引用 && 传指针）
C++ 中的 const & （常引用）参数
C++ 基础之 “引用形参” 和 “利用const引用避免复制” &
C++（笔记）容器(vector)作为函数参数如何传参 （疑似有误）

pycmy
关注
  • 5
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c c++函数手册.rar
06-10
3. 函数对象（Functors）：C++允许自定义类型作为函数的参数，这种类型通常定义了操作符()，可以像函数一样被调用。 4. 嵌套函数与匿名函数（Lambda表达式）：C++11引入的特性，嵌套函数可以在其外部函数的范围内...
vector作为参数的三种传参方式
T-dreaming博客
10-29 7731
vector作为参数的三种传参方式 c++中常用的vector容器作为参数时，有三种传参方式，分别如下（为说明问题，用二维vector）： function1(std::vector&lt;std::vector&lt;int&gt; &gt; vec)，传值 function2(std::vector&lt;std::vector&lt;int&gt; &gt;&amp; vec)，传引...
vector做函数参数和普通数组做函数参数有什么区别
weixin_43410753的博客
09-05 2108
数组做函数参数
C/C++ vector详解
2301_77087344的博客
05-20 1279
C/C++初始识：向量，顺序表，是一个类模板，顺序容器。
【C++】容器vector作为函数参数，容器vector作为函数返回值，容器的使用，容器的遍历，容器的赋值，将数组的值赋给容器
Elon_Zac的博客
11-15 3314
容器vectorC++中在函数的定义与调用时，通常会遇到一组数或者几组数作为参数传递和返回值，初学者会使用数组，但是在定义数组时需要确定数组大小，并且返回值需要使用动态数组，很多不方便的地方，这里我们使用容器作为传递和返回值可以避免这一问题。容器是一个模板类，它用于存放各种类型的数据，如基本类型的变量或者对象等，C++中的容器就是存储对象的一种介质，容器最最重要的优点就是可以自己动态扩展自己的大小；容器的类型分为三大类：顺序性容器，关联式容器和容器适配器。容器的遍历，将数组的值赋给容器，容器与容器相互赋值。
C++（笔记）容器(vector)作为函数参数如何传参
热门推荐
浅然的专栏
05-17 10万+
一、大致以下类型 void 函数名( vector< int> obj ); void 函数名( vector< int>* pobj ); void 函数名( const vector< int>* pobj ); // 在函数内不能改变 pobj 指向的对象 ,//调用时不会调用拷贝构造函数 void 函数名( vector< int>& obj ); void
vector作为参数的三种传递方式
卖瓜小农的博客
04-22 5965
vector作为参数的三种传递方式 c++中常用的vector容器作为参数时，有三种传参方式，分别如下（为说明问题，用二维vector）： function1(std::vector<std::vector > vec)，传值 function2(std::vector<std::vector >& vec)，传引用 function3(std::vector&l...
现代C++函数编程模式
06-27
现代C++函数编程模式是C++11及后续版本引入的一种增强编程范式的特性，它使得C++在传统的面向对象编程之外，增加了函数式编程的能力。这种编程风格强调使用不可变数据、高阶函数和惰性计算，尤其适用于处理多线程...
2.1.1 C++和C#数据传递 -常用类型数组和List类型传递
最新发布
06-23
数组在C++中被视为对象，因此当作为参数传递时，实际上是传递了数组的首地址，也就是指针。这意味着，当你在函数内部改变数组元素的值时，这些更改会影响到原始数组。例如： ```cpp void changeArray(int arr[]) { ...
每天学点C++（C++实例教程：教程+源码）Lambda匿名函数.zip
06-21
它可以在运行时定义，并且可以作为参数传递给其他函数或存储在容器中。Lambda表达式的语法如下： ```cpp [capture_list](parameter_list) -> return_type { function_body } ``` 1. **Capture List**（捕获列表）...
《C++习题答案》（配清华大学 谭浩强版面向对象的程序设计）
08-16
首先，C++是一种强大的、通用的编程语言，以其面向对象特性而闻名。面向对象编程（OOP）的核心概念包括类（class）、对象（object）、封装（encapsulation）、继承（inheritance）和多态性（polymorphism）。谭浩强...
c++中vector做形参传递的三种形式
zou_albert的博客
08-25 1万+
c++中常用的vector容器作为参数时，有三种传参方式，分别如下（为说明问题，用二维vector）： function1(std::vector<std::vector > vec)，传值 function2(std::vector<std::vector >& vec)，传引用 function3(std::vector<std::vector >* vec)，传指针 三种方式对应的调用形式分别为： function1(vec)，传入值 functio
c++ 函数vector传参
h799710的博客
08-04 9771
vector和数组不一样，数组本身和指针差不多，所以传进去的就是一个指针。但是vector并不如此 vector传参的三种方式： void func1(vector vet); //传送数值 void func2(vector &vet); //引用 void func3(vector *vet); //指针 这三种方式产生的效果： 调用拷贝构造函数，形参改变不会影响到实参 不调用拷贝构函数，形参改变影响到实参 不调用拷贝构函数，形参改变影响到实参 如： void func1(.
C++中STL vector总结
u011486738的博客
09-01 1202
本文主要从vector的基础用法、vector作为函数返回值、vector作为函数参数三个方面进行介绍，有任何不当之处，欢迎指教。 一、vector基础用法 vector是C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组...
C++-STL-vector：vector作为函数参数、返回值
u013250861的博客
11-30 1028
【代码】C++-STL-vector：vector作为函数参数、返回值。
C++中vector作为参数的三种传参方式（传值 && 传引用 && 传指针）
code进击者
03-01 2万+
c++中常用的vector容器作为参数时，有三种传参方式，分别如下： function1(vector&lt;int&gt; vec)，传值 function2(vector&lt;int&gt; &amp;vec)，传引用 function3(vector&lt;int&gt; *vec)，传指针 注意，三种方式分别有对应的const形式，不在此讨论。 三种方式对应的调用形式分别为...
Vector作为参数的三种传参方式
wuha391的博客
11-01 7631
转载：Vector作为参数的三种传参方式 c++中常用的vector容器作为参数时，有三种传参方式，分别如下（为说明问题，用二维vector）： function1(std::vectorstd::vectorint> > vec)，传值function2(std::vectorstd::vectorint> >& vec)，传引用function3(std::vectorst
容器vector对象能不能做函数参数
06-03
是的，vector对象可以作为函数参数传递。在函数定义时，可以将vector对象作为参数类型进行声明。例如： ```c++ void printVector(vector<int> v) { for (int i = 0; i < v.size(); i++) { cout << v[i] << " "; } cout << endl; } ``` 上述函数的参数类型为`vector<int>`，表示接收一个整数类型的vector对象。在函数内部，可以使用该vector对象进行相应的操作，例如输出其中的元素。当在主函数中调用该函数时，可以将一个vector对象作为参数传递进去，例如： ```c++ int main() { vector<int> v = {1, 2, 3, 4, 5}; printVector(v); return 0; } ``` 上述代码将一个包含1到5的整数vector对象作为参数传递给了`printVector`函数，该函数输出了该vector对象中的所有元素。需要注意的是，在函数调用时，将vector对象作为参数传递时，会进行复制操作。因此，如果传递的vector对象比较大，可能会导致性能问题。在这种情况下，我们可以使用引用或指针的方式进行传递，可以减少复制操作，提高性能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值