关于vector的用法

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<vector>
using namespace std;

class PtrInt
{
	int* ptr;
public:
	PtrInt(int x = 0) :ptr(new int[x])
	{
		cout << "Create PtrInt：" << endl;
	}
	PtrInt(const PtrInt& pt) :ptr(new int())
	{
		if (pt.ptr!=nullptr)
		{
			*ptr = *pt.ptr;
		}
		cout << "Copy Create：" << endl;
	}
	PtrInt& operator=(const PtrInt& pt)
	{
		if (this != &pt)
		{
			delete ptr;
			ptr = new int();
			if (pt.ptr != nullptr)
			{
				*ptr = *pt.ptr;
			}
			cout << "operator=()" << endl;
		}
	}
	PtrInt(PtrInt&& pt) :ptr(pt.ptr)
	{
		pt.ptr = nullptr;
		cout << "move create" << endl;
	}
	PtrInt& operator=(PtrInt&& pt)
	{
		if (this != &pt)
		{
			delete ptr;
			ptr = pt.ptr;
			pt.ptr = nullptr;
		}
		cout << "move operator=()" << endl;
	}
	~PtrInt()
	{
		delete ptr;
		ptr = nullptr;
		cout << "Destory PtrInt" << endl;
	}
	void Print()const
	{
		if (ptr != nullptr)
		{
			cout << *ptr << endl;
		}
	}
	void SetValue(int x)
	{
		if (ptr = nullptr)
		{
			*ptr = x;
		}
		else
		{
			ptr = new int(x);
		}
	}
	int GetValue()const
	{
		if (ptr != nullptr)
		{
			return *ptr;
		}
		else
		{
			return -1;
		}
	}
};

int main()
{
	std::vector<PtrInt>ar;
	for (int i = 0; i < 20; ++i)
	{
		ar.push_back(PtrInt(i));//构建无名对象
		cout << "Size:" << ar.size() << endl;;
		cout << "capacity" << ar.capacity() << endl;
	}
}

#if 0
class Int
{
private:
	int value;
public:
	Int(int x=0):value(x){}
	~Int(){}
};

int main()
{
	std::vector<int>iar = {12,23,34,45,56,67,78,89};
	std::vector<double>dar;
	std::vector<int*>par;//最好不要存放指针，因为new开辟空间，一定不要忘记析构
	std::vector<int>::reverse_iterator rit = iar.rbegin(); //逆向迭代器

	int n = iar.size();
	int* p = iar.data();
}
#endif

运行结果分析：
在这里插入图片描述

容量按照1.5倍增加，容量增容意味着要不断的创建空间，并且不断调用移动构造函数，和不断将对象析构，效率太低，可以直接调用reserve

int main()
{
	std::vector<PtrInt>ar;
	ar.reserve(200); //先预留200个空间，效率提高，只申请空间，不创建对象
	ar.resize(200); //改变存储元素的个数,直接创建200个对象，并且容量为200
	for (int i = 0; i < 20; ++i)
	{
		ar.push_back(PtrInt(i));//构建无名对象
		cout << "Size:" << ar.size() << endl;;
		cout << "capacity" << ar.capacity() << endl;
	}
}

迭代器失效，指针指向的对象已经被释放掉

int main()
{
	std::vector<PtrInt>ar;
	ar.push_back(PtrInt(1));
	ar.push_back(PtrInt(2)); 
	ar.push_back(PtrInt(3));
	ar.push_back(PtrInt(4));
	ar.push_back(PtrInt(5));

	std::vector<PtrInt>::iterator it = ar.begin();
	ar.insert(it, PtrInt(6));  //调用移动赋值函数

	for (auto x: ar)
	{
		x.Print();
	}
	ar.pop_back();
	ar.erase(it); //迭代器失效，迭代器面向对象的指针
}

vector作为数组，如何使效率变高？（提前获取vector的大小，预留好空间）

关于List的用法

在相同的空间中，vector的存储密度比List的存储密度大

int main()
{
	std::list<PtrInt>arlist;
	for (int i = 0; i < 5; i++)
	{
		//arlist.push_back(PtrInt(i));
		arlist.emplace_back(i);
	}

	for (auto& x : arlist)  //尽量使用引用，因为使用引用不需要调动拷贝构造
	{
		x.Print();
	}
}

出现内存泄漏的情况

int main()
{
	std::list<PtrInt*>arlist;
	for (int i = 0; i < 5; ++i)
	{
		arlist.push_back(new PtrInt(i));
	}
	for (auto& x : arlist)
	{
		x->Print();  //无法调用析构函数去析构PtrInt
	}
	return 0;
}

在这里插入图片描述

解决方案（智能指针）

int main()
{
	std::list<std::unique_ptr<PtrInt>>arlist;
	for (int i = 0; i < 10; ++i)
	{
		arlist.push_back(std::unique_ptr<PtrInt>(new PtrInt(i))); //智能指针，防止内存泄漏
	}
	for (auto& x : arlist)
	{
		x->Print();
	}
	return 0;
}