容器vector与迭代器

1.知识点

2.源程序

#include <iostream>
#include <tchar.h>

#include <vector> 
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
	//1.vector对象的默认构造
	//vector采用模板类实现，vector对象的默认构造形式：vector<T> vecT
	vector<int> vectA;

	//2.演示vector末尾的添加移除操作：
	cout << "2.演示vector末尾的添加移除操作：\n";
	//2.1 vector末尾的添加操作
	vectA.push_back(1);
	vectA.push_back(3);
	vectA.push_back(5);
	vectA.push_back(7);
	vectA.push_back(9);

	//vector可以随机存取元素（支持索引值直接存取,用[]操作符或at()方法)
	for (size_t i = 0; i < vectA.size(); i++)
	{
		cout << vectA[i] << " ";
	}
	cout << "\n\n";

	//2.2 vector末尾的移除操作
	vectA.pop_back();
	for (size_t i = 0; i < vectA.size(); i++)
	{
		cout << vectA[i] << " ";//法一
	}
	cout << "\n";

	vectA.pop_back();
	for (size_t i = 0; i < vectA.size(); i++)
	{
		cout << vectA.at(i) << " ";//法二
	}
	cout << "\n\n";
	
	//3.演示vector的数据存取：
	cout << "3.演示vector的数据存取：\n";
	//3.1常规方法
	for (size_t i = 0; i < vectA.size(); i++)
	{
		cout << "vectA["<<i<<"] = "<< vectA.at(i) << "\n";
	}
	cout << "\n";
	vectA[1] = 155;
	vectA.at(2) = 99;
	for (size_t i = 0; i < vectA.size(); i++)
	{
		cout << "vectA[" << i << "] = " << vectA.at(i) << "\n";
	}
	cout << "\n";

	//3.2利用vector方法返回第一个数据和最后一个数据
	int iFront, iBack;
	iFront = vectA.front();
	iBack = vectA.back();
	cout << "iFront = " << iFront << endl;
	cout << "iBack = " << iBack << endl << endl;

	//3.3利用vector方法修改第一个数据和最后一个数据
	int iFront2, iBack2;
	vectA.front() = 1111;
	vectA.back() = 2222;
	iFront2 = vectA.front();
	iBack2 = vectA.back();
	cout << "iFront2 = " << iFront2 << endl;
	cout << "iBack2 = " << iBack2 << endl << endl;
	for (size_t i = 0; i < vectA.size(); i++)
	{
		cout << "vectA[" << i << "] = " << vectA.at(i) << "\n";
	}
	cout << "\n";

	//3.4如果vector是字符型的类呢？——一样的道理
	vector<char> vectB;
	vectB.push_back('A');
	vectB.push_back('B');
	vectB.push_back('C');
	vectB.push_back('D');
	
	for (size_t i = 0; i < vectB.size(); i++)
	{
		cout << "vectB[" << i << "] = " << vectB.at(i) << "\n";
	}
	cout << "\n";
	char cFront, cBack;
	cFront = vectB.front();
	cBack = vectB.back();
	cout << "cFront = " << cFront << endl;
	cout << "cBack = " << cBack << endl << endl;

	//4.演示vector与迭代器的配合使用
	cout << "4.演示vector与迭代器的配合使用：\n";
	//vector对象的默认构造
	vector<int> vectC;
	vectC.push_back(1);
	vectC.push_back(3);
	vectC.push_back(5);
	vectC.push_back(7);
	vectC.push_back(9);
	
	vector<int>::iterator it;//声明容器vector<int>的迭代器
	it = vectC.begin();//vectC.begin()用来返回容器中第一个元素的迭代器

	//遍历vectC的元素
	for (size_t i = 0; i < vectC.size(); i++)
	{
		cout << "vectC[" << i << "] = " << vectC.at(i) << "\n";
	}
	cout << "\n";

	//4.1利用迭代器获取容器vector的对象vectC的元素的值
	cout << "4.1利用迭代器获取容器vector的对象vectA的元素的值\n";
	cout << "刚开始 *it = " << *it << endl;
	++it;
	cout << "后来啊 *it = " << *it << endl << endl;

	cout << "刚开始 *it = " << *it << endl;
	it = it + 2;
	cout << "后来啊 *it = " << *it << endl << endl;

	//此时再次遍历vectC的元素，看看的元素的值变了没有——没有，因为没有修改元素的值，只是取值
	for (size_t i = 0; i < vectC.size(); i++)
	{
		cout << "vectC[" << i << "] = " << vectC.at(i) << "\n";
	}
	cout << "\n";

	//4.2利用迭代器修改容器vector的对象vectA的元素的值
	cout << "4.2利用迭代器修改容器vector的对象vectA的元素的值\n";
	it = vectC.begin();//上面对迭代器进行了移动，此处将它归位,vectC.begin()用来返回容器中第一个元素的迭代器
	*it = *it + 1000;
	it = it + 2;
	*it = *it - 1000;

	//此时再次遍历vectC的元素，看看修改的元素的值变了没有——变了
	for (size_t i = 0; i < vectC.size(); i++)
	{
		cout << "vectC[" << i << "] = " << vectC.at(i) << "\n";
	}
	cout << "\n\n";

	//4.3利用迭代器遍历容器
	cout << "4.3利用迭代器遍历容器\n";
	for (it = vectC.begin(); it != vectC.end(); ++it)
	   //vectC.begin()用来返回容器中第一个元素的迭代器
	   //vectC.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";

	//4.4利用反向迭代器遍历容器
	vector<int>::reverse_iterator r_it;//声明容器vector<int>的反向迭代器
	cout << "4.4利用反向迭代器遍历容器\n";
	for (r_it = vectC.rbegin(); r_it != vectC.rend(); ++r_it)
		//vectC.rbegin()用来返回容器中倒数第一个元素的迭代器
		//vectC.rend()用来返回容器中倒数最后一个元素之后的迭代器
	{
		cout << *r_it << " ";
	}
	cout << "\n\n";

	//5.vector对象的带参数构造
	cout << "5.vector对象的带参数构造：\n";
	//5.1 vector对象的带参数构造 vector(beg,end)
	//构造函数将[beg,end）区间中的元素拷贝给自身。注意该区间是左闭右开的区间
	cout << "5.1 vector对象的带参数构造 vector(beg,end)：\n";
	int iArray[] = { 0,1,2,3,4 };
	vector<int> vecIntA(iArray, iArray + 5);
	vector<int> vecIntB(vecIntA.begin(), vecIntA.end()); //用构造函数初始化容器vecIntB

	//利用迭代器遍历容器
	for (vector<int>::iterator it = vecIntA.begin(); it != vecIntA.end(); ++it)
		//vecIntA.begin()用来返回容器中第一个元素的迭代器
		//vecIntA.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";
	for (vector<int>::iterator it = vecIntB.begin(); it != vecIntB.end(); ++it)
		//vecIntB.begin()用来返回容器中第一个元素的迭代器
		//vecIntB.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";

	//5.2 vector对象的带参数构造 vector(n,elem)
	//构造函数将n个elem拷贝给自身
	cout << "5.2 vector对象的带参数构造 vector(n,elem)：\n";
	vector<int> vecIntC(3, 9);//此代码运行后，容器vecIntC就存放3个元素，每个元素的值是9

	//利用迭代器遍历容器
	for (vector<int>::iterator it = vecIntC.begin(); it != vecIntC.end(); ++it)
		//vectC.begin()用来返回容器中第一个元素的迭代器
		//vectC.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";

	//5.3 vector对象的带参数构造 vector(const vector& vec)
	//拷贝构造函数
	cout << "5.3 vector对象的带参数构造 vector(const vector& vec)：\n";
	vector<int> vecIntD(vecIntA);

	//利用迭代器遍历容器
	for (vector<int>::iterator it = vecIntD.begin(); it != vecIntD.end(); ++it)
		//vecIntD.begin()用来返回容器中第一个元素的迭代器
		//vecIntD.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";
	
	//6.vector的赋值
	cout << "6.vector的赋值：\n";
	//6.1 vector.assign(beg,end)
	//将[beg, end)区间中的数据拷贝赋值给本身。注意该区间是左闭右开的区间。
	cout << "6.1 vector.assign(beg,end)：\n";
	int iArray2[] = { 0,1,2,3,4 };
	vector<int> vecIntA2(iArray2, iArray2 + 5);
	vector<int> vecIntB2;
	vecIntB2.assign(vecIntA2.begin(), vecIntA2.end());

	//利用迭代器遍历容器
	for (vector<int>::iterator it = vecIntA2.begin(); it != vecIntA2.end(); ++it)
		//vecIntA2.begin()用来返回容器中第一个元素的迭代器
		//vecIntA2.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";
	for (vector<int>::iterator it = vecIntB2.begin(); it != vecIntB2.end(); ++it)
		//vecIntB2.begin()用来返回容器中第一个元素的迭代器
		//vecIntB2.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";

	//6.2 vector.assign(n,elem)
	//将n个elem拷贝赋值给本身
	cout << "6.2 vector.assign(n, elem)：\n";
	vector<int> vecIntC2;
	vecIntC2.assign(3, 9);

	//利用迭代器遍历容器
	for (vector<int>::iterator it = vecIntC2.begin(); it != vecIntC2.end(); ++it)
		//vectC2.begin()用来返回容器中第一个元素的迭代器
		//vectC2.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";

	//6.3 vector& operator = (const vector &vec)
	//重载等号操作符
	cout << "6.3 vector& operator = (const vector &vec)：\n";
	vector<int> vecIntD2;
	vecIntD2 = vecIntC2;

	//利用迭代器遍历容器
	for (vector<int>::iterator it = vecIntD2.begin(); it != vecIntD2.end(); ++it)
		//vectD2.begin()用来返回容器中第一个元素的迭代器
		//vectD2.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";

	//6.4 vector.swap(vec)
	//将vec与本身的元素互换。
	cout << "6.4 vector.swap(vec)：\n";
	vector<int> vecIntE2;
	vecIntE2.push_back(1);
	vecIntE2.push_back(3);
	vecIntE2.push_back(5);
	vecIntE2.push_back(7);
	vecIntE2.push_back(9);

	vector<int> vecIntF2;
	vecIntF2.push_back(10);
	vecIntF2.push_back(30);
	vecIntF2.push_back(50);
	vecIntF2.push_back(70);
	vecIntF2.push_back(90);

	//利用迭代器遍历容器
	cout << "交换前vecIntE2：\n";
	for (vector<int>::iterator it = vecIntE2.begin(); it != vecIntE2.end(); ++it)
		//vectE2.begin()用来返回容器中第一个元素的迭代器
		//vectE2.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n";
	cout << "交换前vecIntF2：\n";
	for (vector<int>::iterator it = vecIntF2.begin(); it != vecIntF2.end(); ++it)
		//vectF2.begin()用来返回容器中第一个元素的迭代器
		//vectF2.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";

	//开始交换
	vecIntE2.swap(vecIntF2);

	//利用迭代器遍历容器
	cout << "交换后vecIntE2：\n";
	for (vector<int>::iterator it = vecIntE2.begin(); it != vecIntE2.end(); ++it)
		//vectE2.begin()用来返回容器中第一个元素的迭代器
		//vectE2.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n";
	cout << "交换后vecIntF2：\n";
	for (vector<int>::iterator it = vecIntF2.begin(); it != vecIntF2.end(); ++it)
		//vectF2.begin()用来返回容器中第一个元素的迭代器
		//vectF2.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";


	// 7.vector的大小
	cout << "7.vector的大小：\n";
	vector<int> vecIntG;
	vecIntG.push_back(1);
	vecIntG.push_back(2);
	vecIntG.push_back(3);
	
	//利用迭代器遍历容器
	cout << "vecIntG刚开始包含的元素：\n";
	for (vector<int>::iterator it = vecIntG.begin(); it != vecIntG.end(); ++it)
		//vecIntG.begin()用来返回容器中第一个元素的迭代器
		//vecIntG.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";

	//7.1 vector.size();返回容器中元素的个数
	cout << "7.1 vector.size();返回容器中元素的个数：\n";

	int Count1 = vecIntG.size();

	cout << "vecIntG刚开始包含的元素个数是：" << Count1 << endl << endl;
	
	//7.2 vector.empty();判断容器是否为空
	cout << "7.2 vector.empty();判断容器是否为空：\n";

	bool bool_vecIntG = vecIntG.empty();

	if(bool_vecIntG == true)
		cout << "vecIntG为空\n";
	else
		cout << "vecIntG不为空\n";
	cout << "\n";


	//7.3 vector.resize(num);
	//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
	cout << "7.3 vector.resize(num);：\n";

	vecIntG.resize(5);

	for (vector<int>::iterator it = vecIntG.begin(); it != vecIntG.end(); ++it)
		//vecIntG.begin()用来返回容器中第一个元素的迭代器
		//vecIntG.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";

	//7.4 vector.resize(num,elem);
	//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
	cout << "7.4 vector.resize(num,elem);：\n";

	vecIntG.resize(8,3);

	for (vector<int>::iterator it = vecIntG.begin(); it != vecIntG.end(); ++it)
		//vecIntG.begin()用来返回容器中第一个元素的迭代器
		//vecIntG.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";


	// 8.vector的插入
	cout << "8.vector的插入：\n";
	vector<int> vecIntH;//{1, 3, 5, 7, 9}
	vector<int> vecIntJ;//{2, 4, 6, 8}

	vecIntH.push_back(1);
	vecIntH.push_back(3);
	vecIntH.push_back(5);
	vecIntH.push_back(7);
	vecIntH.push_back(9);

	vecIntJ.push_back(2);
	vecIntJ.push_back(4);
	vecIntJ.push_back(6);
	vecIntJ.push_back(8);

	//8.1 vector.insert(pos,elem);
	//在pos位置插入一个elem元素的拷贝，返回新数据的位置。
	cout << "8.1 vector.insert(pos,elem);：\n";

	vecIntH.insert(vecIntH.begin(), 11);//{11, 1, 3, 5, 7, 9}

	for(vector<int>::iterator it = vecIntH.begin(); it != vecIntH.end(); ++it)
		//vecIntH.begin()用来返回容器中第一个元素的迭代器
		//vecIntH.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";

	//8.2 vector.insert(pos,n,elem);
	//在pos位置插入n个elem数据，无返回值。
	cout << "8.2 vector.insert(pos,n,elem);：\n";

	vecIntH.insert(vecIntH.begin() + 1, 2, 33); //{11, 33, 33, 1, 3, 5, 7, 9}

	for(vector<int>::iterator it = vecIntH.begin(); it != vecIntH.end(); ++it)
		//vecIntH.begin()用来返回容器中第一个元素的迭代器
		//vecIntH.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";
	
	//8.3 vector.insert(pos,beg,end);
	//在pos位置插入[beg,end)区间的数据，无返回值。
	cout << "8.3 vector.insert(pos,beg,end);：\n";

	vecIntH.insert(vecIntH.begin(), vecIntJ.begin(), vecIntJ.end());//{2, 4, 6, 8, 11, 33, 33, 1, 3, 5, 7, 9}

	for(vector<int>::iterator it = vecIntH.begin(); it != vecIntH.end(); ++it)
		//vecIntH.begin()用来返回容器中第一个元素的迭代器
		//vecIntH.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";

	// 9.vector的删除
	cout << "9.vector的删除：\n";
	vector<int> vecIntL;//{1, 3, 5, 7, 9, 11, 13, 15, 15, 15, 15, 17, 19}
	
	vecIntL.push_back(1);
	vecIntL.push_back(3);
	vecIntL.push_back(5);
	vecIntL.push_back(7);
	vecIntL.push_back(9);
	vecIntL.push_back(11);
	vecIntL.push_back(13);
	vecIntL.push_back(15);
	vecIntL.push_back(15);
	vecIntL.push_back(15);
	vecIntL.push_back(15);
	vecIntL.push_back(17);
	vecIntL.push_back(19);

	cout << "vecIntL初始数据：\n";
	for (vector<int>::iterator it = vecIntL.begin(); it != vecIntL.end(); ++it)
		//vecIntL.begin()用来返回容器中第一个元素的迭代器
		//vecIntL.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";

	//9.1 vector.erase(pos);
	//删除pos位置的数据，返回值是一个迭代器，指向删除元素下一个元素;
	cout << "9.1 vector.erase(pos);：\n";

	vecIntL.erase(vecIntL.begin() + 1);//删除vecIntL第一个元素3，返回一个迭代器，指向下一个元素5的位置
	
	cout << "vecIntL现在的数据：\n";//{1, 5, 7, 9, 11, 13, 15, 15, 15, 15, 17, 19}
	for (vector<int>::iterator it = vecIntL.begin(); it != vecIntL.end(); ++it)
		//vecIntL.begin()用来返回容器中第一个元素的迭代器
		//vecIntL.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";

	//9.2 vector.erase(beg,end);
	//删除[beg,end)区间的数据，返回下一个数据的位置。注意区间是左闭右开
	cout << "9.2 vector.erase(beg,end);：\n";

	vector<int>::iterator iter1 = vecIntL.erase(vecIntL.begin(), vecIntL.begin() + 3);
	//删除vecIntL第0个元素1到第2个元素7，返回一个迭代器，指向第3个元素9的位置
	
	cout << "此时*iter1的值是: " << *iter1 << endl;

	cout << "vecIntL现在的数据：\n";//{9, 11, 13, 15, 15, 15, 15, 17, 19}
	for (vector<int>::iterator it = vecIntL.begin(); it != vecIntL.end(); ++it)
		//vecIntL.begin()用来返回容器中第一个元素的迭代器
		//vecIntL.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";

	//9.3 删除容器中所有等于15的元素;
	cout << "9.3 删除容器中所有等于15的元素：\n";

	for (vector<int>::iterator it = vecIntL.begin(); it != vecIntL.end(); )//小括号里不要写++it
		//vecIntL.begin()用来返回容器中第一个元素的迭代器
		//vecIntL.end()用来返回容器中最后一个元素之后的迭代器
	{
		if (*it == 15)
		{
			it = vecIntL.erase(it);//以迭代器为参数，删除元素3，并把删除数据的下一个元素位置返回给迭代器
			//此时，不执行 ++it，因为 iterator vector::erase()返回值是一个迭代器，指向删除元素的下一个元素;
		}
		else
		{
			++it;
		}
	}

	cout << "vecIntL现在的数据：\n";//{9, 11, 13, 17, 19}
	for (vector<int>::iterator it = vecIntL.begin(); it != vecIntL.end(); ++it)
		//vecIntL.begin()用来返回容器中第一个元素的迭代器
		//vecIntL.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "\n\n";
	
	//9.4 void vector.clear();
	//移除容器的所有数据
	cout << "9.4 void vector.clear();：\n";
	cout << "vecIntL大小：" << vecIntL.size() << endl;

	vecIntL.clear();

	cout << "vecIntL现在的数据：\n";
	for (vector<int>::iterator it = vecIntL.begin(); it != vecIntL.end(); ++it)
		//vecIntL.begin()用来返回容器中第一个元素的迭代器
		//vecIntL.end()用来返回容器中最后一个元素之后的迭代器
	{
		cout << *it << " ";
	}
	cout << "vecIntL现在大小：" << vecIntL.size() << endl;
	cout << "\n\n";

	return 0;
}

3.运行结果

4.官方参考文档