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

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

一：vector容器用法总结

参考链接: https://blog.csdn.net/qq_36734094/article/details/79748612#commentBox

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

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

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

特别注意：

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

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

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

   double Distance(vector&a, vector&b) 其中的“&”绝对不能少！！！

实例：vectortest;

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

简单的使用方法如下：

vectortest;//建立一个vector

test.push_back(1);

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

自己见到的实例：

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

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

1 、基本操作

(1)头文件#include.

(2)创建vector对象，vector vec;

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

(4)使用下标访问元素，cout<

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

vector::iterator it;

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

    cout<<*it<

(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()的区别与用法

(参考链接：https://blog.csdn.net/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  

#include  

using namespace std; 

int main() 

{ 

    vector v1; 

    vector::iterator iter1; 

    vector::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

a

d

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

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

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

2、重要说明

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

[cpp] view plain copy

1. #include  
2. #include  
3. #include  
4. #include  
5. using namespace std;  
6. typedef struct rect  
7. {  
8.     int id;  
9.     int length;  
10.     int width;  
11. 　　//对于向量元素是结构体的，可在结构体内部定义比较函数，下面按照id,length,width升序排序。  
12. 　　bool operator< (const rect &a)  const  
13.     {  
14.         if(id!=a.id)  
15.             return id
16.         else  
17.         {  
18.             if(length!=a.length)  
19.                 return length
20.             else  
21.                 return width
22.         }  
23.     }  
24. }Rect;  
25. int main()  
26. {  
27.     vector vec;  
28.     Rect rect;  
29.     rect.id=1;  
30.     rect.length=2;  
31.     rect.width=3;  
32.     vec.push_back(rect);  
33.     vector::iterator it=vec.begin();  
34.     cout<<(*it).id<<' '<<(*it).length<<' '<<(*it).width<
35. return 0;  
36. }  
    3、算法

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

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

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

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

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

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

定义排序比较函数：

bool Comp(const int &a,const int &b)
{
    return a>b;
}
调用时:sort(vec.begin(),vec.end(),Comp)，这样就降序排序。 

输出Vector的中的元素   

vector vecClass; 

int nSize = vecClass.size();   

 //打印vecClass,方法一：  

[cpp] view plain copy

1. for(int i=0;i
2. {    
3.    cout<"     ";    
4. }    
5.    cout<
   需要注意的是：以方法一进行输出时，数组的下表必须保证是整数。

 //打印vecClass,方法二：     

[cpp] view plain copy

1. for(int i=0;i
2. {    
3.    cout<"     ";    
4. }    
5.    cout<

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

[cpp] view plain copy

1. for(vector<float>::iterator it = vecClass.begin();it!=vecClass.end();it++)    
2. {    
3.     cout<<*it<<"   ";    
4. }    
5.     cout<

二维数组的使用：

[cpp] view plain copy

1. #include "stdafx.h"  
2. #include   
3. #include    
4. #include    
5. using namespace std;  
6. int main()  
7. {  
8.     using namespace std;  
9.     int out[3][2] = { 1, 2,   
10.              3, 4,  
11.             5, 6 };  
12.     vector <int*> v1;  
13.     v1.push_back(out[0]);  
14.     v1.push_back(out[1]);  
15.     v1.push_back(out[2]);  
16.     cout << v1[0][0] << endl;//1  
17.     cout << v1[0][1] << endl;//2  
18.     cout << v1[1][0] << endl;//3  
19.     cout << v1[1][1] << endl;//4  
20.     cout << v1[2][0] << endl;//5  
21.     cout << v1[2][1] << endl;//6  
22.     return 0;  
23. }  

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

 

参考链接：https://blog.csdn.net/loveliuzz/article/details/73555588

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

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

#include "stdafx.h"

#include 

#include 

#include 

#include 

#include 

using namespace std;

void PrintInt( const int &nData)

{

    cout<

}

int _tmain( int argc, _TCHAR* argv[])

{

    vector< int > vecInt;

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

    {

       vecInt.push_back(i);

    }

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

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

    cout<< "vector contains " <" elements" <

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

    cout<< " 删除最后一个元素后，vector contains " <" elements" <

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

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

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

    cout<< " 删除第一个元素后，vector contains " <" elements" <

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

    //cout<<" 删除所有元素后，vector contains "< 输出为0

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

    cout<< " 删除元素后，vector contains " <" elements"<

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

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

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

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

    return 0;

}

执行结果：

 

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

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

程序二：

#include 

#include 

using namespace std; 

 

int main() 

{ 

    vector 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::iterator it; 

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

    { 

        cout<<*it<<" "; 

    } 

    cout<

    return 0;

}   

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

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

参考链接：https://blog.csdn.net/u010002184/article/details/77676638

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

二：stack用法

参考链接：https://blog.csdn.net/qq_42232118/article/details/82080776

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

1、stack的定义

【头文件】

#include

using namespace;

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

stack name;

2、stack容器内元素的访问

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

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

1. #include
2. #include
3. #include
4. #include
5. #include
6. #include
7. #include
8. #include
9. using namespace std;
10. int main()
11. {
12.     stack<int> st;
13.     for(int i=1;i<=5;i++)
14.     {
15.         st.push(i);
16.     }
17.     printf("%d\n",st.pop());
18.     return 0;
19. }

3、stack常用函数

①push()

入栈

②top()

获得栈顶元素

③pop()

弹出栈顶元素

1. #include
2. #include
3. #include
4. #include
5. #include
6. #include
7. #include
8. #include
9. using namespace std;
10. int main()
11. {
12.     stack<int> st;
13.     for(int i=1;i<=5;i++)
14.     {
15.         st.push(i);
16.     }
17.     for(int i=1;i<=3;i++)
18.     {
19.         st.top();
20.         st.pop();
21.     printf("%d\n",st.top());
22.  
23.     }
24.     return 0;
25. }

④empty()

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

⑥size()

返回stack内元素的个数

4、stack的常见用途

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

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

1、stack

stack 模板类的定义在头文件中。
stack 模板类需要两个模板参数，一个是元素类型，一个容器类型，但只有元素类型是必要的，在不指定容器类型时，默认的容器类型为deque。
定义stack 对象的示例代码如下：
stack s1;
stack s2;
stack 的基本操作有：
入栈，如例：s.push(x);
出栈，如例：s.pop();注意，出栈操作只是删除栈顶元素，并不返回该元素。
访问栈顶，如例：s.top()
判断栈空，如例：s.empty()，当栈空时，返回true。
访问栈中的元素个数，如例：s.size()。

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

三：queue用法：

参考链接：https://blog.csdn.net/fengzhizi76506/article/details/54809949

 

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

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

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

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

back() 返回最后一个元素

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

front() 返回第一个元素

pop() 删除第一个元素

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

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

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

1 2	queue q1;   queue q2;

    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:

#include  #include  #include  using namespace std; int main() {     int e,n,m;     queue q1;     for(int i=0;i<10;i++)        q1.push(i);     if(!q1.empty())     cout<<"dui lie  bu kong\n";     n=q1.size();     cout<     m=q1.back();     cout<     for(int j=0;j     {        e=q1.front();        cout<        q1.pop();     }     cout<     if(q1.empty())     cout<<"dui lie  bu kong\n";     system("PAUSE");     return 0; }

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

#include  #include  #include  /* 调用的时候要有头文件： #include 或 #include + #include       #include 详细用法: 定义一个queue的变量     queue M 查看是否为空范例        M.empty()    是的话返回1，不是返回0; 从已有元素后面增加元素   M.push() 输出现有元素的个数      M.size() 显示第一个元素          M.front() 显示最后一个元素        M.back() 清除第一个元素          M.pop() */ using namespace std; int _tmain(int argc, _TCHAR* argv[]) { queue  myQ; cout<< "现在 queue 是否 empty? "<< myQ.empty() << endl;  for(int i =0; i<10 ; i++) { myQ.push(i); } for(int i=0; i { printf("myQ.size():%d\n",myQ.size()); cout << myQ.front()< myQ.pop(); } system("PAUSE");  return 0; }

 输出结果：

现在 queue 是否 empty? 1 myQ.size():10 0 myQ.size():9 1 myQ.size():8 2 myQ.size():7 3 myQ.size():6 4 请按任意键继续. . .

2、queue

queue 模板类的定义在头文件中。
与stack 模板类很相似，queue 模板类也需要两个模板参数，一个是元素类型，一个容器类
型，元素类型是必要的，容器类型是可选的，默认为deque 类型。
定义queue 对象的示例代码如下：
queue q1;
queue q2;

queue 的基本操作有：
入队，如例：q.push(x); 将x 接到队列的末端。
出队，如例：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。
访问队首元素，如例：q.front()，即最早被压入队列的元素。
访问队尾元素，如例：q.back()，即最后被压入队列的元素。
判断队列空，如例：q.empty()，当队列空时，返回true。
访问队列中的元素个数，如例：q.size()

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

4、map的用法

参考链接：https://blog.csdn.net/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对象是模板类，需要关键字和存储对象两个模板参数：

std:map personnel;

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

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

typedef map UDT_MAP_INT_CSTRING;

UDT_MAP_INT_CSTRING enumMap;

4，map的构造函数

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

map mapStudent;

5，插入元素

// 定义一个map对象

map mapStudent;

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

mapStudent.insert(pair(000, "student_zero"));

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

mapStudent.insert(map::value_type(001, "student_one"));

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

mapStudent[123] = "student_first";

mapStudent[456] = "student_second";

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

mapStudent.insert(map::value_type (001, "student_one"));

mapStudent.insert(map::value_type (001, "student_two"));

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

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

pair insert (const value_type& val);

pair::iterator, bool> Insert_Pair;

Insert_Pair = mapStudent.insert(map::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函数的值相同。

// find 返回迭代器指向当前查找元素的位置否则返回map::end()位置

iter = mapStudent.find("123");

if(iter != mapStudent.end())

       cout<<"Find, the value is"<second<

else

   cout<<"Do not Find"<

7， 刪除与清空元素

//迭代器刪除

iter = mapStudent.find("123");

mapStudent.erase(iter);

//用关键字刪除

int n = mapStudent.erase("123"); //如果刪除了會返回1，否則返回0

//用迭代器范围刪除 : 把整个map清空

mapStudent.erase(mapStudent.begin(), mapStudent.end());

//等同于mapStudent.clear()

8，map的大小

在往map里面插入了数据，我们怎么知道当前已经插入了多少数据呢，可以用size函数，用法如下：

int nSize = mapStudent.size();

 9，map的基本操作函数：

     C++ maps是一种关联式容器，包含“关键字/值”对

     begin()         返回指向map头部的迭代器

     clear(）        删除所有元素

     count()         返回指定元素出现的次数

     empty()         如果map为空则返回true

     end()           返回指向map末尾的迭代器

     equal_range()   返回特殊条目的迭代器对

     erase()         删除一个元素

     find()          查找一个元素

     get_allocator() 返回map的配置器

     insert()        插入元素

     key_comp()      返回比较元素key的函数

     lower_bound()   返回键值>=给定元素的第一个位置

     max_size()      返回可以容纳的最大元素个数

     rbegin()        返回一个指向map尾部的逆向迭代器

     rend()          返回一个指向map头部的逆向迭代器

     size()          返回map中元素的个数

     swap()           交换两个map

     upper_bound()    返回键值>给定元素的第一个位置

     value_comp()     返回比较元素value的函数