【c++基础】第六章 STL标准模板库

最新推荐文章于 2024-10-08 10:22:24 发布
最新推荐文章于 2024-10-08 10:22:24 发布
阅读量1.2k 收藏 6
点赞数
分类专栏： cpp 文章标签： c++ 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/distant_rove666/article/details/128419631
版权

第六章 STL标准模板库

认识STL

STL的概述

STL采用泛型思想，把C中所用到的所有的数据结构，按照一定的标准，全部封装成了一个个类模板。也被称为数据容器。

STL就是用来解决容器中数据元素的操作的问题的。并且他按排标准统一封装了操作容器元素的算法，即一个个的函数模板。

为了配合统一的算法去操作不同的容器，他又按标准统一封装了不同的迭代器，即一个个不同类型的具有指针特性的类模板。

所以容器，算法，迭代器是整个STL的核心。

三者的关系如图所示：

在这里插入图片描述

有了统一的数据结构，即容器，有了统一的算法，每一个容器都使用各自的不同的迭代器，从而实现了对数据结构元素的标准操作。

STL标准模板库都有什么

STL的知识结构如图：

在这里插入图片描述

容器

  1. 常用的数据结构，C++重新封装成了 vector（动态数组），list(链表)，deque（双向队列），set(集合) ，map(映射表)等，来实现存放数据，其中 set,map双叫关联容器 。其中的栈，单端队列，优先队列，又都是线性数据结构改造之后的具有各种特性的数据结构，又叫做容器适配器。
  2. 序列式容器强调值的排序，序列式容器中的每个元素均有固定的位置，除非用删除或插入的操作改变这个位置。vector容器，deque容器，List容器等。
  3. 关联式容器是非线性的树结构，更准确的说是二叉树结构，各元素之间没有严格的物理上的顺序关系，也就是说元素在容器中并没有保存元素入容器时的逻辑顺序 。关联式容器另一个显著特点是：在值中选择一个值作为关键字Key,这个关键字对值起到了索引的作用，方便查找。Set/mulitiset容器 Map/multimap容器，并且容器是可以嵌套使用的。

算法

algorithom头文件中的定义相关的操作的一系列的函数模板

STL收录的算法经过了数学上的效能分析与证明，且是经过商业运行考验过的，是极具复用价值 的，包括常用的排序，查找等。

​ 算法又可为为两种，质变算法，与非质变算法。

​ 何为质变算法：是指运算过程中会更改区间内的元素的内容。例如：拷贝，替换，删除等。

​ 何为非质变算法：是指运算过程中不会更改区间内的元素内容，例如：查找，计数，遍历，寻找极值等。

迭代器

迭代器的设计思维-STL 的关键所在，STL 的中心思想在于将容器(container)和算法(algorithms)分开，彼此独立设计，最后再一贴胶着剂将他们撮合在一起。从技术角度来看，容器和算法的泛型化并不困难，c++的 class template 和 functiontemplate 可分别达到目标，如果设计出两这个之间的良好的胶着剂，才是大难题

提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式,迭代器就被发明了出来。

在这里插入图片描述

函数符

在STL中主要用来为泛型算法提供策略。

有四种形式：全局函数指针，成员函数指针，仿函数（函数对象），与匿名函数Lambda表达式。

空间配置器

作用：主是用来解决内存碎片化问题的，以及过多的构造无用对象的问题。

容器的空间配置器的作用是把对象的内存开辟和构造过程分开，对象析构和内存释放分离开 。那为什么要把对象的内存开辟和构造（new的两个作用）分开，对象的析构和内存释放（delete的两个作用）分开呢？

1）因为在使用容器的过程中，构造一个容器，我们只想要容器的内存空间，并不需要给我们在内存上构造一堆无用的对象出来（直接用new没有办法避免这个问题）；当从容器中删除一个元素的时候，我们需要析构这个被删除对象，但是它占用的容器内存空间是不能释放的，因为容器还要使用；再比如我们需要释放一个容器的时候，需要先把容器里面有效对象元素析构一遍，而不是把容器所有元素都析构一遍（用delete无法避免这个问题），所以在操作容器的过程中，我们需要有选择性的分别去开辟内存，构造对象，析构对象，所以这就是空间配置器存在的意义。

C++ 标准STL里面提供的allocator空间配置器，默认的内存分配和释放就是依赖malloc和free实现的。SGI STL提供了两个版本的空间配置器，一级空间配置器和二级空间配置器。一级空间配置器的内存管理也是通过malloc和free实现的，但是SGI STL的二级空间配置器提供了一个内存池的实现。第二级配置器的设计思想为：

1.如果配置区块超过128 bytes，则移交给第一级配置器处理（空间配置器）；

2.如果配置区块小于128 bytes，则采用内存池管理（memory pool）。每次配置一大块内存，则维护对应的自由链表（free-list），下次若再有相同大小的内存需求，就直接从 free-list 中拨出（没有就继续配置内存，具体后面讲述），如果客端释换小额区块，就有配置器回收到 free-list 中。

对于SGI STL的二级空间配置器的内存池实现机制，还是非常重要的，因为这既涉及了空间配置器，又涉及了一个内存池的实现机制，因此大家需要好好的理解它的原理，大家在手写C++空间配置器的过程中，使用过nginx的内存池作为空间配置器的内存管理方案，这又是一个新的积累。

string字符容器库

字符串容器API接口：

#include <iostream>

using namespace std;

int main()
{
    string str(15,'g');
    string str10;
    str10.assign(10,'k');
    cout << str << endl;
    string str1(str,5);
    cout << str1 << endl;
    string str2("yaoliang",8);
    cout << str2 << endl;
	const char* s1=str2.data();
    const char* s=str2.c_str();
    cout << s << endl;
    //获取迭代器
    string::iterator it;
    for(it=str2.begin();it!=str2.end();it++){
        cout << *it << "   ";
    }
    cout << endl;
    //获取反向迭代器
    string::reverse_iterator it1;
    for(it1=str2.rbegin();it1!=str2.rend();it1++){
        cout << *it1 << "   ";
    }
    cout << endl;
    cout << str2.size() << endl;
    cout << str2.length() << endl;
    cout << str2.capacity() << endl;//已经开辟好的空间
    cout << str2.max_size() << endl;//最大容量
    //string 容量对象保存字符时，如果是小字符串（小于23个字节）,会在栈上开辟空间
    //如果是大对象(大于23个字节),会在堆上开辟空间

    //查看动态开辟空间策略（2倍扩容）
//    string str_test;
//    cout << str_test.capacity() << endl;
//    for(int i=0;i<1024;i++){
//        cout << "string容器对象中的有效元素个数:" << str_test.size() <<
//                "，string容器对象中的容量大小:" << str_test.capacity() <<  endl;//采取2倍扩容机制
//        str_test.push_back('a');
//    }

    cout << str1.insert(0,3,'A') << endl;
    cout << str1 << endl;
    cout << str1.insert(0,"hello") << endl;
    cout << str1.erase(0,6) << endl;
    cout << str2.find("liang") << endl;
    cout << str2.substr(3,5) << endl;
    cout << str2.replace(3,5,"ming");
    return 0;
}

在这里插入图片描述

vector容器

vector容器于array数组容器的区别

vector与array无乎是一样的，连续的存储结构，两者的唯一的区别在于在空间上的灵活，数组需要提前指定长度，不量确定了就不能发生改变了，比较死板，不够灵活。比如出现拷贝长度大于了给定的空间，需要再重新定义一个足够空间的大小，然后把旧空间的内容再一个个拷贝到新的空间，非常麻烦。

c++11引入array主要是用来描述一种支持迭代器的C风格数组的，所以数组怎么用，array就怎么用，他定义在栈上，且长度固定不会涉及动态内存的开辟所以没有push_back,pop_back的相关方法，但是Vector这种动态的数组在开发更为常用，他底层对象在堆上，且长度是可变的。

在这里插入图片描述

vector容器是动态空间，他随着元素的加入，它的内部机制会自动扩充空间以容纳新的元素。vector的运用对于内存的合理利用与运用的灵活性有很大的帮助。我们再也不必害怕空间不足而一开始就定义一个巨大的数组了。

实现分析：

在这里插入图片描述

空间分配策略

#include <iostream>
#include <vector>

using namespace std;

int main()
{  
    //动态扩容的策略（没内容不先开辟空间，不同于string）
    vector<int> v;
    for(int i=0;i<100;i++){
        cout << "vector容器对象中的有效元素个数:" << v.size() << "vector容器容量的大小:" << v.capacity() << endl;
        v.push_back(i);
    }
    return 0;
}

迭代器非法化问题及解决

#include <iostream>
#include <vector>

using namespace std;

int main()
{
    vector<int> v;
    for(int i=0;i<20;i++){
        v.push_back(rand()%100+1);
    }
    for(int i=0;i<v.size();i++){
        cout << v[i] << " ";
    }
    cout << endl;

    //insert后,迭代器非法化的问题
    for(vector<int>::iterator it=v.begin();it!=v.end();it++){
        if(0==*it%2){
            it=v.insert(it,888);//返回值为迭代器类型
            it++;//更新迭代器
        }
    }
    for(int i=0;i<v.size();i++){
        cout << v[i] << " ";
    }
    cout << endl;
    //erase迭代器非法化的问题
    for(auto it=v.begin();it!=v.end();){
        if(0==*it%2){
            it=v.erase(it);//返回值为容器类型
        }else{
            it++;
        }
    }
    for(int i=0;i<v.size();i++){
        cout << v[i] << " ";
    }
    cout << endl;
    return 0;
}

泛型算法

泛型算法 = 函数模板 + 迭代器范围（注意迭代器的类型） + 函数符（策略使用）

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

int main()
{
    vector<int> v;
    for(int i=0;i<20;i++){
        v.push_back(rand()%100+1);
    }
    for(int i=0;i<v.size();i++){
        cout << v[i] << " ";
    }
    cout << endl;

    cout << "----------------使用泛型算法进行遍历-------------" << endl;
    for_each(v.begin(),v.end(),[](int val){cout << val << "-";});
    cout << endl;
    //针对于容器中有迭代器的容器for_each算法，提供了一种变种：枚举for循环
    for(int val:v){//val默认为第0个元素，一次遍历，直到结束为止
        cout << val << "-" ;
    }
    cout << endl;
    return 0;
}

sort：

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

template <class T>
T my_greate(T t1,T t2){
    return t1>t2;
}

template <class T>
class my_Greate{
public:
    bool get_my_Greate(T t1,T t2){
        return t1>t2;
    }
};
int main()
{
    vector<int> v;
    for(int i=0;i<20;i++){
        v.push_back(rand()%100+1);
    }
    for(int val:v){
        cout << val << " " ;
    }
    cout << endl;
    cout << "---------------------1---------------------" << endl;
    //sort,ASC//升序
    sort(v.begin(),v.end());
    for(int k:v){
        cout << k << " ";
    }
    cout << endl;
    cout << "----------------------2--------------------" << endl;
    //sort,DESC,使用lambda表达式作为算法策略
    sort(v.begin(),v.end(),[](int val1,int val2){return val1>val2;});//一直判断到最后
//如果val1>val2为真，就把val1排好序，可以把函数符想象成一个抽象（必须这么理解，因为具体排序要看sort实现了），不是算法的具体实现，算法知道意思，就是降序了
    for(int k:v){
        cout << k << " ";
    }
    cout << endl;
    cout << "----------------------3--------------------" << endl;
    //使用函数对象
    sort(v.begin(),v.end(),greater<int>());//这是调用库函数中的函数对象
    for(int k:v){
        cout << k << " ";
    }
    cout << endl;
    cout << "----------------------4--------------------" << endl;
    //定义一个函数指针，函数符来实现
    sort(v.begin(),v.end(),&my_greate<int>);//这个就是全局函数指针，函数符实现
    for(int k:v){
        cout << k << " ";
    }
    cout << endl;
    //定义一个成员函数指针，函数符来实现
    //因为成员函数指针依赖于对象的调用，所以不可以有直接做为策略使用，需要绑定器进行对象绑定才可以
    cout << "----------------------5--------------------" << endl;
    my_Greate<int> m;
    using namespace placeholders;
    sort(v.begin(),v.end(),bind(&my_Greate<int>::get_my_Greate,&m,_1,_2));
    for(int k:v){
        cout << k << " ";
    }
    cout << endl;

    return 0;
}

binary_find:

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

int main()
{
    vector<int> v;
    for(int i=0;i<20;i++){
        v.push_back(rand()%100+1);
    }
    for(int val:v){
        cout << val << " " ;
    }
    cout << endl;
    //sort,ASC
    sort(v.begin(),v.end());
    for(int k:v){
        cout << k << " ";
    }
    cout << endl;
	//时间复杂度O（logn）
    bool ok=binary_search(v.begin(),v.end(),70);
    if(ok)
    cout << "find succeed!" << endl;
    else
    cout << "find failure!" << endl;
    return 0;
}

find&&find_if&&bind1st(绑定第一个参数)&&bind2nd(绑定第二个参数)&&bind(新式绑定器):

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

int main()
{
    vector<int> v;
    for(int i=0;i<20;i++){
        v.push_back(rand()%100+1);
    }
    for(int val:v){
        cout << val << " " ;
    }
    cout << endl;
    //find对容器中的值没有要求,时间复杂度O(n),顺序遍历一遍，和二分查找不一样，时间复杂度不同
    auto it=find(v.begin(),v.end(),70);
    if(it!=v.end()){
        cout << "find succeed!index:" << it-v.begin() << endl;
    }else{
        cout << "find failure!" << endl;
    }
    //find_if按条件查找,需要把一个2这个值按序插入到序列中
    it=find_if(v.begin(),v.end(),[](int val){return val < 2;});
    if(it!=v.end()){
        it=v.insert(it,2);
        it++;
        cout << "find succeed!" << endl;
    }else{
        cout << "find failure!" << endl;
    }
    for(int val:v){
        cout << val << " " ;
    }
    cout << endl;
    //老式绑定器bind1st,bind2nd
    it=find_if(v.begin(),v.end(),bind1st(greater<int>(),2));
    if(it!=v.end()){
        it=v.insert(it,2);
        it++;
        cout << "find succeed!" << endl;
    }else{
        cout << "find failure!" << endl;
    }
    for(int val:v){
        cout << val << " " ;
    }
    cout << endl;
    //新式绑定器:bind
    using namespace placeholders;
    it=find_if(v.begin(),v.end(),bind(greater<int>(),2,_1));
    if(it!=v.end()){
        it=v.insert(it,2);
        it++;
        cout << "find succeed!" << endl;
    }else{
        cout << "find failure!" << endl;
    }
    for(int val:v){
        cout << val << " " ;
    }
    cout << endl;
    return 0;
}

迭代器与空间配置器

在这里插入图片描述

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



//实现一个自定的空间配置器
template <class T>
struct Allocate{
    //1.开辟空间
    T* allocate(size_t size){
        T* temp=(T*)malloc(sizeof (T)*size);
        if(nullptr==temp){
            throw bad_alloc();
        }
        return temp;
    }
    //2.构造对象
    void constructor(T* p,const T& obj){
        //定位new
        new (p) T(obj);
    }
    //3.析构对象
    void destructor(T* p){
        p->~T();
    }
    //4.释放空间
    void destroy(T* p){
        free(p);
    }
};

template <class T,class Allocat=Allocate<T>>
class Vector{
private:
    T* _frist;
    T* _last;
    T* _end;
    Allocat _allcater;
public:
    Vector(int size=10){
//        this->_frist=new T[size];
        this->_frist=_allcater.allocate(size);
        this->_last=_frist;
        this->_end=this->_frist+size;
    }
    ~Vector(){
        if(nullptr!=this->_frist){
//            delete [] this->_frist;
            for(T* p=_frist;p!=_last;p++){
                _allcater.destructor(p);
            }
        }
        _allcater.destroy(_frist);
        this->_end=this->_last=this->_frist=nullptr;
    }
    //拷贝构造
    Vector(const Vector& other){
        int size=other._end-other._frist;
//        this->_frist=new T[size];
        this->_frist=_allcater.allocate(size);
        int len=other._end-other._frist;
        memmove(this->_frist,other._frist,sizeof (T)*len);
        this->_last=this->_frist+len;
        this->_end=this->_frist+size;
    }
    //等号运算符重载
    Vector& operator=(const Vector& other){
        if(this==&other){
            return *this;
        }
        int size=other._end-other._frist;
        int len=other._last-other._frist;
        if(nullptr!=this->_frist){
//            delete [] this->_frist;
//            this->_frist=new T[size];
            for(T* p=_frist;p!=_last;p++){
                _allcater.destructor(p);
            }
            _allcater.destroy(_frist);
            this->_frist=_allcater.allcate(size);
        }else{
//            this->_frist=new T[size];
            this->_frist=_allcater.allcate(size);
        }
        memmove(this->_frist,other._frist,sizeof (T)*len);
        this->_last=this->_frist+ len;
        this->_end=this->_frist+size;
        return *this;
    }
    bool full(){
        return this->_last==this->_end;
    }
    bool empty(){
        return  this->_last==this->_frist;
    }
    //2倍扩容
    void expand(){
        int size=this->_end-this->_frist;
//        T* temp=new T[size* 2];
        T* temp=_allcater.allocate(size*2);
        memmove(temp,this->_frist,sizeof (T)*size);
//        delete [] this->_frist;
        for(T* p=_frist;p!=_last;p++){
            _allcater.destructor(p);
        }
        _allcater.destroy(_frist);
        this->_frist=temp;
        this->_last=this->_frist+size;
        this->_end=this->_frist+size*2;
    }
    void push_back(const T& val){
        if(this->full()){
            this->expand();
        }
//        *_last++=val;
        _allcater.constructor(this->_last,val);
        _last++;

    }
    void pop_back(){
        if(this->empty()){
            return;
        }
//        _last--;
        _last--;
        _allcater.destructor(_last);
    }
    int size(){
        return this->_last-this->_frist;
    }
    int capacity(){
        return this->_end-this->_frist;
    }
    T& operator[](int index){
        if(index<0||index>=this->size()){
            throw out_of_range("越界！");
        }
        return this->_frist[index];
    }
    class iterator{
    public:
        //与标准库中的泛型算法匹配类型
        using difference_type=int;
        using value_type= T ;
        using pointer=T*;
        using reference=T&;
        using iterator_category=random_access_iterator_tag;
    private:
        T* ptr;
    public:
        iterator(T* ptr=nullptr){
            this->ptr=ptr;
        }
        //迭代器功能：++运算，！=运算
        iterator& operator++(){
            ++this->ptr;
            return *this;
        }
        iterator& operator++(int){
            this->ptr++;
            return *this;
        }
        iterator& operator--(){
            --this->ptr;
            return *this;
        }
        iterator& operator--(int){
            this->ptr--;
            return *this;
        }
        // !=运算符重载：
        bool operator!=(const iterator& other){
            return this->ptr!=other.ptr;
        }
        bool operator==(const iterator& other){
            return this->ptr==other.ptr;
        }
        T& operator*(){
            return *ptr;
        }
        T* operator->(){
            return ptr;
        }

        iterator& operator+=(int n){
            this->ptr+=n;
            return *this;
        }
        iterator& operator-=(int n){
            this->ptr-=n;
            return *this;
        }
        iterator operator+(int n){
            T* temp=this->ptr+n;
            return iterator(temp);
        }
        iterator operator-(int n){
            T* temp=this->ptr-n;
            return iterator(temp);
        }
        int operator-(const iterator& other){
            return this->ptr-other.ptr;
        }
        bool operator>(const iterator& other){
            return this->ptr - other.ptr > 0;
        }
        bool operator<(const iterator& other){
            return this->ptr - other.ptr < 0;
        }
        bool operator>=(const iterator& other){
            return !(*this < other);
        }
        bool operator<=(const iterator& other){
            return !(*this > other);
        }
        T* get(){
            return ptr;
        }
    };

    iterator begin(){
        return iterator(this->_frist);
    }

    iterator end(){
        return iterator(this->_end);
    }

};

class A{
public:
    A(){
        cout << "A structure" << endl;
    }
    ~A(){
        cout << "A destruct" << endl;
    }
    A(const A&other){
        cout << "A copy" << endl;
    }
};

int main()
{
    Vector<int> v;
    for(int i=0;i<20;i++){
        v.push_back(rand()%100+1);
    }
    for(int i=0;i<v.size();i++){
        cout << v[i] << " " ;
    }
    cout << endl;
    Vector<A> v1;
    Vector<int> v2;
    for(int i=0;i<20;i++){
        v2.push_back(rand()%100+1);
    }
    for(int k:v2){
        cout << k << " " ;
    }
    cout << endl;
    return 0;
}

deque容器

在这里插入图片描述

在这里插入图片描述

#include <iostream>
#include <deque>
#include <algorithm>
using namespace std;

int main()
{
    deque<int> dq;
    for(int i=0;i<20;i++){
        dq.push_front(rand()%100+1);
    }
    for(auto it=dq.begin();it!=dq.end();it++){
        cout << *it << " ";
    }
    cout << endl;
    sort(dq.begin(),dq.end());
    for(int k:dq){
        cout << k << " ";
    }
    cout << endl;

    for(int i=0;i<20;i++){
        cout << dq.back() << " ";
        dq.pop_back();
    }
    cout << endl;

    for(int i=0;i<20;i++){
        cout << dq.front() << " ";
        dq.pop_front();
    }
    cout << endl;
    return 0;
}

容器适配置

容器适配器是没有迭代器的，不能实现泛型算法

使用deque容器实现一个stack

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

template <class T,class Container=deque<T>>
class Stack{
private:
    Container container;
public:
    void push(const T& val){
        container.push_back(val);
    }
    void pop(){
        container.pop_back();
    }
    T& top(){
        return  container.back();
    }
    bool empty(){
        return container.empty();
    }
};

int main()
{
    Stack<int> s;
    for(int i=0;i<10;i++){
        s.push(i);
        cout << i << " ";
    }
    cout << endl;
    while (!s.empty()) {
        cout << s.top() << " ";
        s.pop();
    }
    cout << endl;
    return 0;
}

实现一个单端队列

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

template <class T,class Container=deque<T>>
class SimpleQ{
private:
    Container container;
public:
    void push(const T& val){
        container.push_back(val);
    }
    void pop(){
        container.pop_front();
    }
    T& top(){
        return  container.front();
    }
    bool empty(){
        return container.empty();
    }
};

int main()
{
    SimpleQ<int> q;
    for(int i=0;i<10;i++){
        q.push(i);
        cout << i << " ";
    }
    cout << endl;
    while (!q.empty()) {
        cout << q.top() << " ";
        q.pop();
    }
    cout << endl;
    return 0;
}

优先队列

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

template<class T,class Container=vector<T>,class Compair=less<T>>
class Priority_queue{
private:
    Container container;
    Compair compair;
public:
    Priority_queue(){
        make_heap(container.begin(),container.end(),compair);
    }
    void push(const T& val){
        container.push_back(val);
//        sort(container.begin(),container.end(),compair);//快排,但系统中采取的是大顶堆，原因快排，递归过多
        push_heap(container.begin(),container.end(),compair);
    }
    void pop(){
        pop_heap(container.begin(),container.end(),compair);
        container.pop_back();
    }
    T& top(){
        return  container.front();
//        return container.back();
    }
    bool empty(){
        return container.empty();
    }
};

int main()
{
    Priority_queue<int> pq;
    for(int i=0;i<20;i++){
        pq.push(rand()%100+1);
    }
    while (!pq.empty()) {
        cout << pq.top() << " ";
        pq.pop();
    }
    cout << endl;
    return 0;
}

list容器

在这里插入图片描述

#include <iostream>
#include <list>
#include <algorithm>
using namespace std;


int main()
{
    list<int> l;
    for(int i=0;i<20;i++){
        l.push_back(rand()%100+1);
    }
    for(int k:l){
        cout << k << " ";
    }
    cout << endl;
    l.sort();
    for_each(l.begin(),l.end(),[](int val){cout << val << " ";});
    cout << endl;
    l.sort([](int val1,int val2){return val1>val2;});
    for_each(l.begin(),l.end(),[](int val){cout << val << " ";});
    cout << endl;
    return 0;
}

set容器

Set特性是：所有元素都会根据元素的键值自动被排序。（set 与 map都会按照键值来自动排序，只不过set的键与值是一体的相同的）Set的元素不像map那样，可以同时拥有实值与键值，set的元素即是键值又是实值。（你也可以理解为只有一个值，键与值相同）Set不允许两个元素有相同的键值。（即然是自动排序，set与map是不允许有相同的键的存在。这一点与map是共同的。），而multiset是可以存相同键值的元素。（这是set与multiset的唯一区别。）。

所以set容器的迭代器是一个常双向迭代器，只支持什么：++，–，==，!=的操作。

我们可以通过set的迭代器改变set元素的值吗？不行，因为set元素值就是其键值，关系到set元素排序规则，如果任意改变set元素值，会严重破坏set组织结构。换句话说，set的迭代器是一个只读迭代器。

set容器拥有与list某些相同的性质，当对容器中的元素进行插入操作或者删除操作的时候，操作之前所有迭代器，在操作完成之后依

multiset的底层实现是红黑树，红黑树是平衡二叉树的一种。二叉树的相关知识点可以百度一下。

#include <iostream>
#include <set>

using namespace std;

class Stu{
private:
    string name;
    int age;
public:
    Stu(string name,int age){
        this->age=age;
        this->name=name;
    }
//    bool operator<(const Stu& other)const{
//        return this->age<other.age;
//    }
    void showInfo()const{
        cout << "姓名：" << name << "，年龄：" << age << endl;
    }
    int getAge(){
        return  this->age;
    }
};

template <class T>
class Myless{
public:
    bool operator()(T t1,T t2)const{
        return t1.getAge()<t2.getAge();
    }
};

int main()
{
    set<int> s;
    for(int i=0;i<20;i++){
        s.insert(rand()%100+1);
    }
    for(int k:s){
        cout << k << " ";
    }
    cout << endl;

    cout << "*********************自定义类型放入set****************" << endl;
    Stu stu1("yaoliang",19);
    Stu stu2("minmin",18);
    Stu stu3("sun",17);
    
    
//    set<Stu> s1;//调用库中的<预算符重载函数
//    s1.insert(stu1);
//    s1.insert(stu2);
//    s1.insert(stu3);
//    for(const Stu& stu:s1){
//        stu.showInfo();
//    }
    
    set<Stu,Myless<Stu>> s1;//自定义比较策略
    s1.insert(stu1);
    s1.insert(stu2);
    s1.insert(stu3);
    for(const Stu& stu:s1){
        stu.showInfo();
    }
    return 0;
}

multiset与set

#include <iostream>
#include <set>

using namespace std;

class Stu{
private:
    string name;
    int age;
    int id;
public:
    Stu(string name,int age,int id){
        this->age=age;
        this->name=name;
        this->id=id;
    }
    bool operator<(const Stu& other)const{
        return this->id<other.id;
    }
    void showInfo()const{
        cout << "学号：" << id << "，姓名：" << name << "，年龄：" << age << endl;
    }
    int getAge(){
        return  this->id;
    }
};

int main()
{
    Stu stu1("王大锤",19,1);
    Stu stu2("李二狗",18,2);
    Stu stu3("张三丰",17,3);
    Stu stu4("王五子",17,5);
    Stu stu5("刘四思",20,3);
//    set<Stu> s1;//调用库中的<预算符重载函数
    multiset<Stu> s1;
    s1.insert(stu1);
    s1.insert(stu2);
    s1.insert(stu3);
    s1.insert(stu5);
    s1.insert(stu4);
//    pair<set<Stu>::iterator,bool> p;
//    p=s1.insert(stu4);
//    if(p.second){
//        cout << "王五子入学成功！" << endl;
//    }else{
//        cout << " 王五子入学失败！" << "\n";
//    }
    for(const Stu& stu:s1){
        stu.showInfo();
    }

    return 0;
}

map容器

对组pair构建方式：

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

int main()
{
    pair<string,int> p1("zhangsan",1001);
    cout << p1.first << "," << p1.second << endl;

    pair<string,int> p2={"lisi",1002};
    cout << p2.first << "," << p2.second << endl;

    pair<string,int> p3;
    p3.first="maliu";
    p3.second=1003;
    cout << p3.first << "," << p3.second << endl;

    pair<string,int> p4=make_pair("wangwu",1004);
    cout << p4.first << "," << p4.second << endl;
    
    pair<string,int> p5=map<string,int>::value_type("tianqi",1005);
    return 0;
}

Map容器的特性是：所有元素都会根据元素的键的值自动排序。Map所有的元素都是统一的pair对组，同时拥有键值Key实值Value，pair的第一元素被视为键值，第二个元素被视为实值，map不允许两个元素有相同的键。

我们可以通过map迭代器改变map的键值吗？答案是不行，因为map的键值关系到map的元素的排列布局，Map中的键是不可修改的，但是键对应的值是可以修改的。

所以Map的迭代器是一个双向迭代器，只支持++ == ！=操作。

Map是可以随时插入或删除键值对的。

Map与multimap的唯一区别是multimap中的键是可以重复的。

Map的底层实现机制是由二叉树中的红黑树进行实现的。

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

int main()
{
    pair<string,int> p1("zhangsan",1001);

    pair<string,int> p2={"lisi",1002};

    pair<string,int> p3;
    p3.first="maliu";
    p3.second=1003;

    pair<string,int> p4=make_pair("wangwu",1004);

    pair<string,int> p5=map<string,int>::value_type("tianqi",1005);

    map<string,int> m1;
    m1.insert(p1);
    m1.insert(p2);
    m1.insert(p3);
    m1.insert(p4);
    m1.insert(p5);

    for(pair<string,int> p:m1){
        cout << p.first << p.second << endl;
    }
    cout <<m1.at("zhangsan") << endl;
//    cout <<m1.at("********") << endl;
    cout << m1["zhangsan"] << endl;
    cout << "------------------map[] not exist throw-------------" << endl;
    cout << m1["**********"] << endl;//副作用，会保存不存在的值
    for(pair<string,int> p:m1){
        cout << p.first << p.second << endl;
    }
    cout << "-----------------find-------------" << endl;
    auto it=m1.find("lisi");
    if(it!=m1.end()){
        cout << it->first << "," << it->second << endl;
    }else{
        cout << "no find!!!" << endl;
    }
    return 0;
}

注意:multimap中是没有【】中括号运算符的：

map中的[]注意事项：

map中的[]运算符具有两个作用：

​ 1.就是可以在map容器直接插入一个键值对。

​ 2.当map容器有同名的key时，使用[]也可修饰key对应的value的值。

​ 3.注意：在multimap中是没有[]中括号运算符的。

​ 4.中括号运算符如果map没有这个键时，将会自动插入这个键值对。

观察者设计模型

引言

用来解决两个不相关对象之间的一对一或者一对多的通信模型。

什么是观察者设计模式

观察者模式是一种对象行为模式。它定义对象间的一种一对多的依赖关系， 当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。在观察者模式中，主体是通知的发布者，它发出通知时并不需要知道谁是它的观察者，可以有任意数目的观察者订阅并接受通知。观察者模式不仅被广泛应用于软件界面元素之间的交互，在业务对象之间的交互、权限管理等方面也有广泛的应用。

解决的问题

定义了对象间的一种一对多的组合关系，以便一个对象的状态发生时，所有依赖于它的对象都得到通知并自动刷新。

观察者和被观察者之间存在“观察”的逻辑关系，当被观察者发生变化时，观察者就会观察到这样的变化，并作出相应的响应。

编程思路

  1. 设定两者类，一个为观察者类，一个为被观察者类

  2. 观察者类中，定义一个对某个事件感兴趣的处理函数，一般也叫做槽函数

  3. 被观察者类中，定义一个数据结构，用来保存观察者对某一个事件id（信号）感兴趣，使用数据结构建立信号与对象之间的映射关系

  4. 被观察者类中，定义两个方法函数：

    一个方法为：添加观察者与其感兴趣的事件id（信号）加入到容器中

    另一个方法为：信号函数：通知事件函数执行逻辑：首先遍历容器中，有没有感兴趣的事件ID，如果有，则代表一系列的观察者，对这个事件感兴趣，那么再次遍历观察者列表，让每一个观察者执行相应的槽函数

#include <iostream>
#include <map>
#include <list>

using namespace std;

class RecvBase
{
public:
    RecvBase(){
        cout << "--------------RecvBase structure------------------" << endl;
    }
    virtual void slotFunctions(int msgid)=0;
    virtual~RecvBase()
    {
        cout << "--------------RecvBase destruct------------" << endl;
    }
};

class Recv:public RecvBase
{
public:
    void slotFunctions(int msgid)override
    {
        switch(msgid)
        {
        case 1:
            cout << "接收到1信号，执行信号1对应槽函数逻辑" << endl;
            break;
        case 2:
            cout << "接收到2信号，执行信号2对应槽函数逻辑" << endl;
            break;
        case 3:
            cout << "接收到3信号，执行信号3对应槽函数逻辑" << endl;
            break;
        case 4:
            cout << "接收到4信号，执行信号4对应槽函数逻辑" << endl;
            break;
        }
    }
    Recv()
    {
        cout << "--------------structure--------------" << endl;
    }
    ~Recv()override
    {
        cout << "--------------destruct------------" << endl;
    }
};

class Sender
{
public:
    map<int,list<RecvBase*>> recvMap;
    void addRecvToMap(int msgid,RecvBase* recv)
    {
        this->recvMap[msgid].push_back(recv);
    }
    void signals(int msgid)
    {
        auto it=recvMap.find(msgid);
        if(it!=recvMap.end())
        {
            for(RecvBase* p:it->second)
                p->slotFunctions(msgid);
        }else
        {
            cout << "接受到未知信号，没有信号对应的槽函数逻辑" << endl;
        }
    }
};

int main(){
    Sender sender;
    RecvBase* r1=new Recv();
    RecvBase* r2=new Recv();
    RecvBase* r3=new Recv();
    RecvBase* r4=new Recv();

    sender.addRecvToMap(1,r1);
    sender.addRecvToMap(2,r2);
    sender.addRecvToMap(3,r3);
    sender.addRecvToMap(4,r4);


    int msgid;
    while(true)
    {
        cin >> msgid;
        if(-1==msgid)break;
        sender.signals(msgid);
    }
    delete r1;
    delete r2;
    delete r3;
    delete r4;
    return 0;
}
编程远泊
关注
专栏目录
C++ STL 标准模板库介绍与入门
dvlinker的技术专栏
05-14 2万+
C++ STL 标准模板库概述与入门
STL标准模板库
11-08
C++ STL 向量vector是一种随机访问的数组类型，提供了对数组元素的快速、随机访问以及在序列尾部快速、随机的插入和删除操作。它是大小可变的向量，在需要是可以改变其大小。 形式：
C++ STL模板
wkl132337的博客
11-27 599
文章目录一、STL介绍二、实验内容1.序列变换（取反、平方、立方）2.像素变换（二值化、灰度拉伸）3.SET的应用 实现学生信息的增删改查4.map的应用 使用map统计字符串中每个字符出现的次数总结 一、STL介绍 STL（Standard Template Library），即标准模板库，是一个具有工业强度的，高效的C++程序库。它被容纳于C++标准程序库（C++ Standard Library）中，是ANSI/ISO C++标准中最新的也是极具革命性的一部分。该库包含了诸多在计算机科学领域里所常用
C++：STL简介
Jdxxwu的博客
10-06 1429
本文将讲解C++STL简介
C++标准模板库（STL）
qq_44901656的博客
07-28 744
C++标准模板库（STL）
C++标准模板库
a46543266的博客
07-29 157
作为C++标准库相当重要的一部分，STL库提供一系列组件操作。它主要可以分为容器、迭代器、基本算法、函数对象以及内存分配器和配接器六个部分。整个STL库的代码都采用模板函数以及模板类的方式实现，具有高度的通用性。对于传统的应用程序来讲，模板库支持并且倡导一种新的编程风格，即称为泛型编程思想，以通用的模板方式来编写应用程序中的数据结构与算法。 16.1 STL常见容器 C++标准ST...
C++中的STL（标准模板库）
shaozheng0503的博客
04-17 1847
迭代器是STL容器和算法之间的桥梁，它们提供了一种统一的方式来访问容器中的元素。STL迭代器分为输入迭代器、输出迭代器、前向迭代器、双向迭代器和随机访问迭代器五种类型，每种类型的迭代器都有其特定的功能和限制。STL中的算法包括排序、查找、替换、合并、拷贝等，这些算法都是以泛型的方式实现的，即它们可以用于任何类型的数据，而不需要重复地编写代码。容器是一种存储和管理数据的对象，算法是对数据进行操作的函数，迭代器则是容器和算法之间的桥梁。在本文中，我们将探讨STL的基本概念、使用方法和一些常用的数据结构和算法。
C++ PPT第9章 标准模板库STL.ppt
05-30
C++标准模板库（Standard Template Library，简称STL）是C++语言中的一种通用库，主要思想是结合C++的模板机制，设计出一系列针对数据结构中具体问题的类模板和函数模板，并不针对具体的数据类型，形成了具有优秀、...
C++_标准模板库(STL) pdf 高清版
04-27
C++标准模板库（STL）是C++编程语言中不可或缺的一部分，它为开发者提供了大量高效、可重用的容器、算法和迭代器。STL的主要目标是提高代码的效率和可读性，通过使用泛型编程（也称为模板编程）来实现。以下是关于...
C++标准模板库(STL)
weixin_66580750的博客
06-30 1142
但如果定义的是万能头,则可以直接忽略//定义:int 数组名;int a;//输入:while(cin>>数组名){数组名.push_back(a);
【STL详解】STL标准模板库入门 | STL版本 | STL六大组件 | STL优点 | 常用STL容器vector、list和map | STL算法函数 | STL使用异常原因分析与总结
最新发布
dvlinker的技术专栏
10-08 1万+
本文详细介绍STL标准模板库相关的内容，包括STL版本、STL六大组件、STL优点、常用的STL容器vector、list与map、提升效率的STL算法函数的使用、STL使用异常常见原因分析与总结等，以供大家参考。
STL运用的C++技术（1）——成员模板
wuzhekai的专栏
08-02 7561
STL是C++标准库的重要组成部分之一，它不仅是一个可复用的组件库，更是一个包含算法与数据结构的软件框架，同时也是C++泛型编程的很好例子。STL中运用了许多C++的高级技术。本文
【C++】标准模板库（STL）
weixin_53235104的博客
05-06 5890
标准模板库 STL（Standard Template Library），是 C++ 标准库的一部分，不需要单独安装，只需要 #include 头文件。STL 的一个重要特点是数据结构和算法的分离。尽管这是个简单的概念，但这种分离确实使得STL 变得非常通用。例如，由于 STL 的 sort() 函数是完全通用的，你可以用它来操作几乎任何数据集合，包括链表、容器和数组；STL 的另一个重要特性是它不是面向对象的。STL 主要依赖于模板而不是封装、继承和虚函数（多态性）—— OOP的三个要素。
C++ - 标准库（STL）
m0_54386352的博客
05-02 2013
C++标准库是C++编程语言的标准程式库，它提供了一个通用的容器类、算法和函数模板库。其中包括了多种容器类型，例如：向量（vector）、双向链表（deque）、列表（list）、集合（set）和映射（map）等，各种容器类型均具备不同的优缺点和使用场景，STL还提供了许多算法和函数模板，使程序员能够轻松地完成一些常见的操作，例如排序、搜索、遍历和数据转换等。可以通过使用STL，从而提高代码的可读性和可维护性。
（C++）STL(标准模板库)
weixin_53812805的博客
06-01 1094
容器
[C++]——STL(标准模板库)
weixin_50720782的博客
08-09 902
STL标准模板库
【C++】STL（标准模板库）
weixin_45725295的博客
01-14 706
文章目录1. 基本概念 1. 基本概念
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

编程远泊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值