• C++ 语言学习 day09 STL vector list map set queue

    1.标准模板库
         定义：标注模板库 惠普实验室开发的一些列统称
         组成部分：
             容器：特殊的数据机构用来存放数据。
             迭代器：用来遍历，底层是一些列的指针组成。用来通过迭代器操作容器
             算法：多容器的算法操作，排序，查找等操作
             空间配置器：管理模块类
             配接器： 仿函数：  对象( 参数)
             组件的关系：各个部分组成的关系
    容器：容器是用来存放数据的，和数据结构中的队列 双向链表栈!

    2..vector--- 动态数组
          连点： 顺序存放 ，可以改变数组大小，数组在尾部添加和移除数据非常快，但是在中间或者头部添加删除数据就比较慢了。
          可以不指定大小，直接使用
         构造： 无参构造： vector<类型> 对象；
                    有参构造：vector（size_t n，T x）;  用n个x构建数组。
                                      vector v(2,10);
                     拷贝构造 ：vector（const T& X）;
                                         vector x(v);

         迭代器：iterator 是一种可以变量容器元素的数据类型（理解成内部类）。可以理解成容器和操作容器算法的中间。
          begin（）   迭代器执行容器的首位置  
          end（）       迭代器执行容器的尾位置下一个
         迭代器定义格式： vector::iterator  it = arr.begin（）；


         成员函数：
         size()  ---  获取vector的元素个数
                          案例：vec.size() 一般用于for循环中
         clear(); 清空vector中的内容，size变成0，capacity不会变
         empty(); 判断vector是否为空，如果为空则结果为真
         insert(迭代器位置，值)：在某一个位置插入值，底层会把所有位置后的数据往后移动，效率比较低下
         erase(): 删除vector的一个数据或者某一个范围的数据
                   第一种：删除某一个数据   vector.erase(迭代器位置) 删除迭代器位置的元素
                   第二种：删除某一个范围的数据  案例
         vector.erase(vc.begin(),vc.begin()+4),会删除第一个到第三个元素，第四个元素不会删除；
          push_back();在尾部添加一个元素，效率比较高。参数是需要添加的值
         pop_back(); 在尾部删除一个元素，没有返回值
         capacity（）：得到vector的容量，可以使用的总大小。

    代码：程序作用   定义一个学生的结构体，有姓名年龄，学生id。（用vector存放数据）
        如果输入1则尾部添加一个学生，输入2则打印学生信息，输入3则随机位置插入学生信息，输入4则班级解散。

    头文件

    student.h

    1. #ifndef STUDENT_H
    2. #define STUDENT_H
    3. #include
    4. #include
    5. #include
    6. #include
    7. using namespace std;
    8. typedef struct student
    9. {
    10.     int id;
    11.     string name;
    12. }stu;
    13. void caidan(vector&q);
    14. void zuoyong1(vector &q,stu a);//尾部添加学生信息
    15. void zuoyong2(vector &q);//打印学生信息
    16. void zuoyong3(vector &q,stu a,int n);//随机位置插入学生信息
    17. void zuoyong4(vector &q);//清空学生信息
    18.  
    19.  
    20. #endif // STUDENT_H

    student.cpp

    1. #include "student.h"
    2. void caidan(vector<stu> &q)
    3. {
    4.     int a;
    5.  
    6.     cout<<"请输入您的选择：";
    7.     cin>>a;
    8.     if(a==1)
    9.     {
    10.         stu b;
    11.         cout<<"请输入学生的id:";
    12.         cin>>b.id;
    13.         cout<<"请输入学生的name : ";
    14.         cin>>b.name;
    15.         zuoyong1(q,b);
    16.     }
    17.     if(a==2)
    18.     {
    19.         zuoyong2(q);
    20.     }
    21.     if(a==3)
    22.     {
    23.         stu b;
    24.         int n;
    25.         cout<<"请输入学生的id:";
    26.         cin>>b.id;
    27.         cout<<"请输入学生的name : ";
    28.         cin>>b.name;
    29.         cout<<"请输入插入的数据: ";
    30.         cin>>n;
    31.         zuoyong3(q,b,n);
    32.     }
    33.     if(a==4)
    34.     {
    35.        zuoyong4(q);
    36.     }
    37.  
    38.  
    39. }
    40. void zuoyong1(vector<stu> &q,stu a)//尾部添加学生信息
    41. {
    42.     q.insert(q.end(),a);//地址  ++ 数据
    43.     getchar();
    44.     caidan(q);
    45. }
    46. void zuoyong2(vector<stu> &q)//打印学生信息
    47. {
    48.     vector<stu>::iterator it =q.begin();
    49.     for(it=q.begin();it!=q.end(); it++)//it++ 遍历下一个
    50.     {
    51.         cout<<"学生的id :  "<<it->id<<"   ";
    52.         cout<<"学生的名字： "<<it->name<<endl;
    53.     }
    54.      getchar();
    55.     caidan(q);
    56. }
    57. void zuoyong3(vector<stu> &q,stu a,int n)//随机位置插入学生信息
    58. {
    59.     q.insert(q.begin()+n,a);
    60.      getchar();
    61.     caidan(q);
    62. }
    63. void zuoyong4(vector<stu> &q)//清空学生信息
    64. {
    65.     q.clear();
    66.      getchar();
    67.     caidan(q);
    68. }
    69.

    main.cpp 

    1. #include <iostream>
    2. #include <vector>
    3. #include<list>
    4. #include<cstdlib>
    5. #include"student.h"
    6. #include"bank.h"
    7. using namespace std;
    8.  
    9. void show(vector<int> &vec1)//打印动态数组的元素
    10. {
    11.     //begin() 是开始!
    12.     //end() 是结束!
    13.     vector<int>::iterator it =vec1.begin();
    14.     for(it=vec1.begin();it!=vec1.end(); it++)//it++ 遍历下一个
    15.     {
    16.         cout<<*(it)<<"  ";
    17.     }
    18.     cout<<"元素的个数： "<<vec1.size()<<endl; //获得元素个数
    19. }
    20.  
    21.  
    22.  
    23. int main(int argc, char *argv[])
    24. {
    25.     /*
    26.     vector<int>vec1;//无参构造
    27.     vector<int>vec2(5,10);//有参构造 ，4个 int 类型的数值  10存入动态数组
    28.     vec1=vec2;//拷贝构造
    29.     show(vec1);
    30.     vec1.pop_back();//尾部删除
    31.     show(vec1);
    32.  
    33.  
    34.     vec1.clear();//清空动态数组 vector
    35.     //判断动态数组 vector 是否为空
    36.     if(vec1.empty())
    37.     {
    38.         cout<<"vector 是空的！"<<endl;
    39.     }
    40.     else
    41.     {
    42.         cout<<"vector 不是空的！"<<endl;
    43.     }
    44.  
    45.     //插入数据
    46.     vec1.insert(vec1.end(),110);//地址  ++ 数据 //这里插入的数据是哪里 就插入哪里，  begin（）  -》下标为  0  的位置
    47.     show(vec1);
    48.  
    49.     //在任意的位置删除元素
    50.     vec1.erase(vec1.begin());//括号里面的数据是 迭代器的地址
    51.     show(vec1);
    52.  
    53.  
    54.     //vec2 插入数据
    55.     vec2.insert(vec2.begin(),110);
    56.     show(vec2);
    57.  
    58.     //删除固定范围的数据
    59.     vec2.erase(vec2.begin(),vec2.begin()+1);//前面那个数据不会删除，1 2 3 4   的动态数组只会删除  1   第一个数据，  因为begin 是开始的 0  吧！
    60.     show(vec2);
    61.  
    62.     //开始的时候申请的空间大小，是开始申请的2 倍，等空间不够的时候再次申请！！
    63.     cout<<"容量空间大小： "<<vec2.capacity()<<endl;//容量空间
    64. */
    65.  
    66.  
    67.  
    68.     //建立动态数组
    69.     vector<stu> q;
    70.     //运用菜单
    71.     caidan(q);
    72.  
    73.  
    74.     return 0;
    75. }


    3.list(双向链表）
        头文件： #include
        特点： list是双向链表，在任意位置添加和删除都方便，效率高，但查找不容易，不可以通过下标操作。
         构造：
            第一个：空的构造函数   list()
            第二个： 拷贝构造   list(const list& other)
            第三个：list(int n,T val); 包含n个val元素
            第四个：用某一个容器的某一部分进行构造
                         list(T first,T last)  包含[ first ,last)
          成员函数： 
             首元素： front（）
             尾元素： back()
             判断空：empty()
             得大小： size()
             清空： clear()
             尾部添加：push_back()
             尾部删除： pop_back()
             头部添加： push_front()
             头部删除：pop_front()
             添加元素： insert()
             交换list: swap()
             链表排序： sort()
             链表反转：  reverse() 

    代码：程序 功能： 测试list 的函数

    main.c

    1. #include <iostream>
    2. #include <vector>
    3. #include<list>
    4. #include<cstdlib>
    5. #include"student.h"
    6. #include"bank.h"
    7. using namespace std;
    8.  
    9.  
    10. int main(int argc, char *argv[])
    11. {
    12.    
    13.  
    14.     list<int>mylist1;//无参构造
    15.     list<int>mylist2(5,6);//有参构造 定义 5个 6
    16.     list<int>mylist3(mylist2);//拷贝构造
    17.     vector<int>vct(10,20);
    18.     list<int>mylist4(vct.begin()+3,vct.end()-2);//拷贝了5个！ 20
    19.     cout<<mylist3.size()<<endl;//元素个数
    20.     mylist3.pop_front();//头部删除
    21.     mylist1.insert(mylist1.begin(),111);//任意位置添加元素
    22.     mylist1.reverse();//list 反转
    23.     mylist1.swap(mylist3);//list 的相互交换
    24.     mylist1.sort();//排序函数 固定的升序
    25.     //                第一个地址        第二个地址
    26.     mylist1.erase(mylist1.begin(),mylist1.end());//list 的开始位置，到list 末尾的位置，全部删除
    27.  
    28.  
    29.  
    30.  
    31.     return 0;
    32. }

    4.deque(双向队列）
         队列特点：先进先出
            deque是在vector和list的组合，可以在两端push和pop
            可以随机访问的，可以使用下标操作，等价vector中的at。
            
        常用函数
          deque.assign(begin(),end())     赋值 把[begin，end)的数据赋值给deque
          deque.assign(n,val) ; 把n个val赋值给deque
          deque.at(x), 得到下标是x的数据元素，如果越界会抛出异常out_of_rang
          deque.back() ; 得到最后一个元素
           deque.front(); 得到首元素
            deque.begin()  迭代器，指向首元素
            deque.end() ;迭代器中执行尾元素
          deque.clear()  清空队列
           deque.size()  得到队列的容器
           deque.push_back(val)   尾部添加
            deque.pop_back()   尾部删除
             deque.push_front()  头部添加
             deque.rbegin();  反向迭代器，指向最后一个，it++ 指向倒数第二个
          deque.resize()  重新指定长度， 返回实际长度大小

    代码：

    1. #include <iostream>
    2. #include <deque>
    3. using namespace std;
    4.  
    5. void show(deque<int> de)//打印队列数据
    6. {
    7.     deque<int>::const_reverse_iterator  it = de.rbegin();
    8.     while (it != de.rend())
    9.     {
    10.         cout << *it << " ";
    11.         it++;
    12.     }
    13.     cout << "\n-------------------"<<endl;
    14. }
    15.  
    16. int main()
    17. {
    18.     deque<int>  de;//无参构造
    19.     for (int i = 0;i < 5;i++)
    20.         de.push_back(i);//尾部添加数据
    21.     de.assign(5, 10);//把5 个 10 的值赋给 de
    22.  
    23.     show(de);
    24.     de.pop_front();//头部删除
    25.     show(de);
    26.     cout << de.at(1) << endl;
    27.    
    28.     de.resize(100);
    29.     show(de);
    30.     de.clear();
    31.     show(de);
    32.  
    33.     return 0;
    34. }

    5.set(集合)
         作用：叫做集合，容器中不允许有相同的数据，并且数据自动排序。  
                  底层叫红黑树的平衡二叉树（红黑树） 也是一种容器

     

     

    代码：

    1. #include <iostream>
    2. #include <set>
    3. using namespace std;
    4.  
    5. void show(set<int> de)
    6. {
    7.     set<int>::iterator  it = de.begin();
    8.     while (it != de.end())
    9.     {
    10.         cout << *it << " ";
    11.         it++;
    12.     }
    13.     cout << "\n-------------------" << endl;
    14. }
    15. int main()
    16. {
    17.     int arr[10] = { 1,2,3,4,5,6,7,8,98,90 };
    18.     //把数组中所有元素添加到 set中
    19.     set<int> myset(arr,arr+sizeof(arr)/sizeof(arr[0]));
    20.     myset.insert(911);
    21.     set<int>::iterator  it = myset.begin();
    22.     //c++的新语法
    23.     for (auto& i : myset)
    24.     {
    25.         cout << i << endl;
    26.     }
    27.     show(myset);
    28.     myset.erase(5);
    29.     show(myset);
    30.     try{
    31.         set<int>::const_iterator cit = myset.find(9011);
    32.     }
    33.     catch (...)
    34.     {
    35.      //   cout << *cit << endl;
    36.     }
    37.    
    38.     std::cout << "Hello World!\n";
    39. }

    6.   map(字典--地图）
        特点：字典--一个key值对应一个val，由两个部分组成。
                 map则需要添加key也需要添加val所以要在map中放pair模板类
                 map可以方便的查找，并且key是唯一的。
                 底层是二叉树实现的。每次插入值的时候都需要重写构建一个树
        pair构造：
                无参构造：std::pair x;
                有参构造：std::pair x(begin,end);
                 拷贝构造：std::pair x(const std::pair& other);       


         map的构建：
              map xxx;
         map成员函数
             添加数据：需要添加pair模板，    insert(pair(1,2));
            begin():  迭代器第一元素
            end()  :迭代器最后一个元素
             at(int pos): 访问pos位置的元素
             rbegin() 反向迭代器
             erase(): 删除一个元素或者某个范围的元素，不可以使用反向迭代器
             size(): map的大小，实际存放数据元素
             find(key) 查找key对应的值，返回的是迭代器。
    map中有两个成员变量，一个是first一个second ，迭代器中的first表示key,second表示val
             可以通过下标访问元素。也可以通过下标赋值，但下标是key。

    代码：

    1. #include <iostream>
    2. #include <map>
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7.     map<int, string> mymap;//建立一个  map  key 是  int  类型   val  是 string 类型
    8.     mymap.insert(pair<int, string>(11, "ddanny1"));
    9.     mymap.insert(pair<int, string>(2, "ddanny2"));
    10.     mymap.insert(pair<int, string>(13, "ddanny3"));
    11.     mymap.insert(pair<int, string>(1, "ddanny4"));
    12.     mymap.insert(make_pair(6, "ddanny"));
    13.  
    14.     for (map<int, string>::iterator it = mymap.begin();
    15.         it != mymap.end();it++)
    16.     {
    17.         cout << it->first<<": "<< it->second << endl;
    18.     }
    19.     //最大可以使用的map大小。
    20.     cout << mymap.max_size() << endl;
    21.     mymap[2] = "abc";
    22.     //下标是key 所以13是key
    23.     cout << mymap[13] << endl;
    24.     cout << mymap.at(1) << endl;
    25.     mymap[1] = mymap[2];
    26.     cout << mymap[1] << endl;
    27.     mymap.clear();//清除
    28.  
    29.  
    30. }


       

    7.queue 操作

    queue 和 stack 有一些成员函数相似，但在一些情况下，工作方式有些不同：

    • front()：返回 queue 中第一个元素的引用。如果 queue 是常量，就返回一个常引用；如果 queue 为空，返回值是未定义的。
    • back()：返回 queue 中最后一个元素的引用。如果 queue 是常量，就返回一个常引用；如果 queue 为空，返回值是未定义的。
    • push(const T& obj)：在 queue 的尾部添加一个元素的副本。这是通过调用底层容器的成员函数 push_back() 来完成的。
    • push(T&& obj)：以移动的方式在 queue 的尾部添加元素。这是通过调用底层容器的具有右值引用参数的成员函数 push_back() 来完成的。
    • pop()：删除 queue 中的第一个元素。
    • size()：返回 queue 中元素的个数。
    • empty()：如果 queue 中没有元素的话，返回 true。
    • emplace()：用传给 emplace() 的参数调用 T 的构造函数，在 queue 的尾部生成对象。
    • swap(queue &other_q)：将当前 queue 中的元素和参数 queue 中的元素交换。它们需要包含相同类型的元素。也可以调用全局函数模板 swap() 来完成同样的操作。

    代码：

    1. #include <cstdlib>
    2. #include <iostream>
    3. #include <queue>
    4.   
    5. using namespace std;
    6.   
    7. int main()
    8. {
    9.     int e,n,m;
    10.     queue<int> q1;//创建队列
    11.     for(int i=0;i<10;i++)
    12.        q1.push(i); //入队
    13.     if(!q1.empty())//判断是否为空
    14.     cout<<"dui lie  bu kong\n";
    15.     n=q1.size();//返回队列元素的数量
    16.     cout<<n<<endl;
    17.     m=q1.back();//返回队列最后的元素
    18.     cout<<m<<endl;
    19.     for(int j=0;j<n;j++)
    20.     {
    21.        e=q1.front();//返回队列开始的元素
    22.        cout<<e<<" ";
    23.        q1.pop();//出队
    24.     }
    25.     cout<<endl;
    26.     if(q1.empty())
    27.     cout<<"dui lie  bu kong\n";
    28.     system("PAUSE");
    29.     return 0;
    30. }

    8.stack

    一：头文件

    #include

    二：定义stack

    1. stack<int>  s;创建一个空的 stack 对象。
    2.  
    3. stack<int, list<int> >   s1;
    4. stack<int, list<int> >   s2(s1);
    5. 利用 s1 ，创建一个以双向链表为底层容器的空堆栈对象 s2 。

     三：基本函数

    1. empty() 堆栈为空则返回真
    2.  
    3. pop() 移除栈顶元素
    4.  
    5. push() 在栈顶增加元素
    6.  
    7. size() 返回栈中元素数目
    8.  
    9. top() 返回栈顶元素
    10.  
    11. swap（）交换元素

    四：用法示例

    1. #include <iostream>
    2. #include <stack>
    3. #include <vector>
    4. #include <string>
    5. using namespace std;
    6.  
    7. int main() {
    8.     int i = 0;
    9.     stack<int> v;
    10.     for (i=0;i<10;++i)
    11.     {
    12.         v.push(i);
    13.         cout << v.top() << "已入栈"<<endl;
    14.  
    15.     }
    16.     cout << "现在栈的容量" << v.size() << endl;
    17.     for (i=0;i<10;++i)
    18.     {
    19.         cout << v.top() << "准备出栈" << endl;
    20.         v.pop();
    21.     }
    22.     cout << "现在栈的容量" << v.size() << endl;
    23.     return 0;
    24.  
    25. }

  • 相关阅读:
    C++日期类实现（联系类和对象）
    CSS属性使用之字体属性和文本属性使用规范标准有那些？
    数据库基本增删改查语法和多表联查的方式
    mac的vscode配置vue项目环境
    数据链路层：以太网/ARP协议
    【整理扑克牌】python实现-附ChatGPT解析
    【TypeScript】深入学习TypeScript命名空间
    一款内网信息收集利用工具
    java通过zookeeper 高可用方式连接hiveserver2
    了解一下，我是如何用Python在业余时间赚5千外快的
  • 原文地址：https://blog.csdn.net/she666666/article/details/126755995