目录

一、STL的概述

1、概述

2、特点

3、string 类

二、容器

1、概述

 2、vector 

3、deque

4、list

5、stack

6、queue

优先队列

7、set 容器

8、map容器

9、multimap

一、STL的概述

1、概述

//STL是由 容器、迭代器、空间适配器、适配器、算法、仿函数六大组件组成；

//STL包含了诸多在计算机科学领域里常用的基本数据机构和基本算法；并且降低了他们之间的耦合关系。

//STL是由惠普实验室开发的一系列软件的统称，现在主要应用于c++中。

2、特点

1.将数据结构和算法分离

2.不需要关心具体的实现过程，只要熟练使用STL就可以。

3.STL具有高度的可重用性，高性能，高移植性，跨平台

3、string 类

//不是STL容器，但是与STL容器有相似之处。

1. 是一个字符串类型，通常用来标识字符串

2.string和插入*的区别

1> string是一个类，char*是一个指向字符串的指针

2> string封装了char*，管理整个字符串，是一个char*的容器

3> string几乎不需要考虑内存越界和内存释放。

#include 
#include 
#include 
using namespace std;

int main(int argc, char const *argv[])
{
#if 0
    string s1;  //无参构造函数
    string s2("helloworld");  //有参构造函数
    string s3(10,'a'); //10个a
    string s4(s2);


    cout<>s1;   //重载了输入运算符
    cout< 0)     //s1 与 s2 比较
    {
        cout<<"s1 > s2"< 0)
    {
        cout<<"s1> s2"< 
二、容器 
1、概述 
 
 
容器就是将各种常用的数据结构，如数组、链表、栈、队列、二叉树等封装成一个个模板类，以方便编程。
 
 
 
 2、vector  
 
 
vector是将元素放置在一个动态数组中加以管理的容易，可以随机存取元素，[]或者at直接存取，vector在尾部存取元素十分迅速，但是在中部或者头部插入或者删除 元素比较费时。
 
 
 
 
#include 
#include 
#include 
using namespace std;

int main(int argc, char const *argv[])
{
#if 1
    int data[10] = {1,2,3,4,5,6,7,8,9,10};
    vector v1;                     //创建数组对象（模板类），无参构造函数
    vector v2(data, data + 10);    //显示调用，int类型
    vector v3(10, 1);                

    v1.resize(10);
    for(int i = 0; i < v1.size(); i++)
    {
        v1[i] = i;
    }

    for (int i = 0; i < v1.size(); i++)
    {
        cout<::iterator it = v3.begin(); it != v3.end(); it++)  //正向迭代
    {
        cout<<*it<<" ";
    }
    cout<::reverse_iterator rit = v2.rbegin(); rit != v2.rend(); rit++)
    {
        cout<<*rit<<" ";
    }                                           //反向迭代
    cout<::const_iterator cit = v2.begin(); cit != v2.end(); cit++)
    {
        //(*cit)++;     //只读容器
        cout<<*cit<<" ";
    }
    cout< v(s, s + strlen(s));     //char 类型

    for (vector::iterator it = v.begin(); it != v.end(); it++)  //迭代
    {
        cout<<*it;
    }
    cout<::iterator it = v.begin(); it != v.end(); it++)
    {
        cout<<*it;
    }
    cout<::iterator it = v.begin(); it != v.end(); it++)
    {
        cout<<*it;
    }
    cout<::iterator it = v.begin(); it != v.end(); it++)
    {
        cout<<*it;
    }
    cout<::iterator it = v.begin(); it != v.end(); it++)
    {
        cout<<*it;
    }
    cout<::iterator it = v.begin(); it != v.end(); it++)
    {
        cout<<*it;
    }
    cout< 
3、deque 
 
 
deque:双端数组，而vector是单端数组，但是两者在接口上非常非常相似，许多操作可以直接替换，deque可以随机存取元素，使用[]或者at() 在deque中，在头部和尾部添加或者删除元素非常迅速，但是在中部添加或者删除则比较费事，头文件：#include 
 
 
#include 
#include 
using namespace std;

int main(int argc, char const *argv[])
{
#if 1
    int data[5] = {1,2,3,4,5};

    deque d1;
    deque d2(data, data + 5);     //int 类型
    deque d3(10,1);

    d1.resize(10);
    for (int i = 0; i < d1.size(); i++)
    {
        d1[i] = i + 1;
    }

    for (int i = 0; i < d1.size(); i++)
    {
        cout<::iterator it = d2.begin(); it != d2.end(); it++)
    {
        cout<<*it<<" ";
    }
    cout<::iterator it = d2.begin(); it != d2.end(); it++)
    {
        cout<<*it<<" ";
    }
    cout<::iterator it = d2.begin(); it != d2.end(); it++)
    {
        cout<<*it<<" ";
    }
    cout<::iterator it = d2.begin(); it != d2.end(); it++)
    {
        cout<<*it<<" ";
    }
    cout<::iterator it = d2.erase(d2.begin());    //删除第一个元素
    cout<<*it<::iterator it = d2.begin(); it != d2.end(); it++)
    {
        cout<<*it<<" ";
    }
    cout< d(data, data + 10);

    for (deque::iterator it = d.begin(); it != d.end();)  //删除所有3
    {
        if (*it == 3)
        {
            d.erase(it);
        }
        else
        {
            it++;
        }
        
    }
    
    for (deque::iterator it = d.begin(); it != d.end() ; it++)
    {
        cout<<*it<<" ";
    }
    cout< 
4、list 
 
 
list：是一个双向链表容器，可高效的进行插入和删除元素，list不支持随机存取元素，所以说不支持[]和at(),也不支持迭代器的随机访问
 
 
#include 
#include 
#include 
using namespace std;

class Student                  //与链表相同，需要自己定义节点的类型（结构体类型）
{                              //在C++中，通常用类，代替结构体类型
    private:
        int id;
        char name[32];

    public:
        Student(){}
        Student(int i, const char *n);
        void show();
        bool operator==(const Student &s);

};

Student::Student(int i, const char *n)
{
    id = i;
    strcpy(name, n);
}

void Student::show()
{
    cout<<"id = "< l;    //创建链表对象

    l.push_back(s1);  //尾插法
    l.push_back(s2);  //尾插法
    l.push_back(s3);  //尾插法
    l.push_back(s4);  //尾插法
    l.push_back(s5);  //尾插法
    l.push_back(s6);  //尾插法

    for (list::iterator it = l.begin(); it != l.end(); it++)  //迭代
    {
        it->show();
    }

    l.pop_back();   //删除最后一个节点
    l.pop_front();   //删除第一个节点

    cout<<"***********************"<::iterator it = l.begin(); it != l.end(); it++)  //迭代
    {
        it->show();
    }  

    cout<<"最后一个元素是："<::iterator it = l.begin(); it != l.end(); it++)  //迭代
    {
        it->show();
    }  
    
    //对象数组
    cout<<"************************"<::iterator it = l.begin(); it != l.end(); it++)  //迭代
    {
        it->show();
    }  

    cout<<"************************"<::iterator it = l.begin(); it != l.end(); it++)  //迭代
    {
        it->show();
    }  

    cout<<"************************"<::iterator it = l.begin(); it != l.end(); it++)  //迭代
    {
        it->show();
    }  

    cout<<"删除一个区间"<::iterator it = l.begin();
    for (int i = 0; i < 5; i++)
    {
        it++;
    }
    l.erase(it, l.end());        //删除it 后面全部
     for (list::iterator it = l.begin(); it != l.end(); it++)  //迭代
    {
        it->show();
    }  

    cout<<"删除一个位置"<::iterator it = l.begin(); it != l.end(); it++)  //迭代
    {
        it->show();
    }  
    
    cout<<"删除具体元素"<::iterator it = l.begin(); it != l.end(); it++)  //迭代
    {
        it->show();
    }  

    cout<<"链表反转"<::iterator it = l.begin(); it != l.end(); it++)  //迭代
    {
        it->show();
    }  

    return 0;
}
 
5、stack 
//包含头文件 #include 
 
//栈：同样需要显示调用：如：stack s;
 
//push() 进栈; top() 栈顶元素； size() 栈的大小； empty()  是否为空； pop() 出栈；
 
#include 
#include 
#include 
#include 
using namespace std;

int main(int argc, const char *argv[])
{
    stack s;
    srand(sizeof(time(NULL)));
    
    int num;

    for (int i = 0; i < 10; i++)
    {
        num = rand()%10;
        s.push(num);
        cout< 
6、queue 
//包含头文件 #include 
 
//push() 进队； front() 队头元素； back() 队尾元素；empty() 是否为空； 
 
#include 
#include 
using namespace std;

int main(int argc, const char *argv[])
{
    queue q;

    int num;

    for (int i = 0; i < 10; i++)
    {
        num = i + 1;
        q.push(num);
        cout< 
优先队列 
//priority_queue 优先队列；如：priority_queue p;
 
//pop() 出队；push()进队；top()栈顶；empty()栈空
 
#include 
#include 
#include 
#include 
using namespace std;

int main(int argc, char const *argv[])
{
    //priority_queue p;   //priority_queue, less> p; //由大到小排序
    //priority_queue, greater> p;  //由小到大排序，由动态数组构成
    priority_queue, less> p;      //由队列构成

    srand(sizeof(time(NULL)));
    int num;

    for (int i = 0; i < 10; i++)
    {
        num = rand()%10;
        p.push(num);
        cout< 
 
7、set 容器 
 
 
//包含头文件 #include 
 
 
//属于链式存储，故而也需要先定义节点（通过类定义）；遍历就是要迭代
 
 
//链式存储是有序的，（由小到大 或 由大到小）
 
 
// insert() 插入数据； begin() 开始元素； end() 结尾元素； erase() 删除元素或区间；find() 查找（返回 地址）；count() 统计相同节点个数；lower_bound() 找到一个比当前元素大一个的元素；
 
 
upper_bound() 找到一个比当前元素小一个的元素；
 
 
//pair 类的使用：如： pair<参数1，参数2>  p; 对象 p 可以通过访问两个参数（p.first；p.second），起到lower_bound()；upper_bound()的作用
 
 
#include 
#include 
using namespace std;

class Student
{
    private:
        int id;
        string name;
    
    public:
        Student(int i, string n);
        void show() const;
        bool operator<(const Student &s) const;
        bool operator>(const Student &s) const;

};

Student::Student(int i, string s)
{
    id = i;
    name = s;
}

void Student::show() const
{
    cout<<"id = "< s;
    //set> s;  //greater<> 由小到大排序
    s.insert(s3);
    s.insert(s1);
    s.insert(s4);
    s.insert(s2);
    s.insert(s6);
    s.insert(s5);

    for (set::iterator it = s.begin(); it != s.end(); it++)
    {
        it->show();
    }
    
    cout<<"集合大小： "<::iterator it = s.begin(); it != s.end(); it++)
    {
        it->show();
    }

    cout<<"set区间删除"<::iterator it = s.begin(); it != s.end(); it++)
    {
        it->show();
    }

    cout<<"删除具体的元素"<::iterator it = s.begin(); it != s.end(); it++)
    {
        it->show();
    }

    cout<<"set的查找"<::iterator it = s.find(s4);
    if (it == s.end())
    {
        cout<<"对象不存在"<show();
    }

    cout<<"set的统计"<show();
    }

    cout<<"upper_bound"<show();
    }

    cout<<"**********************"<::iterator it = s.begin(); it != s.end(); it++)
    {
        it->show();
    }
    cout<<"equl_range"<::iterator, set::iterator> p;
    p = s.equal_range(s4);
    p.first->show();                //第一个变量：lower_bound
    p.second->show();               //第二个变量：upper_bound

    return 0;
}
 
8、map容器 
 
 
//map 容器包含两个部分：键（key）、值（value）
 
 
//在访问map 对象的内容时，需要指向 键（key）和值（value）两个数据
 
 
//begin() 开始元素； end() 结尾元素； erase() 删除元素或区间；
 
 
 
 
insert() 插入数据；//在接口括号中，调用其它接口
 
 
（1）pair(1,"zz")    //通过pair对组（组合一组数据）插入
 
 
（2）make(1,"aa")    //通过make_pair组合一对数据插入
 
 
（3）map::value_type(1,"cc");  //通过map内部的静态成员函数插入
 
 
（4）m[1] = “aa”;    //map重载了[ ]运算符,进行插入
 
 
#include 
#include