【STL】Vector和List的深拷贝浅拷贝问题

STL容器共性机制STL容器所提供的都是值（value）寓意，而非引用（reference）寓意，也就是说当我们给容器中插入元素的时候，容器内部实施了拷贝动作，将我们要插入的元素在另行拷贝一份放入到容器中，而不是将原数据直接放入到容器中，也就是说我们提供的元素必须能够被拷贝（自己写的指针的话，就需要自己写一个拷贝构造函数；如果是一个类，会调用拷贝构造函数※）。1.除了Queue和Stack之外，每

Emiiya

7048人浏览 · 2020-05-29 17:45:47

Emiiya · 2020-05-29 17:45:47 发布

STL容器共性机制

STL容器所提供的都是值（value）寓意，而非引用（reference）寓意，也就是说当我们给容器中插入元素的时候，容器内部实施了拷贝动作，将我们要插入的元素在另行拷贝一份放入到容器中，而不是将原数据直接放入到容器中，也就是说我们提供的元素必须能够被拷贝（自己写的指针的话，就需要自己写一个拷贝构造函数；如果是一个类，会调用拷贝构造函数※）。

1.除了Queue和Stack之外，每个容器都提供可返回迭代器的函数，运用返回的迭代器就可以访问元素

2.通常STL不会抛出异常，需要使用传入正确的参数

3.每个容器都提供了一个默认的构造函数和默认的拷贝构造函数

4.大小相关的构造方法：1.size（）返回容器中元素的个数 2.empty（）判断容器是否为空。

Vector的push_back问题：

如果发生扩容，会拷贝就元素到扩容后的里面，然后析构原有元素

参考：STL-vector

此时如果有浅拷贝发生，会出现析构问题！

流程：

https://blog.csdn.net/u012501459/article/details/44132147

https://zohead.com/archives/vector-push-back-space-copy/

#include <iostream>
#include <vector>
#include <list>

using namespace std;

class Base {
public:
    Base(vector<int> vec,list<int> list):m_vec(vec),m_list(list){};
    ~Base(){
     cout<<"destroy class"<<endl;
    };
    Base(const Base& base)
    {
    m_list = base.m_list;
    m_vec = base.m_vec;
    cout<<"copy class"<<endl;
    };
private:
    vector<int> m_vec;
    list<int> m_list;
};

int main()
{
vector<int> vec1 (5,0);
list<int> list1(3,1);
Base base1(vec1,list1);
Base base2(vec1,list1);

cout<<"push_back list:"<<endl;
list<Base> m_listGroup;
m_listGroup.push_back(base1);
m_listGroup.push_back(base2);

cout<<"push_back vector:"<<endl;
vector<Base> m_vectGroup;
m_vectGroup.push_back(base1);
m_vectGroup.push_back(base2);
cout<<"end test"<<endl;
}

push_back list:
copy class
copy class
push_back vector:
copy class
copy class
copy class
destroy class
end test
destroy class
destroy class
destroy class
destroy class
destroy class
destroy class

结果分析

vector 每次调用 push_back 时都会拷贝一个新的参数指定的 sss 类对象，这会调用 sss 的拷贝构造函数，第一次的 copy 正常，而且 vector 的实际容量也由 0 变为 1。

第二次调用 push_back，通过输出会发现调用了两次拷贝构造函数，一次析构函数，原来 vector 此时判断容量不够，将容量扩大为原来的两倍，变为 2，并将原来的元素再次拷贝一份存放到新的内存空间，然后拷贝新加的类对象，最后再释放原来的元素。

第三次调用 push_back 时，vector 自动扩大为4，因此拷贝构造函数调用了3次，析构函数调用了2次，程序最终退出了时就析构了 5 次加本身的 sss 类对象一共 6 次。

1.拷贝本身是深拷贝

#include <vector>
#include <iostream>
 
using namespace std;
 
typedef struct point{
	int x;
	int y;
}Point;
 
 
 
ostream& operator<<(ostream& output, const Point &a)
{
	return output << a.x <<" "<< a.y;
}
 
int main(){
 
	Point * a = new Point;
	vector<Point> PointList;
 
 
	a->x = 3;
	a->y = 4;
	PointList.push_back(*a);
 
	a->x = 4;
	a->y = 4;
	PointList.push_back(*a);
	
	a->x = 5;
	a->y = 4;
	PointList.push_back(*a);
 
	delete a;
 
	for (vector<Point>::iterator i = PointList.begin(); i != PointList.end(); i++){
		cout << (*i)<< endl;
	}
 
	return 0;
}

这说明完成的不是将a的地址加入到vector，而是将数据整个拷贝了一份加入进去

2.如果用类（如Point类）构造的容器来说如果有new/malloc分配的空间，要重写复制构造函数才不会出问题。（因为默认复制构造函数为浅拷贝）

#include<iostream>
#include<vector>
using namespace std;
 
//深拷贝和浅拷贝的问题
#if 0
class Person
{
public:
	Person(const char* name,int age)
	{
		this->pName = new char[strlen(name) + 1];		//开辟内存
		strcpy(this->pName, name);						//值拷贝
		this->pAge = age;
	}
 
	//只写上面的会出现程序宕掉,原因是出现了两次析构
	//解决办法，写一个拷贝构造
	Person(const Person& p)
	{
		this->pName = new char[strlen(p.pName) + 1];
		strcpy(this->pName, p.pName);
		this->pAge = p.pAge;
	}
	//重载等号
	Person& operator=(const Person& p)
	{
		//先释放空间，然后在拷贝
		if (this->pName != NULL)
		{
			delete[] this->pName;
		}
 
		this->pName = new char[strlen(p.pName) + 1];
		strcpy(this->pName, p.pName);
		this->pAge = p.pAge;
 
		return *this;
	}
	~Person()
	{
		if (this->pName != NULL)
		{
			delete[] this->pName;
		}
	}
public:
	char* pName;			//指针
	int pAge;
};
 
void test01()
{
	Person p("aaa", 21);
	vector<Person> vPerson;
	vPerson.push_back(p);
}
 
#endif
 
class Person2
{
public:
	Person2(char* s)
	{
		pStr = s;
	}
	Person2() {}
	/*Person2& operator=(const Person2 p)
	{
		pStr = p.pStr;
		return *this;
	}*/
	Person2& operator=(const Person2& p)
	{
		if (strlen(pStr) != strlen(p.pStr))
			pStr = new char[strlen(p.pStr) + 1]; //为被赋值对象申请了一个新的内存
		/*if (*this != p)
			strcmp(p.pStr, p.pStr);*/
		return *this;
	}
public:
	char* pStr;
};
 
void test02()
{
	Person2 p2("aaa"),p3;     //上面不加const这里报错，加了const后上面的=报错
	p3 = p2;
	cout << p2.pStr << endl;
	cout << p3.pStr << endl;
}
 
int main()
{
	//test01();
	test02();
 
	system("pause");
	return 0;
}

作为函数参数和返回值

读取vector内的元素，如果赋值给其他变量，是将对象复制一份新的。

Item ii  = list[0];

如果直接操作数组元素，是不会产生对象复制的

list[0].a

1.std::vector 作为参数传入

是值传递，vector本身，及vector内的所有元素都会复制一遍。

得不偿失，可以使用引用传递。

c++中常用的vector容器作为参数时，有三种传参方式，分别如下（为说明问题，用二维vector）：

function1(std::vector<std::vector<int> > vec)，传值
function2(std::vector<std::vector<int> >& vec)，传引用
function3(std::vector<std::vector<int> >* vec)，传指针

注意，三种方式分别有对应的const形式，不在此讨论。

三种方式对应的调用形式分别为：

function1(vec)，传入值
function2(vec)，传入引用
function3(&vec),传入地址

三种方式的效果分别为：

会发生拷贝构造
不会发生拷贝构造
不会发生拷贝构造

2.std::vector作为函数返回值

不会创建新vector对象的。函数内返回的跟接收返回值的是一个对象。

读取vector内的元素，如果赋值给其他变量，是将对象复制一份新的。

#include <stdlib.h>
#include <stdio.h>
#include <vector>
 
class Item{
    public:
    int a;
    int b;
};
 
std::vector<Item> vectorTestFunc(std::vector<Item> input){
 
printf("vectorTestFunc >>> in %p   %p, %p\n",&input,  &input[0], &input[0].a);
    Item item = input[0];
 
    std::vector<Item> output;
    output.push_back(item);
    printf("vectorTestFunc <<< in %p    %p, %p\n",&output, &output[0], &output[0].a);
    return output;
}
int main(int argc, char* argv[]){
     std::vector<Item> list;
    Item i;
    i.a = 1;
    i.b =2;
    printf("i adr is %p, %p\n",&i, &i.a);
    list.push_back(i);
    printf("list[0] adr is %p, %p\n",&list[0], &list[0].a);
    
    Item ii  = list[0];
    printf(" ii  adr is %p, %p\n",&ii, &ii.a);
 
 
 
    printf("vectorTestFunc in  %p %p, %p\n",&list, &list[0], &list[0].a);
    std::vector<Item> output = vectorTestFunc(list);
 
    printf("vectorTestFunc output  %p %p, %p\n",&output, &output[0], &output[0].a);
    return 0;
}

build$ make; ./main
Scanning dependencies of target main
[ 50%] Building CXX object CMakeFiles/main.dir/main.cpp.o
[100%] Linking CXX executable main
[100%] Built target main
i adr is 0x7ffc5a16b160, 0x7ffc5a16b160
list[0] adr is 0x5583c3b0f280, 0x5583c3b0f280
ii  adr is 0x7ffc5a16b168, 0x7ffc5a16b168
vectorTestFunc in  0x7ffc5a16b170 0x5583c3b0f280, 0x5583c3b0f280
vectorTestFunc >>> in 0x7ffc5a16b1b0   0x5583c3b0f2a0, 0x5583c3b0f2a0
vectorTestFunc <<< in 0x7ffc5a16b190    0x5583c3b0f2c0, 0x5583c3b0f2c0
vectorTestFunc output  0x7ffc5a16b190 0x5583c3b0f2c0, 0x5583c3b0f2c0

如果把函数参数改成引用：

build$ make; ./main
Scanning dependencies of target main
[ 50%] Building CXX object CMakeFiles/main.dir/main.cpp.o
[100%] Linking CXX executable main
[100%] Built target main
i adr is 0x7ffe81b1cf40, 0x7ffe81b1cf40
list[0] adr is 0x5641c6771280, 0x5641c6771280
 ii  adr is 0x7ffe81b1cf48, 0x7ffe81b1cf48
vectorTestFunc in  0x7ffe81b1cf50 0x5641c6771280, 0x5641c6771280
vectorTestFunc >>> in 0x7ffe81b1cf50   0x5641c6771280, 0x5641c6771280
vectorTestFunc <<< in 0x7ffe81b1cf70    0x5641c67712a0, 0x5641c67712a0
vectorTestFunc output  0x7ffe81b1cf70 0x5641c67712a0, 0x5641c67712a0

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...

云原生

所有评论(0)

查看更多评论

Emiiya

@woalss

已为社区贡献1条内容