13.标准模板库(STL)

目录

  • 1.定义
  • 2. Vector 向量容器
    • 2.1.构造函数
    • 2.2.支持的运算符
    • 2.3. vector 函数接口的使用
    • 2.4.vector 迭代的定义
      • 补充: stl 库中的迭代器
  • 3.双向队列
  • 4.Lists(链表)
  • 5.Set 二叉树
  • 6. map 容器的使用 (重点)

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.支持的运算符

13.标准模板库(STL)_第1张图片

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;   

13.标准模板库(STL)_第2张图片

补充: 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)是一种包含已排序对象的关联容器 (相等于二叉树)
13.标准模板库(STL)_第3张图片

  • 构造函数
    // 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 对组的使用
    13.标准模板库(STL)_第4张图片

  • 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  
    

你可能感兴趣的:(cpp,c++,标准模板库)