亲宝软件园·资讯

展开

C++标准模板库STL深入讲解

编程远泊 人气:0

认识STL

STL的概述

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

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

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

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

三者的关系如图所示：

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

STL标准模板库都有什么

STL的知识结构如图：

容器

算法

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没有这个键时，将会自动插入这个键值对。

观察者设计模型

引言

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

什么是观察者设计模式

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

解决的问题

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

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

编程思路

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

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

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

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

一个方法为：添加观察者与其感兴趣的事件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;
}

加载全部内容
相关教程
猜你喜欢
用户评论