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

 

 

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

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

更多推荐

沃云统一开发平台介绍

沃云集成平台研发平台介绍1.平台优势2.平台原理3.研发平台使用方法4.遇到的问题5.现阶段实现的功能6.后续需要补充的功能和优化内容研发平台介绍1.平台优势解决孤岛式应用，实现能力共享；现有系统框架过于复杂，跨系统业务处理成本居高不下，协同服务共享，降低运维成本；提高项目应用资源监控能力，改善资源利用率；业务微服务化，快速发布、快速部署，快速响应业务需求变化；沃云平台不仅提供了自动化的、可快速部

avatar 云原生

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

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

avatar 云原生

基于docker的test-containers环境百宝箱

笔者语录： 我开了个公众号【Java你我他】，欢迎大家关注。  在很多时候，程序猿们更关注代码本身，而不愿意把时间花费在环境搭建上，这也是Docker变得越来越受欢迎的原因之一。test-containe是Docker生态圈中的一颗新星，其 主要针对测试领域、背靠Docker实现环境百宝箱功能。  test-containers： 你要的环境，我都有~  假设我们现在需要一个redis-clust

avatar 云原生