STL——基本概念和常用容器

1、STl 基本概念

         （1）STl（Standard Temlate Library.标准模板库）

         （2）STL从广义上分为：容器（container）算法（algorithm）迭代器（iterator）

         （3）容器和算法之间通过迭代器进行无缝连接

         （4）STL几乎所有的代码都采用了模板类或者模板函数

 

2、STL六大组件，分别是：容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

        1.容器：各种数据结构，如：vector、list、deque、set、map等，用来存放数据。

        2.算法：各种常用的算法，如sort、find、copy、for_each等

        3.迭代器：扮演了容器与算法直接的胶合剂

        4.仿函数：行为类似函数，可作为算法的某种策略

        5.适配器：一种用来修饰容器或者仿函数或迭代器接口的东西

        6.空间适配器：负责空间的配置与管理

 

3、STL中容器、算法、迭代器

        容器：置物之所也

        STL容器就是将运用最广泛的一些数据结构实现出来

        常用的数据结构：数组、链表、树、栈、队列、集合、映射表等

        这些容器分为序列式容器和关联式容器两种：

                    序列式容器：强调值的排序，序列式容器中每个元素均有固定的位置。

                    关联式容器：二叉树结构，各元素之间没有严格的物理上的顺序关系

 

        算法：问题之解法也

        有限的步骤，解决逻辑或教学上的问题，这一门学科我们叫做算法（Aigorithms）

        算法分为质变算法和非质变算法：

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

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

    

        迭代器：容器和算法之间粘合剂

        提供一种方法，使之能够依次寻访某个容器所含的各个元素，而又无需暴露该容器表示方式。

        每个容器都有自己专属的迭代器

        迭代器使用非常类似于指针，初学阶段可以先将迭代器当指针

        迭代器种类：

        输入迭代器：对数据的只读访问，只读，支持++、==、!=

        输出迭代器：对数据的只写访问，只写，支持++

        前项迭代器：读写操作，并能向前推进迭代器，读写，支持++、==、!=

        双向迭代器：读写操作，并能向前和向后操作，读写，支持++、--

        随机访问迭 代器：读写操作，可以以跳跃式的方式访问任意数据，功能最强的迭代器，读写，支持++、--、[n]、-n、、<、<=、>、>=

 

4、容器算法迭代器初识

        容器：vector

        算法：for_each

        迭代器：vector<int > :: iterator

 

 

5、常用容器--string

        本质：string是c++风格的字符串，而string本质上是一个类

        string和char*区别：

                    char*是一个指针

                    string 是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器。

        特点：

                string内部封装了很多成员方法

                    例如：查找find，拷贝copy，删除delete，替换replace，插入insert

                string管理char*所分配的内存，不用担心复制越界和取值越界等，有类内部进行负责

 

        string构造函数原型：

                string（）；    //创建一个空的字符串 例如：string str；

                string（const char* s）；  //使用字符串s初始化

                string（const string& str ）；//使用一个string对象初始化另一个string对象

                string（int n，char c）；//使用n个字符c初始化

 

                总结：string的多钟构造方式没有可比性，灵活使用即可

 

        string赋值操作原型：

                string& operator=(const char* s);    //char*类型字符串  赋值给当前的字符串

                string& operator=(const string& s);    //把字符串s赋值给当前的字符串

                string& operator=(char  c);    //字符赋值给当前的字符串

                string& assign(const char* s)  //把char*类型字符串s赋值给当前字符串

                string& assign(const char* s，int n)  //把字符串s的前n个字符赋值给当前字符串

                string& assign(const string& s))  //把字符串s赋值给当前字符串

                string& assign(int n，char c)  //用n个字符c赋值给当前字符串

 

                总结：string的赋值方式很多，operator=这种方式比较实用的

                

        string字符串拼接原型：

                string& operator+=(const char* str);     //重载+=操作符

                string& operator+=(const char c);     //重载+=操作符

                string& operator+=(const string  &str);     //重载+=操作符

                string& append(const char* s);      //把字符串s连接到当前字符串结尾

                string& append(const char* s，int n);      //把字符串s的前n个字符连接到当前字符串结尾

                string& append(const string  &s);      //同operator+=(const string  &str)

                string& append(const string  &s，int pos， int  n);      //把字符串s从pos开始的n个字符连接到当前字符串结尾

 

        string查找和替换原型：

                int find(const string& str,int pos = 0) const;   //查找str第一次出现的位置，从pos开始查找

                int find(const char* s,int pos = 0) const;   //查找s第一次出现的位置，从pos开始查找         

                int find(const char* s,int pos,int n) const;   //从pos位置查找s的前n个字符第一次出现位置

                int find(const char c,int pos = 0) const;   //查找字符c第一次出现位置

                int rfind(const string& str,int pos = npos) const;   //查找str最后一次出现的位置，从pos开始查找

                int rfind(const char* s,int pos = 0) const;   //查找s最后一次出现的位置，从pos开始查找         

                int rfind(const char* s,int pos,int n) const;   //从pos位置查找s的前n个字符最后一次出现位置

                int rfind(const char c,int pos = 0) const;   //查找字符c最后一次出现位置  

                string& replace(int pos,int n,const string& str);  //替换从pos开始n个字符为字符串str

                string& replace(int pos,int n,const char* s);  //替换从pos开始的n个字符为字符串s

                find和rfind区别：

                        find从左往右查，rfind从右往左查。

 

        string字符串比较：

                字符串比较按照字符ASCLL码进行对比：=返回0  >返回1   <返回-1

                函数原型：

                        int  compare（const string &s ）const;  //与字符串比较

                        int  compare（const char *s ）const;  //与字符串比较

 

        string字符存取：

                string中单个字符串存取方式有两种

                char& operator[](int n);     //通过[]方式取字符串

                char& at(int n);    //通过at方法获取字符

 

        string插入和删除：

                函数原型：

                        string& insert（int pos,const char* s）;      //插入字符串

                        string& insert（int pos,const string& s）;      //插入字符串

                        string& insert（int pos,int n,char c）;      //在指定位置插入n个字符c

                        string& erase（int pos，int  n = npos）;    //删除从pos开始的n个字符

 

        string子串

                从字符串中获取想要的子串

                函数原型：

                        string  substr（int pos = 0，int  n = npos）const； //返回由pos开始的n个字符组成的字符串

 

6、常用容器--vector

        vector基本概念

                功能：vector数据结构和数组非常相似，也称为单端数组

                vector和普通数组区别：不同之处在于数组是静态空间，而vector可以动态扩展

                动态扩展：并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝到新空间，释放原空间。

                                vector容器的迭代器是支持随机访问的迭代器。

                

        vector构造函数

                函数原型：

                        vector<T>  v;       //采用模板实现类实现，默认构造函数

                        vector(v.begin(),v.end());  //将v[begin(),end())区间中的元素拷贝给本身

                        vector(n,elem);         //构造函数将n个elem拷贝给本身

                        vector(const vector &vec);    //拷贝构造函数

 

        vector赋值操作

                函数原型：

                        vector&  operator=（const  vector &vec）；//重载等号操作符

                        assign（beg，end）；// 将[beg,end)区间中的数据拷贝赋值给本身

                        assign（n，elem）；  //将n个elem拷贝赋值给本身

 

        vector容量和大小

                功能描述：对vector容器的容量和大小操作

                函数原型：

                        empty（）；    //判断容器是否为空

                        capacity（）； //容器的容量

                        size（）；   //返回容器中元素的个数

                        reszie（int  num）；  //重新指定容器的长度为num，若容器变长，则以默认值0填充新位置；如果容器变短，则末尾超出容器长度的元素被删除

                         reszie（int  num，elem）；  //重新指定容器的长度为num，若容器变长，则以elem值填充新位置；若容器变短，则末尾超出容器长度的元素被删除。

 

        vector插入和删除 

                函数原型：

                        push_back(ele);       //末尾插入元素ele

                        pop_back();             //删除最后一个元素

                        insert(const_iterator pos,ele);     //迭代器指向位置pos插入元素ele

                        insert(const_iterator pos, int count, ele);  //迭代器指向位置pos插入count个元素ele

                        erase(const_iterator pos);       //删除迭代器指向的元素

                        erase(const_iterator start, const_iterator end);  //删除迭代器从start到end之间的元素

                        clear();               //删除容器中所有元素

 

        vector数据存取

                函数原型：at(int idx);      //返回索引idx所指的数据

                                operator[];      //返回索引idx所指的数据

                                front();            //返回容器中第一个数据元素

                                back();            //返回容器中最后一个数据元素

 

        vector互换容器

                功能：实现两个容器内元素进行不换

                函数原型：swap（vec）；     //将vec与本身的元素互换

                vector<int>(v);      //匿名对象

                    vector<int>(v).swap(v);   //通过匿名对象交换容器，收缩容器容量

 

        vector预留空间

                功能：减少vector在动态扩展容量时的扩展次数

                函数原型：reserve（int  len）；   //容器预留len个元素长度，预留位置不初始化，元素不可访问

 

 

7、常用容器--deque

        基本概念

                功能：双端数组，可以对头端进行插入删除操作

                deque与vector区别：

                            vector对于头部的插入删除效率低，数据量越大，效率越低

                            deque相对而言，对头部的插入和删除速度比vector快

                            vector访问元素时的速度会比deque快，这和两者内部函数实现有关

                deque内部工作原理：deque内部有个中控器，维护每段缓存区中的内容，缓存区中存放真实数据；中控器维护的是每个缓存区的地址，使得使用deque时像一片连续的内存空间；deque容器的迭代器也是支持随机访问的。

        deque构造函数

                函数原型：

                        deque<T>   deqT;     //默认构造

                        deque(beg,end);        //构造函数将[beg,end)区间中的元素拷贝给本身

                        deque(n,elem);           //构造函数将n个elem拷贝给本身

                        deque(const  deque &deq);   //拷贝构造

 

        deque赋值操作

                        deque&  operator=（const  deque &vec）；//重载等号操作符

                        assign（beg，end）；// 将[beg,end)区间中的数据拷贝赋值给本身

                        assign（n，elem）；  //将n个elem拷贝赋值给本身

 

        deque大小

                deque没有容量概念

                功能描述：对deque容器大小操作

                函数原型：

                        deque.empty（）；    //判断容器是否为空

                        deque.size（）；   //返回容器中元素的个数

                        deque.reszie（int  num）；  //重新指定容器的长度为num，若容器变长，则以默认值0填充新位置；如果容器变短，则末尾超出容器长度的元素被删除

                         deque.reszie（int  num，elem）；  //重新指定容器的长度为num，若容器变长，则以elem值填充新位置；若容器变短，则末尾超出容器长度的元素被删除。

 

 

        deque插入和删除

                两端插入操作：

                        push_back(elem);   //在容器尾部添加一个数据

                        push_front(elem);   //在容器头部添加一个数据

                        pop_back();             //删除容器最后一个数据

                        pop_front();             //删除容器第一个数据

                指定位置操作：

                        insert(pos,elem);     //在pos位置插入一个elem元素的拷贝，返回新数据的位置

                        insert(pos,n,elem);   //在pos位置插入n个elem数据，无返回值

                        insert(pos,beg,end); //在pos位置插入[beg,end)区间的数据，无返回值

                        clear();  //清空容器的所有数据

                        erase(beg,end);   //删除[beg,end)区间的数据，返回下一个数据的位置

                        erase(pos);      //删除pos位置的数据，返回下一个数据的位置

 

        deque数据存取

                函数原型：

                        at（int   idx）；   //返回索引idx所指的数据

                        operator[];           //返回索引idx所指的数据

                        front();                 //返回容器中第一个数据元素

                        back();                 //返回容器中最后一个数据元素

                

        deque数据存取

                函数原型：

                        sort（iteration beg，iteration  end）；   //对beg和end区间内元素进行排序

 

8、常用容器--stack

        stack基本概念

                概念：stack是一种先进后出（First  In   Last  Out）的数据结构，它只有一个出口

                栈中只有顶端的元素才可以被外部使用，因此栈不允许有遍历行为

 

        stack常用接口

                构造函数：

                        stack<T>  stk; //stack采用模板类实现，stack对象的默认构造形式

                        stack（const stack &stk）； //拷贝构造、

                赋值操作：

                        stack& operator=（const stack &stk）；//重置等号操作符

                数据存取：

                        push（elem）； //向栈顶添加元素

                        pop（）；        //从栈顶取第一个元素

                        top（）；        //返回栈顶指针

                大小操作：

                        empty（）；  //判断堆栈是否为空

                        size（）；      //返回栈的大小

 

 

8、常用容器--queue

            queue基本概念

                    概念：queue是一种先进先出（First  In  First Out，FIFO）的数据结构，它有两个出口

                    队列容器允许从一端新增元素，从另一端移除元素

                    队列中只有对头和队尾才可以被外界使用，因此队列不允许有遍历行为

                    队列中进数据称为---入队push

                    队列中出数据称为---出队pop

 

            queue常用接口

                    构造函数：

                            queue<T> que;    //queue采用模板类实现，queue对象的默认构造形式

                            queue(const  queue &que);   //拷贝构造函数

                    赋值操作：

                            queue&  operator=(const  queue &que);   //重载等号操作符

                    数据存取：

                            push(elem);     //往队尾添加元素

                            pop();              //从队头移除第一个元素

                            back();             //返回最后一个元素

                            front();             //返回第一个元素

                    大小操作：

                            empty();          //判断堆栈是否为空

                            size();              //返回栈的大小

                            

9、常用容器--list

            list基本概念

                    功能：将数据进行链式存储

                    链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的

                    链表的组成：链表由一系列结点组成

                    结点的组成：一个是存储数据元素的数据域，另一个存储下一个结点地址的指针域

                    STL中的链表是一个双向循环链表

                    由于链表的存储方式并不是连续的内存空间，因此链表list中迭代器指支持前移和后移，属于双向迭代器

                    list的优点：采用动态存储分配，不会造成内存浪费和输出；链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素

                    list的缺点：链表灵活，但是空间（指针域）和时间（遍历）额外耗费较大

                    list有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的实效，这在vector是不成立的

                    总结：STL中list和vector是两个最常被使用的容器，各有优缺点

 

            list构造函数

                    函数原型：

                            list<T> lst;        //list采用模板类实现，对象的默认构造形式

                            list(beg,end);    //构造函数将[beg，end）区间中的元素拷贝给本身

                            list(n,elem);    //构造函数将n个elem拷贝给本身

                            list(const list &lis);   //拷贝构造函数

 

            list赋值与交换

                    函数原型：

                            assign(beg,end);       //将[beg，end)区间中的数据拷贝赋值给本身

                            assign(n,elem);         //将n个elem拷贝赋值给本身

                            list& operator=(const  list  &lst);  //重载符号操作符

                            swap（lst）；       //将lst与本身的元素交换

 

            list大小操作

                    函数原型

                            size();             //返回容器中元素的个数

                            empty();         //判断容器是否为空

                            reszie（num）；  //重新指定容器的长度为num，若容器变长，则以默认值填充新位置；如果容器变短，则末尾超出容器长度的元素被删除

                           reszie（num，elem）；  //重新指定容器的长度为num，若容器变长，则以elem值填充新位置；若容器变短，则末尾超出容器长度的元素被删除。

 

            list插入和删除

                    函数原型：

                            push_back(elem);     //在容器尾部加入一个元素

                            pop_back();              //删除容器中最后一个元素

                            push_front(elem);    //在容器开头插入一个元素

                            pop_front();             //从容器开头移除第一个元素

                            insert(pos,elem);     //在pos位置插elem元素的拷贝，返回新数据的位置 

                            insert(pos,n,elem);   //在pos位置插n个elem元素，无返回值

                            insert(pos,beg,end); //在pos位置插入[beg,end)区间的数据，无返回值

                            clear();                      //移除容器的所有数据

                            erase(beg，end);     //删除[beg，end)区间的数据，返回下一个数据的位置

                            erase(pos);             //删除pos位置的数据，返回下一个数据的位置

                            remove(elem);       //删除容器中所有与elem值匹配的元素

 

            list数据存取

                    函数原型：

                            front();    //返回第一个元素
                            back();        //返回最后一个元素

 

            list反转和排序

                    函数原型：

                            reverse();     //反转链表

                            sort();          //链表排序，默认升序排列

 

9、常用容器--set/multiset

            set基本概念

                    简介：所有元素都会在插入时自动排序

                    本质：set/multiset属于关联式容器，底层结构是采用二叉树实现

                    set和multiset区别：

                                set不允许容器中有重复的元素

                                multiset允许容器中有重复的元素

 

            set构造

                    set<T> st;     //默认构造

                    set(const set &st);    //拷贝构造

            set赋值

                    set&  operator=(const set &st);     //重载等号操作符

                    

            set大小和交换

                    size();    //返回容器中元素的数目

                    empty();   //判断容器是否为空

                    swap();    //交换两个集合容器

 

            set插入和删除

                    insert(elem);    //在容器中插入元素

                    clear();            //清除所有元素

                    erase(pos);     //删除pos迭代器所指的元素，返回下一个元素的迭代器

                    erase(beg,end）； //删除区间[beg,end)内的所有元素，返回下一个元素的迭代器

                    erase(elem);    //删除容器中值为elem的元素

 

 

            set查找和统计

                    功能：对set容器进行查找数据以及统计数据

                    函数原型：

                            find(key);   //查找key是否存在，若存在，返回该键值的元素的迭代器；若不存在，返回set.end();

                            count(key);  //统计key的元素个数

 

            set和multiset区别：

                    1.set不可以插入重复数据，而multiset可以

                    2.set插入数据的同时会返回插入结果，表示插入是否成功

                    3.multiset不会检测数据，因此可以插入重复数据

 

            pair对组创建

                    功能：成对出现的数据，利用对组可以返回两个数据

                    第一个数据first，第二个数据second。

                    创建方式：pair<type，type>  p(value1，value2);

                                    pair<type，type>  p = make_pair(value1, value2);

 

              set容器排序

                    默认升序排列

                       利用仿函数，可以改变规则 

                        仿函数

                        class   函数名

                        {

                            public：

                                    bool  operator（）（参数列表）

                                            {   return 比较方式 }

                                }

 

  10、常用容器--map/multimap容器

            基本概念

                    简介：

                            map中所有元素都是pair

                            pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值）

                            所以元素都会根据元素的键值自动排序

                    本质：

                            map/multimap属于关联式容器，底层结构是用二叉树实现

                    优点：

                            可以根据key值快速找到value值

                    map和multimap：

                            map不允许容器中有重复key值元素

                            multimap允许容器中有重复key值元素

 

            map构造和赋值

                    构造：

                            map<T> mp;    //map默认构造

                            map(cont map &map);  //拷贝构造函数

                    赋值：

                            map& operator=（const  map &map）；  //重载等号操作符

 

            map大小和交换

                    size();    //返回容器中元素的数目

                    empty();   //判断容器是否为空

                    swap();    //交换两个集合容器         

 

            map插入和删除

                    insert(elem);    //在容器中插入元素

                                第一种：m.insert（pair<数据类型,数据类型>（1,10））

                                第二种：m.insert（make_pair（2,20））；

                                第三种：m.insert（map<int,int>::value_type（3,30））

                                第四种：m[4]=40;  //[]不建议插入，用途可以利用key访问value

                    clear();            //清除所有元素

                    erase(pos);     //删除pos迭代器所指的元素，返回下一个元素的迭代器

                    erase(beg,end）； //删除区间[beg,end)内的所有元素，返回下一个元素的迭代器

                    erase(key);    //删除容器中值为key的元素 

            

             map查找和统计

                    功能：对map容器进行查找数据以及统计数据

                    函数原型：

                            find(key);   //查找key是否存在，若存在，返回该键值的元素的迭代器；若不存在，返回map.end();

                            count(key);  //统计key的元素个数

                    map不允许插入重复的key元素，count统计而言  结果要么是0，要么是1；multimap的count统计可能大于1。

 

              map容器排序

                        默认按照key值，升序排列。可以通过仿函数改变规则。