一、STL概述

 

        1.  STL概述

        （1）STL定义：STL（standard template library），标准模板库，是一个高效的c++程序库，重在提高了代码的复用性；主要包含了常用的数据结构和基本算法，为广大c++程序员提供了一个可扩展的应用框架；

        体现了泛型化（模板化）程序设计的思想，在实现方面是以一种类型程序参数化的方式实现的；采用模板类实现，所以定义时需要执行存储元素的类型（基本类型或自定义类型）；

      2. STL的六大组件

        （1）容器（container）：各种基本数据结构

        （2）迭代器（iterator）：常使用在遍历容器，又可以用在连接容器和算法；

        （3）算法（algorithm）：提供了各种基本算法如sort、search等；

        （4）适配器（adapter）：可改变容器（containers）、迭代器（iterators）或函数对象（function object）接口的一种组件；

        （5）函数对象（function object）：用类型包装函数，将函数类型化；

        （6）分配器（allocator）：内部调用malloc分配空间；

 二、容器

        1. 分类：可分为三类：

        （1）顺序容器（sequence containers），主要包括array、vector、deque、list、forward_list；

        （2）关联容器（associative containers），内部机理是树、哈希表，元素是键/值对，特别适合做查找，因为其时间复杂度较低；且大都具有自动排序功能；主要包括set、multiset、map、multimap；

        （3）无序（散列）容器（UNordered containers），内部机理是哈希表，c++11里推出：元素的位置不重要，重要的是这个元素是否在这个容器里面，主要适用于查找；主要包括：underde_set、unordered_multiset、unordered_map、unordered_multimap；

        2. vector容器  头文件#include<vector>

        （1）本质与特点

        ①vector是内置有动态数组，可以随机存取元素，可用[ ] 和 at()方法；

        ②vector尾部添加或移除元素非常快速；

        ③因为vector在中间插入会导致后面的所有元素都要重新析构与拷贝构造，效率很低；

        ④vector采用模板类实现，所以定义时需要执行存储元素的类型（基本类型或自定义类型）

        （2）主要操作

vector对象的默认构造	vector<int>v1;
vector对象的带参数构造	vector<int>v2(v1.begin()+1, v1.begin()+4);
vector的插入	push_back、insert
vector数据存取	v1.at(), v1[ ], v1.front(),
vector的删除	pop_back(), clear(), erase(),
vector的迭代器	begin(), end(), rbegin(), rend()
vector的大小	size(), empty(), capacity(), resize(), shrink_to_fit
vector的赋值	assign(), operator=, swap

vector示例：

#include <vector>
#include <iostream>
using namespace std;

class Test
{
public:
    Test()
    {
        // cout << "Test" << endl;        
    }

    Test(int t) : m_t(t)
    {
        // cout << "Test int" << endl;
    }

    Test(const Test &other)
    {
        m_t = other.m_t;
        // cout << "Test copy" << endl;
    }

    ~Test()
    {
        // cout << "~Test" << endl;
    }

    friend ostream& operator<<(ostream&out, Test &t);
    friend bool operator!=(const Test&t, int num);
    friend int operator%(const Test&t, int num);

    int m_t;
};
ostream& operator<<(ostream&out, Test &t)
{
    out<<t.m_t;
    return out;
}
bool operator!=(const Test&t, int num)
{
    return (t.m_t != num);
}
int operator%(const Test&t, int num)
{
    return (t.m_t % num);
}

template <typename T>
void print(vector<T> &vt)
{
    for(int i = 0; i < vt.size(); i++)
    {
        cout<<vt.at(i)<<" ";
    }
    cout<<endl;
}

template <typename T>
void delete_node(vector<T> &vt)
{
    for(auto it = vt.begin(); it != vt.end(); )
    {
        
        if(*it % 2 != 0)
        {
            // it = vt.erase(it);
            vt.erase(it);
        }
        else
        {
            ++it;
        }
    }
}

int main(int argc, char **argv)
{
    vector<Test> vt;
    vt.reserve(20);  //提前预留20个元素值，避免了空间不够时，频繁的拷贝构造
    for(int i = 0; i < 9; i++)
    {
        vt.push_back(Test(i+1));  //连续构造1-10
    }

    print(vt);
    delete_node(vt);  //删除其中是基数的元素值（test的m_t是奇数的）
    print(vt);

    cout<<"vt.capacity() = "<<vt.capacity()<<endl;  //输出vt容器的可容纳元素的大小，20
    vt.shrink_to_fit();  //回收未被利用的空间
    cout<<"vt.capacity() = "<<vt.capacity()<<endl;  //输出vt容器的可容纳元素的大小，4

    vt.assign(7,7);  //将7个7，赋给vt容器，注意是系统默认将vt原有的内容先清空
    print(vt);

    return 0;
}

        3. list 容器  头文件 #include<list>

        （1）本质及特点

        ①list是一个双向链表容器，适合高效地在头尾插入或者删除元素；

        ②list不支持随机存取元素，所以不支持at()方式与[ ]操作符；请注意迭代器方面it++可以，但是it+2这样就不支持了；只可遍历，不可跳跃；

        （2）主要操作

list对象的默认构造	list<int> l1;也可以是自定义类型；
list对象的带参数构造	list<int> l2 (l1.begin()+1, l1.end());
list的插入	l2.push_back();     l2.pop_back(); l2.push_front();     l2.pop_front(); l2.emplace_back(); l2.emplace_front();
list元素删除	l2.clear();  l2.erase(beg,end); l2.erase(pos); l2.remove(elem); l2.remove_if(); list.unique();
list的迭代器	l2.begin(); l2.end(); l2.rbegin(); l2.rend();
list的元素存取	l2.front(); l2.back();
list的赋值	l2.assign(); l2.swap(l1);
list的大小	l2.size(); l2.empty(); l2.resiae(); l2.resize();
list的排列	l2.sort(); l2.reverse();
list对容器的操作	splice();

list示例：

#include <list>
#include <iostream>
#include <vector>

using namespace std;

template <typename T>
class Deleteor
{
public:
    bool operator()(const T &t)
    {
        return (t % 2) == 0;
    }
};

template <typename T>
void print(list<T> & other)
{
    for(auto it = other.begin(); it != other.end(); ++it)
    {
        cout<<*it<<" ";
    }
        cout<<endl;
}

int main(int argc,char **argv)
{
    list<int> l1;
    l1.emplace_back(1);
    l1.emplace_back(2);
    l1.emplace_back(3);
    l1.emplace_back(4);
    l1.emplace_back(5);
    l1.emplace_back(6);
    l1.emplace_back(7);
    l1.emplace_front(8);

    print(l1);  

    l1.insert(std::next(l1.begin(),3),9);  //std::next(l1.begin(),3)是制定插入的位置
    print(l1); 

    l1.remove(4);  //删除值等于4的元素
    print(l1);

    l1.remove_if(Deleteor<int>());  //Deleteor<int>()是删除的规则，返回的是bool（true，false）
    print(l1);                      //这里是一个函数对象，重载了函数运算符()

    l1.sort();  //对list排序，默认是从小到大
    print(l1);

    l1.sort(greater<int>());  //内建函数（对象）,实现从大到小排序
    print(l1);

    l1.reverse();  //对list逆序
    print(l1);

    list<int>l2 = {1,3,5,7,9};
    list<int>l3 = {2,4,6,8,10};
    l2.merge(l3);  //将l3合并到l2上,并按照默认的从小到大方式排好序
    cout<<"l2 : ";
    print(l2);
    cout<<"l3 : ";
    print(l3);  //l3会被清空

    list<int>l4 = {7,7,7,7};

    auto it = l2.begin();
    std::advance(it,2);  //将it迭代器后退2个位置，-2就是前进2个位置
    l2.splice(it,l4);
    cout<<"l2 : ";
    print(l2);

    return 0;
}

        4. forward_list容器

        本质及特点：优化list产生的，forward_list是单向链表，这样的话少存储一个指针，节省系统开销；

        ①只提供前向迭代器，不支持反向迭代器；

        ②不提供size()成员函数；

        ③没有指向最末元素的锚点，因此不提供back(),push_back(),pop_back()；

        ④不提供随机访问，与list同；

        ⑤插入和删除元素不会造成“指向其他元素的”指针、引用、迭代器失效；

        5. deque 容器，本质及特点：

        ①deque是双端数组，而vector是单端的；

        ②与vector一样，可以随机存取元素；且在头部和尾部移除元素都非常快速，但是在中间插入元素则比较费时；

        ③其他内容以vector一样；

        6. set/multiset 容器  头文件：#include<set>

        （1）本质及特点

        ①set是一个集合容器，其中包含的元素是唯一的，集合中的元素按一定的顺序排列；元素插入过程是按排序规则插入，所以不能指定插入位置；

        ②set采用红黑树变体的数据结构实现，红黑树属于平衡二叉树，在插入操作和删除操作上比vector快；时间复杂度是O(log n)；

        ③set不可以直接存取元素（不可以使用at.(pos)与[ ] 操作符）；

        ④multiset与set的区别是：set支持唯一键值，即每一个元素只能出现一次；而multiset中的元素可以出现多次；

        ⑤不可以直接修改set或multiset容器中的元素值，因为这类容器是自动排序的，如果要修改其中的某个元素值，必须先删除原有的元素，再插入新的元素；

程序示例：

#include <iostream>
#include <set>
#include <vector>

using namespace std;

template <typename T>
void print(const set<T> &other)
{
    for(auto it = other.begin(); it != other.end(); ++it)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
}

int main(int argc, char **argv)
{
    set<int>si;
    si.insert(1);
    si.insert(3);
    si.insert(7);
    si.insert(5);
    si.insert(2);

    print(si);

    // auto node = si.extract(3);  //修改成员值，c++17，本系统不支持
    // node.value = 9;
    // si.insert(move(node));

    // set<int>s2 = {2,4,6,8};
    // si.merge(s2);  //将s2合并到si，c++17，本系统不支持

    cout<<"si.count(5) : "<<si.count(5)<<endl;  //数值是5的元素有几个?

    auto it = si.find(5);
    if(it != si.end())
    {
        cout<<"找到了"<< *it <<endl;
    }

    auto it1 = si.lower_bound(5); //返回首个不小于5的元素的迭代器
    auto it2 = si.upper_bound(5); //返回收个大于5的元素迭代器
    if(it1 != si.end())
    {
        cout<<"it1 = "<<*it1<<endl;
    }
    if(it2 != si.end())
    {
        cout<<"it2 = "<<*it2<<endl;
    }

    return 0;
}

        7. map/multimap 容器  #include<map>

        （1）本质及特点

        ①map是标准的关联式容器，一个map是一个键值对（一个序列号，一个值，相当于数组的索引和对应的值），它提供基于key（键值）的快速检索能力；键值对中第一个元素是first，第二个元素是second，支持迭代器访问输出；

        ②map中的key值是唯一的；集合中的元素按一定的顺序排列，元素插入过程是按排序规则插入，所以不能指定插入位置；

        ③map的具体实现采用红黑树变体的平衡二叉树数据结构，在插入和删除操作上比vector块；

        ④map可以直接存取key所对应的value，支持[ ] 操作符，如map[key] = value；

        ⑤multimap 与 map 的区别：map支持唯一键值，每个键只能出现一次，而multimap中相同的键可以出现多次。但是multimap不支持[ ]操作符；

        （2）示例

#include <iostream>
#include <map>
#include <string>

using namespace std;

template<typename key, typename value>
void print(const map<key, value> &other)
{
    for(auto it = other.begin(); it != other.end(); ++it)
    {
        cout<<"key : "<<it->first<<" value : "<<it->second<<endl;
    } 
}

int main(int argc, char **argv)
{
    map<int, string> m1;  //和数组很像，索引+对应的值
    m1[1] = "hello1";
    m1[2] = "hello2";
    m1[3] = "hello3";

    print(m1);

    return 0;
}

        （3）一个面试题示例：给定一个数组，计算每个数值出现的次数，然后按字符出现次数的升序输出数值及其出现次数；并且单独输出个数大于数组个数一半的元素；

#include <iostream>
#include <map>
#include <set>

using namespace std;

template<typename key, typename value>
void print(const multimap<key, value> &other)
{
    for(auto it = other.rbegin(); it != other.rend(); ++it)
    {
        cout<<"降序遍历 : 值"<<it->second<<"   次数:"<<it->first<<endl;
    } 
}

int main(int argc, char **argv)
{
    int num[]={1,3,3,3,5,3};
    int len  = sizeof(num)/(sizeof(num[0]));
    cout<<"len = "<<len<<endl;  //输出元素的个数
    map<int,int>mc;

    for(auto &temp : num)
    {
        mc[temp]++;
    }
    // cout<<"mc[3] = "<<mc[3]<<endl;  //输出数值3对应的次数

    multimap<int,int>mi;  //注意这里又新建了一个容器，在插入元素时，与mc相反，以次数为键值，这样就会自动根据次数排序，默认是升序，若要降序，则需要采用逆向迭代器
    for(auto it = mc.begin(); it != mc.end(); ++it)
    {
        mi.insert(pair<int,int>(it->second,it->first));
    }

    for(auto &temp : mi)
    {
        cout<<"升序遍历 : 值"<<temp.second<<"   次数:"<<temp.first<<endl;  //注意前后的输出顺序对照上
    }

    print(mi);
    
    for(auto &temp : mc)
    {
        if(temp.second > (len/2))
        {
            cout<<"符合要求："<<temp.first<<" 出现次数："<<temp.second<<endl;
        }
    }

    return 0;
}

结果：

        8. 容器的选择原则总结

        ①vector是内置有动态数组，当容量满时会自动扩充，在末尾有定位指针，所以末尾插入十分快速，但中间插入则较慢，因为涉及到原有数组的拷贝；最大的特点是适合高效的随机访问；而deque则优化为可以既可以头插也可以末尾插；

        ②list是一个双向链表容器，访问指定元素的效率较低，不支持随机访问，最大的特点是中间插入的效率较快；

        ③set是一个集合容器，元素具有唯一性，因为排序功能，所以开销较大；若需要支持重复数据则需要使用multiset；

        ④map是关联式容器，内置键值对，且内部按照顺序排序，内部采用红黑树的数据结构，时间复杂度是O(log n )，查找与删除的效率很高；适合字典式存储数据；