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 <iostream>
#include <list>
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 <iostream>
#include <set>
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 插入自定义的数据类型

重载比较运算符 ,提示重载参数：需要添加const

#include <iostream>
using namespace std; 
#include <set> 
 //练习:利用 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;
   }
    
}

在定义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 <iostream>
#include <map>
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 <iostream>
#include <map>
#include <string>
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

原文链接：https://blog.csdn.net/weixin_44693625/article/details/123925211

13.标准模板库(STL)

目录

1.定义

2. Vector 向量容器

2.1.构造函数

2.2.支持的运算符

2.3. vector 函数接口的使用

2.4.vector 迭代的定义

补充： stl 库中的迭代器

3.双向队列

4.Lists（链表）

5.Set 二叉树

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

目录

1.定义

2. Vector 向量容器

2.1.构造函数

2.2.支持的运算符

2.3. vector 函数接口的使用

2.4.vector 迭代的定义

补充： stl 库中的迭代器

3.双向队列

4.Lists（链表）

5.Set 二叉树

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

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