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