c++笔记之stl

stl都在std命名空间中;




string
取值：
[]方式，如果访问越界，直接挂了
at方式，如果越界，抛出out_of_rang异常


方法：
 拼接操作：
string& append(const char *s); 把字符串s连接到当前字符串尾
string& append(const char *s,int n); 把字符串s的前n个字符连接到当前字符串尾
string& append(const char &s);
string& append(const char &s，int pos，int n); 把字符串s中从pos开始的n个字符连接到当前字符串尾
string& append(const char &s，char c); 在当前字符串尾添加n个字符c


查找和替换：
int find(const srting& str,int pos = 0) const; 从pos位置开始查找str第一次出现的位置
int find(const char* s,int pos = 0) const; 从pos位置开始查找s第一次出现的位置
int find(const char* s,int pos,int n) const; 从pos位置开始查找s的前n个字符第一次出现的位置
int find(const char c,int pos = 0) const; 从pos位置开始查找字符c第一次出现的位置
int rfind(const srting& str,int pos = npos) const; 从pos位置开始查找str最后一次出现的位置
int rfind(const char* s,int pos = npos) const; 从pos位置开始查找s最后一次出现的位置
int rfind(const char* s,int pos,int n) const; 从pos位置开始查找s的前n个字符最后一次出现的位置
int rfind(const char c,int pos = 0) const; 从pos位置开始查找字符c最后一次出现的位置
string& replace(int pos,int n, const string& srt); 替换从pos位置开始n个字符为字符串str
srting& replace(int pos,int n, const char* s); 替换从pos位置开始n个字符为字符串s


比较操作：
    大于返回1，小于返回-1，等于返回0；
int compare(const string& s) const; 于字符串比较
int compare(const char* c) const; 于字符串c比较


子串：
string substr(int pos = 0,int n = npos) const; 返回从pos位置开始的n个字符组成的字符串


插入和删除操作：
srting& insert(int pos,const char* c); 从pos位置开始插入字符串c
srting& insert(int pos,const string& str); 从pos位置开始插入字符串str
srting& insert(int pos，int n, char c); 从pos位置开始插入n个字符c
srting& erase(int pos,int n = npos); 删除从pos位置开始的n个字符


序列式容器
   每个元素都有固定的位置--取决于插入的时机和地点，和元素值无关
   vector  deque  list


vector
   将元素置于一个动态数组加以管理
   可以随机存取元素（用索引直接存取）
   数组尾部添加或移除元素非常快速，但在中部和头部安插元素比较费时
   
   使用场景：
   如：软件历史操作记录：经常查看，不经常删除

构造函数：
vector<T> v; 默认构造函数
vector<T> v2(v.begin(),v.end()); 将v[[begin(),end())区间中的元素拷贝给本身
例：
int arr[] = {10,20,30,40};
vector<int> v2(arr,arr + sizeof(arr)/sizeod(int));
vector<int> v3(v2,begin(),v2,end());
vector<T> v(n,elem) 构造函数将n个elem拷贝给本身
vector<T> v(const vector &vec） 拷贝构造
赋值操作：
assign(begin,end) 将区间[begin，end)中的数据拷贝赋值给本身
例：
int arr[] = {10,20,30,40};
vector<int> v;
v.assign(arr,arr + sizeof(arr)/sizeod(int));
assign(n,elem) 将n个elem拷贝赋值个本身
vector& operator=(const vector &vec)  重载=操作符
swap(vector vec); 将vec于本身交换


大小操作：
size(); 返回容器中元素的个数；
empty(); 判断容器是否为空；
resize(int num);重新指定容器的长度，若容器变长，则以默认值填充新位置，如果变短，则末尾超出容器长度的元素被删除
resize(int num，T elem);重新指定容器的长度，若容器变长，则以elem填充新位置，如果变短，则末尾超出容器长度的元素被删除
capacity(): 容器的容量

list


使用场景：
如：公交车乘客的储存，随时可能有乘客下车，支持频繁的不确定位置元素的移除插入

翻转排列排序：
reverse(); 反向操作
sort(); 排序，注：成员函数，不是算法函数
list<int> mylist1;
list<int> mylist2;
mylist1.sort();   排序
mylist1.uniqe();   排好序后删除重复的元素
mylist2.sort();
mylist1.merge(mylist1);   排好序后合并两链表     
mylist1.erase(mylist.end()-1);  删除最后一个元素，记得减一,因为此时迭代器指向最后一个元素的下一个位置


关联式容器
   元素位置取决于特定的排序准则。和插入顺序无关
   set  multiset  map  multimap


set         是一颗红黑树，重复元素会被舍弃


使用场景：
如：对手机游戏的个人得分记录的储存，储存要求从高分到低分的顺序排列


插入和删除操作：
insert(elem) 在容器中插入元素
clear(); 清除所以元素
erase(pos): 删除迭代器所指的元素，返回下一个元素的迭代器
erase(beg,end); 删除区间[beg，end)中的所以元素，返回下一个元素的迭代器
erase(elem); 删除容器中值为elem的元素

查找：
find(key); 查找键key是否存在，若存在，返回该键的元素迭代器，若不存在，返回map.end();
lower_bound(keyElem); 返回第一个key>=keyElem元素的迭代器
upper_bound(keyElem); 返回第一个key>keyElem元素的迭代器
equal_range(keyElem); 返回容器中key和key相等的上下限的两个迭代器，就是返回一个对组（pair）
pair<int,int> pair1(10,20);
pair<int,string> pair2 = make_pair(10,"aaa");
pair<int,string> pair3 = pair2;
pair1.first 就是第一个类型的值
pair1.second 就是第二个类型的值



nultiset    重复元素不会舍弃


<stack>   栈


<queue>   队列
使用场景：
排队购票系统，对排队者的储存可以采用deque，支持头端的快速移除，尾端的快速插入
如果采用vector，则头端移除时，会移动大量数据，速度慢

<deque>   双端队列






<map>
使用场景：
如：按ID号储存十万个用户，想要通过Id查找对应的用户。二叉树的查找效率，这时候就体现出来了。


具有键值(key)和实值(value)
初始化
map<int, int> mymap; 第一个类型key的类型，第二个value类型

插入方式：
mymap.insert(pair<int,int>(1,1));
mymap.insert(make_pair(2,3);
mymap.insert(map<int,int>::value_type(3,3));
mymap[4]=4;


vector于deque的比较：
vector.at()比deque.at()高，
如果有大量释放操作的话，vector花的时间更少，
deque支持头部的快速插入和快速移除