13.标准模板库(STL)

1.定义

C++ STL (Standard Template Library标准模板库) 是通用类模板和算法的集合，它提供给程序员一些标准的数据结构的实现如 queues(队列), lists(链表), 和 stacks(栈)等.

2. Vector 向量容器

Vectors 包含着一系列连续存储的元素,其行为和数组类似。

2.1.构造函数

vector();
vector( size_type num, const TYPE &val ); //把 num 个 val 的值放到该容器中 
vector( const vector &from );//拷贝构造函数 
vector( input_iterator start, input_iterator end );//利用迭代器进行区间赋值

2.2.支持的运算符

2.3. vector 函数接口的使用

push_back 函数 
语法: 
  	void push_back( const TYPE &val );
	push_back()添加值为val的元素到当前vector末尾
   
    
size 函数 
语法: 
  	size_type size();
	size() 函数返回当前vector所容纳元素的数目 

   
void pop_back();
pop_back()函数删除当前vector最末的一个元素

2.4.vector 迭代的定义

每个stl 模板接口都有一个专用的迭代器。

vector<int>::iterator it;   

补充： stl 库中的迭代器

迭代器就是 stl 库中的 一个特殊指针，功能与指针类似
官方的迭代器使用 demo:

begin 函数 
语法: 
  iterator begin();

 

begin()函数返回一个指向当前vector起始元素的迭代器.例如,下面这段使用了一个迭代器来显示出vector中的所有元素:

vector<int> v1( 5, 789 );
vector<int>::iterator it;
for( it = v1.begin(); it != v1.end(); it++ )
  cout << *it << endl;

相关内容: end(). 
    
    
end 函数 
语法: 
  iterator end();
end() 函数返回一个指向当前vector末尾元素的下一位置的迭代器.注意,如果你要访问末尾元素,需要先将此迭代器自减1.

相关内容: begin() 

• vector 删除接口的使用

  
    iterator erase( iterator loc );  //删除迭代器所指向的值 
    							   	   //返回值：一个新的迭代器 
    iterator erase( iterator start, iterator end );
    //删除 start 迭代器  -》 end 迭代器区间的值 
  
  

• vector 容器的插入接口的使用

  iterator insert( iterator loc, const TYPE &val ); //在 loc 位置插入 val  
  void insert( iterator loc, size_type num, const TYPE &val );//在 loc 位置 插入 num个val 
  void insert( iterator loc, input_iterator start, input_iterator end); //loc 位置上插入 区间 start -> end 
  

3.双向队列

双向队列和向量很相似，但是它允许在容器头部快速插入和删除（就像在尾部一样）。
特点可以操作头部数据：

pop_front 
语法: 
  void pop_front();
pop_front()删除双向队列头部的元素
    
push_front 
语法: 
  void push_front( const TYPE &val );
push_front()函数在双向队列的头部加入一个值为val的元素。

4.Lists（链表）

Lists将元素按顺序储存在链表中. 与 向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却比较慢.

• 构造函数

  list<int> first;                                // 定义一个空链表
  list<int> second (4,100);                       // 往链表中插入4个100 
  list<int> third (second.begin(),second.end());  // 把一个区间的值赋值给链表
  list<int> fourth (third);                       // 拷贝构造函数
  

• 接口说明

  merge 
  语法: 
    void merge( list &lst );
    void merge( list &lst, Comp compfunction );
  	
    merge()函数把自己和lst链表连接在一起，产生一个整齐排列的组合链表。如果指定compfunction，则将指定函数作为比较的依据
  
      
  排序(sort) 
  语法: 
    void sort();
    void sort( Comp compfunction );
    sort()函数为链表排序，默认是升序。如果指定compfunction的话，就采用指定函数来判定两个元素的大小。
  
      
  remove 
  语法: 
    void remove( const TYPE &val );
    remove()函数删除链表中所有值为val的元素。例如 
  
    
  reverse 
  语法: 
    void reverse();
    reverse()函数把list所有元素倒转
  
  unique 
  语法: 
    void unique();  //删除重复的元素  
  

  使用例子：

  // list::merge
  #include 
  #include 
  using namespace std;
  
  // this compares equal two doubles if
  //  their interger equivalents are equal
  bool mycomparison (double first, double second)
  { return ( int(first)<int(second) ); }
  
  int main ()
  {
      //定义两条链表
    list<double> first, second;
   //往第一条插入数据
    first.push_back (3.1);
    first.push_back (2.2);
    first.push_back (2.9);
   //往第二条插入数据
    second.push_back (3.7);
    second.push_back (7.1);
    second.push_back (1.4);
  
    //进行链表排序 
    first.sort();
    second.sort();
     
    //合并两条链表
    first.merge(second);
  
    second.push_back (2.1);
  
     //再次合并  并指定合并的排序方式 
    first.merge(second,mycomparison);
  
    cout << "first contains:";
    for (list<double>::iterator it=first.begin(); it!=first.end(); ++it)
      cout << " " << *it;
    cout << endl;
  
    return 0;
  } 
  

5.Set 二叉树

集合(Set)是一种包含已排序对象的关联容器 （相等于二叉树）

• 构造函数

  // constructing sets
  #include 
  #include 
  using namespace std;
  struct classcomp {
    bool operator() (const int& lhs, const int& rhs) const
    {return lhs<rhs;}
  };
  
  int main ()
  {
    set<int> first;                           //定义空的set容器
  
    int myints[]= {10,20,30,40,50};
    set<int> second (myints,myints+5);        //往set容器中插入5个数据 
  
    set<int> third (second);                  //拷贝构造函数 
  
    set<int> fourth (second.begin(), second.end());  //迭代器的方式赋值
  
    set<int,classcomp> fifth;                 // 指定插入的比较方法
  
    return 0;
  }
  

• 插入数据

  iterator insert( iterator i, const TYPE &val );
  
  void insert( input_iterator start, input_iterator end );
  
  pair insert( const TYPE &val );
   
  

  • set 插入自定义的数据类型
    1. 重载 比较运算符 ,提示重载参数：需要添加const

       #include 
       using namespace std; 
       #include  
        //练习:利用 set 容器，插入自定义的 person 数据 ,姓名，年龄，根据年龄插入。 
       class  person
       {
       public: 
          person(string n,int a):name(n),age(a){}
       string  name; 
       int age;
       
       friend bool operator<(person &a,person &b);
       };
       
       
       //重载比较运算符
       bool operator<(const person &a,const person &b)
       {
           return  a.age <  b.age;
       }
       int main()
       {
           //定义一个 set 容器 
           set<person>  s;
       
           person a("小明",10);
           person a1("小花",19);
           person a2("小东",7);
       
           //插入数据 
           s.insert(a);
           s.insert(a1);
           s.insert(a2);
       
           for(auto it=s.begin();it!=s.end();it++)
          {
              cout  << it->name << endl;
              cout  << it->age << endl;
          }
           
       }
       

    2. 在定义set 容器的时候说明比较方法

       //重新定义比较的方法 
       struct classcomp {
         bool operator() (const person& lhs, const person& rhs) const
         {return lhs.age>rhs.age;}
       };
       
       int main()
       {
           //定义一个 set 容器 
           set<person,classcomp>  s;
           person a("小明",10);
           person a1("小花",19);
           person a2("小东",7);
           //插入数据 
           s.insert(a);
           s.insert(a1);
           s.insert(a2);
           for(auto it=s.begin();it!=s.end();it++)
          {
              cout  << it->name << endl;
              cout  << it->age << endl;
          } 
       }
       

6. map 容器的使用 （重点）

C++ map 是一种关联式容器，包含 键值对 key/value ，即每一个 key 对应一个 value
在map 容器中，所有的数据都是成对存在的。 -> pair 对组

• pair 对组的使用
  

• map 容器的构造函数

  // constructing maps
  #include 
  #include 
  using namespace std;
  
  struct classcomp {
    bool operator() (const char& lhs, const char& rhs) const
    {return lhs<rhs;}
  };
  
  int main ()
  {
    map<char,int> first; //定义一个空的 map 容器 
      
   //往map容器中插入数据
    first['a']=10;
    first['b']=30;
    first['c']=50;
    first['d']=70;
  
    map<char,int> second (first.begin(),first.end()); //赋值一个区间 
  
    map<char,int> third (second);//拷贝构造函数
  
    map<char,int,classcomp> fourth;        //设置map 容器的排序方法 
  
    return 0;
  }
  

• map插入数据的方法

   //在pos 的位置插入 pair 
  iterator insert( iterator pos, const pair<KEY_TYPE,VALUE_TYPE> &val );
  //插入 start -》 end 的区间值 
    void insert( input_iterator start, input_iterator end );
  
  //直接插入  pair 
    pair<iterator, bool> insert( const pair<KEY_TYPE,VALUE_TYPE> &val );
  

• 重载下标后的插入方法

  // accessing mapped values
  #include 
  #include 
  #include 
  using namespace std;
  
  int main ()
  {
    map<char,string> mymap;
    map<char,string>::iterator it;
  	
    //重载后的下标插入方法  
    mymap['a']="an element";
    mymap['b']="another element";
    mymap['c']=mymap['b'];
  
       //重载后的下标 取出value的方法
    cout << "mymap['a'] is " << mymap['a'] << endl;
    cout << "mymap['b'] is " << mymap['b'] << endl;
    cout << "mymap['c'] is " << mymap['c'] << endl;
    cout << "mymap['d'] is " << mymap['d'] << endl;
  
    cout << "mymap now contains " << (int) mymap.size() << " elements." << endl;
  
    return 0;
  }
  
  //语法说明： 
  对象名[key] = value;    //赋值  
  
  变量 = 对象名[key]     //取值 
  

• map 的查找方法 （使用最多）

  find 
  语法: 
  	iterator find( const KEY_TYPE &key );
  
  
  find()函数返回一个迭代器指向键值为key的元素，如果没找到就返回指向map尾部的迭代器。
  
  //通过 key 找到 value