1200字范文 > c++ vector stack queue map用法总结

c++ vector stack queue map用法总结

时间：2020-04-12 16:41:58

c++ vector、stack、queue、map用法总结

一：vector容器用法总结

参考链接: /qq_36734094/article/details/79748612#commentBox

在c++中，vector是一个十分有用的容器。

作用：它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。

vector在C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。

特别注意：

使用vector需要注意以下几点：

1、如果你要表示的向量长度较长（需要为向量内部保存很多数），容易导致内存泄漏，而且效率会很低；

2、Vector作为函数的参数或者返回值时，需要注意它的写法：

doubleDistance(vector<int>&a,vector<int>&b)其中的“&”绝对不能少！！！

实例：vector<int>test;

//建立一个vector，int为数组元素的数据类型，test为动态数组名

简单的使用方法如下：

vector<int>test;//建立一个vector

test.push_back(1);

test.push_back(2);//把1和2压入vector，这样test[0]就是1,test[1]就是2

自己见到的实例：

vector<vector<Point2f>>points;//定义一个二维数组

points[0].size();//指第一行的列数

1、基本操作

(1)头文件#include<vector>.

(2)创建vector对象，vector<int>vec;

(3)尾部插入数字：vec.push_back(a);

(4)使用下标访问元素，cout<<vec[0]<<endl;记住下标是从0开始的。

(5)使用迭代器访问元素.

vector<int>::iteratorit;

for(it=vec.begin();it!=vec.end();it++)

cout<<*it<<endl;

(6)插入元素：vec.insert(vec.begin()+i,a);在第i+1个元素前面插入a;

(7)删除元素：vec.erase(vec.begin()+2);删除第3个元素

vec.erase(vec.begin()+i,vec.begin()+j);删除区间[i,j-1];区间从0开始

(8)向量大小:vec.size();

(9)清空:vec.clear();

特别提示：C++ STL begin()和front()、end()和back()的区别与用法

(参考链接：/qq_30366449/article/details/77126788)

begin()函数和end()位于iteartor；

而front()和back()位于vector list deque and etc…

- begin()函数

函数原型:

iterator begin();

const_iterator begin();

功能：返回一个当前vector容器中起始元素的迭代器。

end()函数

函数原型：

iterator end();

const_iterator end();

功能：返回一个当前vector容器中末尾元素的迭代器。

front()函数

函数原型：

reference front();

const_reference front();

功能：返回当前vector容器中起始元素的引用。

back()函数

函数原型：

reference back();

const_reference back();

功能：返回当前vector容器中末尾元素的引用。

#include <iostream>

#include <vector>

using namespace std;

int main()

{

vector<char> v1;

vector<char>::iterator iter1;

vector<char>::iterator iter2;

v1.push_back('a');

v1.push_back('b');

v1.push_back('c');

v1.push_back('d');

cout << "v1.front() = " << v1.front() << endl;

cout << "v1.back() = " << v1.back() << endl;

iter1 = v1.begin();

cout << *iter1 << endl;

iter2 = v1.end()-1;

//v1.end()指向的是最后一个元素的下一个位置，所以访问最后一个元素，所以:iter2 = v1.end() - 1 是使iter2指向最后一个元素

cout << *iter2 << endl;

return 0;

}

输出结果为：

v1.front() = a

v1.back() = d

STL中的begin和end定义的是一个半开放区间“[begin, end)”，end是最后一个元素的后一个位置。这样做有两个好处：

1，判断是否到尾部简单只要!=end就行了，<运算在STL中是要避免的，因为计算量可能会比较大。

2，判断空区间很简单begin()==end()要取最后一个元素的话用last()方法。

2、重要说明

vector的元素不仅仅可以是int,double,string,还可以是结构体，但是要注意：结构体要定义为全局的，否则会出错。

[cpp]view plaincopy

#include<stdio.h>#include<algorithm>#include<vector>#include<iostream>usingnamespacestd;typedefstructrect{intid;intlength;intwidth;//对于向量元素是结构体的，可在结构体内部定义比较函数，下面按照id,length,width升序排序。booloperator<(constrect&a)const{if(id!=a.id)returnid<a.id;else{if(length!=a.length)returnlength<a.length;elsereturnwidth<a.width;}}}Rect;intmain(){vector<Rect>vec;Rectrect;rect.id=1;rect.length=2;rect.width=3;vec.push_back(rect);vector<Rect>::iteratorit=vec.begin();cout<<(*it).id<<''<<(*it).length<<''<<(*it).width<<endl;return0;}

3、算法

(1)使用reverse将元素翻转：需要头文件#include<algorithm>

reverse(vec.begin(),vec.end());将元素翻转，即逆序排列！

(在vector中，如果一个函数中需要两个迭代器，一般后一个都不包含)

(2)使用sort排序：需要头文件#include<algorithm>，

sort(vec.begin(),vec.end());(默认是按升序排列,即从小到大).

可以通过重写排序比较函数按照降序比较，如下：

定义排序比较函数：

boolComp(constint&a,constint&b)

{

returna>b;

}

调用时:sort(vec.begin(),vec.end(),Comp)，这样就降序排序。

输出Vector的中的元素

vector<float>vecClass;

intnSize=vecClass.size();

//打印vecClass,方法一：

[cpp]view plaincopy

for(inti=0;i<nSize;i++){cout<<vecClass[i]<<"";}cout<<endl;

需要注意的是：以方法一进行输出时，数组的下表必须保证是整数。

//打印vecClass,方法二：

[cpp]view plaincopy

for(inti=0;i<nSize;i++){cout<<vecClass.at(i)<<"";}cout<<endl;

//打印vecClass,方法三：输出某一指定的数值时不方便

[cpp]view plaincopy

for(vector<float>::iteratorit=vecClass.begin();it!=vecClass.end();it++){cout<<*it<<"";}cout<<endl;

二维数组的使用：

[cpp]view plaincopy

#include"stdafx.h"#include<cv.h>#include<vector>#include<iostream>usingnamespacestd;intmain(){usingnamespacestd;intout[3][2]={1,2,3,4,5,6};vector<int*>v1;v1.push_back(out[0]);v1.push_back(out[1]);v1.push_back(out[2]);cout<<v1[0][0]<<endl;//1cout<<v1[0][1]<<endl;//2cout<<v1[1][0]<<endl;//3cout<<v1[1][1]<<endl;//4cout<<v1[2][0]<<endl;//5cout<<v1[2][1]<<endl;//6return0;}

重要说明：删除vector容器中的对象元素的三种方法:pop_back, erase与remove算法

参考链接：/loveliuzz/article/details/73555588

向量容器的成员函数pop_back()可以删除最后一个元素，而函数erase()可以删除由一个iterator指出的元素，也可以删除一个指定范围的元素。

还可以采用通用算法remove()来删除vector容器中的元素，不同的是，采用remove一般情况下不会改变容器的大小，而pop_back()与erase()等成员函数会改变容器的大小。

#include"stdafx.h"

#include<iostream>

#include<vector>

#include<algorithm>

#include<string>

#include<list>

usingnamespacestd;

voidPrintInt(constint&nData)

{

cout<<nData<<endl;

}

int_tmain(intargc, _TCHAR* argv[])

{

vector<int> vecInt;

for(inti=0; i<10;++i)

{

vecInt.push_back(i);

}

cout<<"向量中的内容为："<<endl;

for_each(vecInt.begin(),vecInt.end(),PrintInt);

cout<<"vector contains "<<vecInt.size()<<" elements"<<endl;

vecInt.pop_back();//删除最后一个元素

cout<<"删除最后一个元素后，vector contains "<<vecInt.size()<<" elements"<<endl;

vector<int>::iterator k = vecInt.begin();

vecInt.erase(k);//删除第一个元素

//vecInt.erase(k); //迭代器k已经失效，会出错

cout<<"删除第一个元素后，vector contains "<<vecInt.size()<<" elements"<<endl;

//vecInt.erase(vecInt.begin(),vecInt.end()); //删除所有元素

//cout<<"删除所有元素后，vector contains "<<vecInt.size()<<"elements"<<endl; //输出为0

vector<int>::iterator vecNewEnd =remove(vecInt.begin(),vecInt.end(),5);//删除元素

cout<<"删除元素后，vector contains "<<vecInt.size()<<" elements"<<endl;

cout<<"向量开始到新结束为止的元素："<<endl;

for_each(vecInt.begin(),vecNewEnd,PrintInt);

cout<<"向量中的元素："<<endl;

for_each(vecInt.begin(),vecInt.end(),PrintInt);

return0;

}

执行结果：

可以看到：remove算法会返回一个指向新的vector的结尾的iterator，从开始到新这个新的结尾（不含新结尾元素）的范围包含了remove操作后剩余的所有元素。还可以看到，删除向量中的元素后，后面的元素都向前移动了。

另外，迭代器用于erase删除元素后，其后会失效，即不能再用该迭代器操作向量。如，例子中的k，当再次用来删除向量的元素后，就会报错。

程序二：

#include<vector>

#include<iostream>

using namespace std;

int main()

{

vector<int> v(3);

v[0]=2; //v[0]是第0个元素

v[1]=7;

v[2]=9;

v.insert(v.begin(),8);//在最前面插入新元素。

v.insert(v.begin()+2,1);//在迭代器中第二个元素前插入新元素

v.insert(v.end(),3);//在向量末尾追加新元素。

v.insert(v.end(),4,1);//在尾部插入4个1

int a[] = {1,2,3,4};

v.insert(v.end(),a[1],a[3]);//在尾部插入a[1]个a[3]

vector<int>::iterator it;

for(it=v.begin(); it!=v.end();it++)

{

cout<<*it<<" ";

}

cout<<endl;

return 0;

}

//8 2 1 7 9 3 1 1 1 1 4 4

//请按任意键继续. . .

参考链接：/u010002184/article/details/77676638

=====================================================================

二：stack用法

参考链接：/qq_42232118/article/details/82080776

stack翻译为栈，时STL中实现的一个后进先出的容器

1、stack的定义

【头文件】

#include<stack>

using namespace;

定义方法与其他容器相同，typename可以任意基本类型数据类型或容器

stack<typename> name;

2、stack容器内元素的访问

由于栈（stack）本身就是一种后进先出的数据结构

在STL的stack中只能通过top()来访问栈顶元素

#include<utility>#include<iostream>#include<stdio.h>#include<string>#include<algorithm>#include<map>#include<vector>#include<stack>using namespace std;int main(){stack<int> st; for(int i=1;i<=5;i++) {st.push(i); } printf("%d\n",st.pop()); return 0;}

3、stack常用函数

①push()

入栈

②top()

获得栈顶元素

③pop()

弹出栈顶元素

④empty()

可以检测stack内是否为空，返回true为空，返回false为非空

⑥size()

返回stack内元素的个数

4、stack的常见用途

stack常用来模拟一些递归，防止程序对栈内存的限制而导致程序出错

一般来说程序的栈内存空间很小，对有些题目来说如果用普通的函数来进行递归，一旦递归层数过深，则会导致程序运行崩溃，如果用栈来模拟递归算法的实现，可以避免这一方面的问题。

1、stack

stack 模板类的定义在<stack>头文件中。

stack 模板类需要两个模板参数，一个是元素类型，一个容器类型，但只有元素类型是必要的，在不指定容器类型时，默认的容器类型为deque。

定义stack 对象的示例代码如下：

stack<int> s1;

stack<string> s2;

stack 的基本操作有：

入栈，如例：s.push(x);

出栈，如例：s.pop();注意，出栈操作只是删除栈顶元素，并不返回该元素。

访问栈顶，如例：s.top()

判断栈空，如例：s.empty()，当栈空时，返回true。

访问栈中的元素个数，如例：s.size()。

====================================================================

三：queue用法：

参考链接：/fengzhizi76506/article/details/54809949

C++队列queue模板类的定义在<queue>头文件中,queue 模板类需要两个模板参数，一个是元素类型，一个容器类型，元素类型是必要的，容器类型是可选的，默认为deque 类型。 C++队列Queue是一种容器适配器，它...

C++队列queue模板类的定义在<queue>头文件中,queue 模板类需要两个模板参数，一个是元素类型，一个容器类型，元素类型是必要的，容器类型是可选的，默认为deque 类型。

C++队列Queue是一种容器适配器，它给予程序员一种先进先出(FIFO)的数据结构。

C++队列Queue类成员函数如下:

back()返回最后一个元素

empty()如果队列空则返回真

front()返回第一个元素

pop()删除第一个元素

push()在末尾加入一个元素

size()返回队列中元素的个数

定义queue 对象的示例代码如下：

queue的基本操作举例如下：

queue入队，如例：q.push(x); 将x 接到队列的末端。

queue出队，如例：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。

访问queue队首元素，如例：q.front()，即最早被压入队列的元素。

访问queue队尾元素，如例：q.back()，即最后被压入队列的元素。

判断queue队列空，如例：q.empty()，当队列空时，返回true。

访问队列中的元素个数，如例：q.size()

C++ stl队列queue示例代码1:

C++ stl队列queue示例代码2:

输出结果：

2、queue

queue 模板类的定义在<queue>头文件中。

与stack 模板类很相似，queue 模板类也需要两个模板参数，一个是元素类型，一个容器类

型，元素类型是必要的，容器类型是可选的，默认为deque 类型。

定义queue 对象的示例代码如下：

queue<int> q1;

queue<double> q2;

queue 的基本操作有：

入队，如例：q.push(x); 将x 接到队列的末端。

出队，如例：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。

访问队首元素，如例：q.front()，即最早被压入队列的元素。

访问队尾元素，如例：q.back()，即最后被压入队列的元素。

判断队列空，如例：q.empty()，当队列空时，返回true。

访问队列中的元素个数，如例：q.size()

=====================================================================

4、map的用法

参考链接：/sevenjoin/article/details/81943864

1，map简介

map是STL的一个关联容器，它提供一对一的hash。

第一个可以称为关键字(key)，每个关键字只能在map中出现一次；

第二个可能称为该关键字的值(value)；

map以模板(泛型)方式实现，可以存储任意类型的数据，包括使用者自定义的数据类型。Map主要用于资料一对一映射(one-to-one)的情況，map內部的实现自建一颗红黑树，这颗树具有对数据自动排序的功能。在map内部所有的数据都是有序的，后边我们会见识到有序的好处。比如一个班级中，每个学生的学号跟他的姓名就存在著一对一映射的关系。

2，map的功能

自动建立key－ value的对应。key 和 value可以是任意你需要的类型。

3，使用map

使用map得包含map类所在的头文件

#include <map>//注意，STL头文件没有扩展名.h

map对象是模板类，需要关键字和存储对象两个模板参数：

std:map<int, string>personnel;

这样就定义了一个用int作为索引,并拥有相关联的指向string的指针.

为了使用方便，可以对模板类进行一下类型定义，

typedefmap<int,CString>UDT_MAP_INT_CSTRING;

UDT_MAP_INT_CSTRING enumMap;

4，map的构造函数

map共提供了6个构造函数，这块涉及到内存分配器这些东西，略过不表，在下面我们将接触到一些map的构造方法，这里要说下的就是，我们通常用如下方法构造一个map：

map<int,string>mapStudent;

5，插入元素

// 定义一个map对象

map<int,string>mapStudent;

// 第一种用insert函數插入pair

mapStudent.insert(pair<int, string>(000, "student_zero"));

// 第二种用insert函数插入value_type数据

mapStudent.insert(map<int, string>::value_type(001, "student_one"));

// 第三种用"array"方式插入

mapStudent[123] = "student_first";

mapStudent[456] = "student_second";

以上三种用法，虽然都可以实现数据的插入，但是它们是有区别的，当然了第一种和第二种在效果上是完成一样的，用insert函数插入数据，在数据的插入上涉及到集合的唯一性这个概念，即当map中有这个关键字时，insert操作是不能在插入数据的，但是用数组方式就不同了，它可以覆盖以前该关键字对应的值，用程序说明如下：

mapStudent.insert(map<int, string>::value_type (001, "student_one"));

mapStudent.insert(map<int, string>::value_type (001, "student_two"));

上面这两条语句执行后，map中001这个关键字对应的值是“student_one”，第二条语句并没有生效，那么这就涉及到我们怎么知道insert语句是否插入成功的问题了，可以用pair来获得是否插入成功，程序如下

// 构造定义，返回一个pair对象

pair<iterator,bool> insert (const value_type& val);

pair<map<int, string>::iterator, bool> Insert_Pair;

Insert_Pair = mapStudent.insert(map<int, string>::value_type (001, "student_one"));

if(!Insert_Pair.second)

cout << ""Error insert new element" << endl;

我们通过pair的第二个变量来知道是否插入成功，它的第一个变量返回的是一个map的迭代器，如果插入成功的话Insert_Pair.second应该是true的，否则为false。

6，查找元素

当所查找的关键key出现时，它返回数据所在对象的位置，如果沒有，返回iter与end函数的值相同。