STL容器简单介绍

string

string是一个类，定义在头文件<string>中

构造方法

string str; //无参构造
string();//创建了一个空字符串相当于string str;
string(const string& str)//使用一个string对象初始化另一个string对象
string(const char*s)//使用字符串s初始化
string(int n,char c)//使用n个字符c初始化

基本赋值操作

//operator=是重写了=号运算符和函数的重载
string& operator=(const char*s)//char*类型字符串 赋值给当前的字符串
string& operator=(const string&s)//把字符串s赋给当前的字符串
string& operatro=(char c)//把字符赋值给当前的字符串
//assing是成员方法和函数的重载
string& assign(const char*s)把字符串s赋值给当前的字符串
string& assign(const char*s,int n)把字符串s的前n个字符赋值给当前的字符串
stirng& assign(const string&s)把字符串s赋给当前字符串
string& assign(int n,char c)把n个字符c赋值给当前字符串
string& assign(const string &s,int start,int n)将s从start开始n个字符赋值给当前字符串

string存取字符操作

//重写了[]
char& operator[](int n)//通过[]方式取字符
//string 成员方法
char& at(int n)//通过at方法获取字符
区别：通过[]索引越界会直接崩掉
at会抛出异常

string拼接

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

string&operator+=(const char* str)

string&operator+=(const char c)

string&append(const char*s)

string&append(const char*s,int n)//把当前字符串的前n个字节添加到字符串结尾

string&append(cosnt string &s)

string&append(const string &s,int pos,int n)//把字符串s从pos开始的n个字符添加到结尾

string&append(int n,char c)//当前字符串结尾添加n个字符c

string查找

找不到返回-1；
int fand(const string& str,int pos=0)const;//查找str第一次出现的位置，从pos开始查找
int fand(const char*s,int pos=0)const;查找s第一次出现的位置，从pos开始查找
int fand(const char*s,int pos,int n)const;//从pos位置开始查找s前n个字符第一次出现的位置
int fand(const char c,int pos=0)const;//从pos开始查找字符c第一次出现的位置
int rfand(const string& str,int pos=npos)const;//查找str最后出现的位置，从pos开始查找
int rfand(const char*s,int pos=npos)const;//查找s最后出现的位置，从pos开始查找
int rfand(const char*s,int pos,int n)const;从pos位置开始查找s前n个字符最后出现的位置
int rfand(const char c,int pos=0)const;从pos开始查找字符c最后出现的位置

string替换

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

string比较

大于时返回1，小于时返回-1;==时返回0；

int compare(const string &s)const;

int compare(const char*s)const;

string子串

string& substr(int pos=0;int n=npos)const;//返回从pos开始的n个字符组成的字符串

string插入

string& insert(int pos,const char* s)//在pos位置插入字符串

string&insert(int pos,const string&str)

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

string删除

string& erase(int pos,int n=npos)//删除从pos开始的n个字符

string和c-style字符串转换

从string转char*

string str="itcast";

const char* cstr=str.c_str();
//从char*转string
char * s="itcast";
string str(s);

string小写转大写

string& toupper(char&c);

不用考虑内存释放和越界

vector(动态数组)容器

使用场景：比如软件历史操作记录的存储，

头文件 <vector>

vector构造函数

vector<T> v;//默认构造函数，采用模板实现类实现
vector(v.begin(),v.end());//将v.begin(),v.end()区间的元素拷贝给本身
vector(n,elem)//将n个elem拷贝给本身
vector(cosnt vector &vec)//拷贝构造函数

vector常用赋值操作

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

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

vector& operator=(const vector& vec)//重载等号操作符

seap(vec)//将vec于本身的元素互换

vector大小操作

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

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

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

capaci()//容器的大小

reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问

利用swap()收缩空间

vector<类型>(v).swap(v);//去除无用空间

vector数据存取

at(int idx)//返回索引idx所指的数据，如果idx越界，抛出out_of_range异常
operatro[];//返回索引idx所指的数据，越界时，运行直接报错
front()返回容器中第一个元素
back()//返回容器中最后一个数据元素
swap()交换元素

vector插入和删除

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

push_back(ele);//尾部插入一个元素ele

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

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

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

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

deque(双向开口的动态数组)容器

使用场景：比如排队购票系统

构造函数

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

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

deque(n,elem);//将n个elem拷贝给本身

deque(const deque&deq)拷贝构造函数

deque赋值

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

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

deque& operator=(const deque&deq)//重载等号操作符

swap(deq)//将deq与本身的元素互换

deque大小操作

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

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

deque.resize(num)//重新指定容器的长度为num，若容器变长，则以默认值填充，若变短，则末尾超出容器长度的元素被删除

deque.resize(num,elem)//重新指定容器的长度为num,若容器变长，则以elem值填充新位置，如果容器变短，则末尾超出容器长度的元素被删除

deque双端插入和删除

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

push_front(elem)//在容器头部插入一个数据

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

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

deque数据存取

at(idx);//返回索引idx所指的数据，如果idx越界，抛出out_of_range

operator[]返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错

front()//返回第一个数据

back()//返回最后一个数据

deque插入操作

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

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

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

deque删除操作

clear()//删除操作

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

stack（栈）容器

stack构造函数

stackstkT;//默认构造，采用模板类实现

stack(const stack &stk);//拷贝构造函数

stack赋值

stack& operator=(const stack &stk)//重载=号

stack数据存取

push(elem)//向栈顶添加元素

pop()//从栈顶移除第一个元素

top()//返回栈顶元素

stack大小操作

empty()//判断是否为空

size()//返回堆栈大小

queue（队）容器

queue构造函数

queue<T> queT;//默认构造，采用模板类实现

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

queue存取、插入和删除

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

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

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

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

queue赋值

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

queue大小操作

empty()//判断队列是否为空

size()//返回队列的大小

list（双向链表）容器

使用场景：比如公交车乘客的存储

list构造函数

list<T>lstT//默认构造，采用模板类实现

list(beg,end)//将[beg,end]区间的元素拷贝给本身

list(n,elem)//将n个elem拷贝给本身

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

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大小

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

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

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

resize(num,elem)//重新指定容器的长度为num，若容器变长，则以elem填充新位置，如果容器变短，则末尾超出容器长度的元素被删除

list赋值操作

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

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

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

swap(list)//将list与本身的元素互换

list数据的存取

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

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

set和multiset容器（底层红黑树）

使用场景：比如对手机有效的个人得分记录的存储

set和multiset操作类似，默认从小到大排序
区别：set不允许键值重复，multiset允许键值重复

set构造函数

set<T> st;//set默认构造，采用模板设计
自定义对象要指定排序规则
mulitset<T> mst;//multiset默认构造函数

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

例：

//自定义类
class Person
{
public:
string name;
int age;
}
//排序类
class myComparePerson

{

public:
//仿函数
bool operator()(Person&p1,Person&p2)

{

return p1.age>p2.age;

}

}
set<Person,mycomparePerson> s;

set赋值

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

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

set大小操作

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

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

set插入和删除

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

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

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

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

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

set查找

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

count(key);//查找键key的元素的个数

lower_bound(KeyElem);//返回第一个key>=keyElem元素的迭代器

upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器

equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器,可以用pair接收

pair(对组)

pair<T,T> 有参构造

pair<string,int>p(string("tom"),12);

p.first第一个值

p.second第二个值

map和multimap容器（底层红黑树）

map和multimap操作类似,默认从小到大排序

区别multimap键值可以重复，map键值不可以重复

map构造函数

使用场景：比如按id号存储十万个用户

map<T1,T2>maptt//默认构造

map(const map&mp)//拷贝构造函数

map赋值操作

map&operator=(const map&mp)//重载等号操作符

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

map大小操作

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

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

map插入数据元素操作

map.insert(...)//往容器插入元素，返回pair<iterator,bool》
例：
map<int,string>mapStu;
//第一种通过pair方式插入对象
mapStu.insert(pair<int,string>(3,"tom"));
//第二种方式（推荐）
mapStu.inset(make_pair(-1,"小王"))
第三种通过value_type的方式插入对象（不推荐）
mapStu.inset(map<int,string>::value_type(1,"小李"));
//第四种 通过数组的方式插入值（如过key存在，可以通过这种方法访问）
map[3]="小刘"；
map[5]="小王"

map删除操作

clear()//删除所有元素

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

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

erase(keyElem)//删除容器中key为keyElem的对组

map查找

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

count(keyElem)//返回容器中key为keyElem的对组个数，对map来说，要么0，要么1，对multimap来说，值有可能大于1

lower_bound(keyElem)//返回第一个key>=keyElem元素的迭代器

lower_bound(keyElem)//返回第一个key>keyElem元素的迭代器

equal_range(keyElem)//返回容器中key与keyElem相等的上下限的两个迭代器

例 find()：

map<int,int>m;
map<int,int>::iterator pos=m.find(1);

equal_range()例：

map<int,int>m;
pair<map<int,int>::iterator,map<int,int>::iterator> ret=m.equal_range(keyElem)
m.first是第一个map
m.second是第二个map