C++(8) STL 一

STL详解 一

1.三大组件

容器 :任何特定的数据结构都是为了实现某种特定的算法。STL容器就是将运用最广泛的一些数据结构实现出来。

数组(array) , 链表(list), tree(树)，栈(stack), 队列(queue), 集合(set),映射表(map)

这些数据分为序列式容器(强调值的排序，序列式容器中的每个元素均有固定的位置，除非用删除或插入的操作改变这个位置。) 和关联式容器(是非线性的树结构，更准确的说是二叉树结构。) 两种。

算法:

算法分为:质变算法和非质变算法 。

质变算法：是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等等 非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等

迭代器:

其中iterator模式定义如下：提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。

迭代器的设计思维-STL的关键所在，STL的中心思想在于将容器(container)和算法(algorithms)分开，彼此独立设计，最后再一贴胶着剂将他们撮合在一起。

2.string容器

1.数据结构：连续的存储空间，用一个char*指向这片空间

2.迭代器:随机访问迭代器

3.常用的api：

1.构造

 string(); //创建一个空的字符串 例如: string str;
 string(const char* s); //使用字符串s初始化
 string(const string& str); //使用一个string对象初始化另一个string对象
 string(int n, char c); //使用n个字符c初始化

 

2.基本赋值

 string& operator=(const char* s); //char*类型字符串 赋值给当前的字符串
 string& operator=(const string &s); //把字符串s赋给当前的字符串
 string& operator=(char c); //字符赋值给当前的字符串
 string& assign(const char *s); //把字符串s赋给当前的字符串
 string& assign(const char *s, int n); //把字符串s的前n个字符赋给当前的字符串
 string& assign(const string &s); //把字符串s赋给当前字符串
 string& assign(int n, char c); //用n个字符c赋给当前字符串

3.存取字符

 char& operator[](int n); //通过[]方式取字符
 char& at(int n); //通过at方法获取字符

4.拼接

 string& operator+=(const char* str); //重载+=操作符
 string& operator+=(const char c); //重载+=操作符
 string& operator+=(const string& str); //重载+=操作符
 string& append(const char *s); //把字符串s连接到当前字符串结尾
 string& append(const char *s, int n); //把字符串s的前n个字符连接到当前字符串结尾
 string& append(const string &s); //同operator+=(const string& str)
 string& append(const string &s, int pos, int n);//字符串s中从pos开始的n个字符连接到字符串结尾
 ​

5.查找和替换

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

6.比较

 int compare(const string &s) const; //与字符串s比较
 int compare(const char *s) const; //与字符串s比较
 //返回0是相等 返回1是不相等

7.子串->返回对应字符后面的字符串

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

8.插入和删除

 string& insert(int pos, const char* s); //插入字符串
 string& insert(int pos, const string& str); //插入字符串
 string& insert(int pos, int n, char c); //在指定位置插入n个字符c
 string& erase(int pos, int n = npos); //删除从Pos开始的n个字符

9.string和const char*转换

 const char *str = "hello";
     string s=string(str);
     cout << s << endl;
 ​
     const char *str2=s.c_str();
     cout << str2 << endl;

4.常用的api中的注意:

1.[]和at区别：[]如果越界，不抛异常，直接挂。at会抛异常

2.字符串内存重新分配，[]和at获取的字符引用，再次使用时，可以能会出错

3.string和char *的区别：string是一个类，char *是一个指针

 void test10()
 {
     string s = "abcde";
     char &a = s[2];
     char &b = s[3];
     a = '1';
 b = '2';
 cout << "a:" << a << endl;
 cout << "b:" << b << endl;
 cout << s << endl;
 cout << "字符串的原空间地址:" << (int*)s.c_str() << endl;
 ​
 s = "fdasfdasfdsafdasherewrkewhsaferew";
 cout << "字符串的空间地址:" << (int*)s.c_str() << endl;
 ​
 //原空间被释放，但是a还是被释放的s[2]空间的别名，如果操作非法的空间，会出错
 //a = '3';
 }

5.//用迭代器遍历字符串

 void test11()
 {
     string s = "hello";
     for (string::iterator it = s.begin(); it != s.end(); ++it)
     {
         cout << *it << " ";
     }
     cout << endl;
 ​
     //反向遍历
     for (string::reverse_iterator it = s.rbegin(); it != s.rend(); ++it)
     {
         cout << *it << " ";
     }
     cout << endl;
 }

3.vector容器

1.数据结构:连续存储空间

2.迭代器：随机迭代器

 void printVector(const vector<int> &vec)
 {
     for (vector<int>::const_iterator it = vec.begin(); it != vec.end(); ++it)
     {
         cout << *it << " ";
     }
     cout << endl;
 }

3.vector容器动态增长原理

1.当存储空不够时，会开辟另一块大的空间，然后把数据拷贝过去，最后在销毁原来的空间

2.申请的空间,会比用户需求大一点

3.重新分配空间，那么原来的迭代器就会失效

4.常用的api:

1.构造

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

2.赋值操作

 assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
 assign(n, elem);//将n个elem拷贝赋值给本身。
 vector&operator=(const vector  &vec);//重载等号操作符
 swap(vec);// 将vec与本身的元素互换。

3.大小操作

 //大小操作
 size();//返回容器中元素的个数
 empty();//判断容器是否为空
 resize(int num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
 resize(int num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长>度的元素被删除。
 capacity();//容器的容量
 reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。

4.数据存取

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

5.插入和删除

 ​
 插入和删除操作
 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();//删除容器中所有元素
 ​
 ​

5.常用的api中的注意:

1.resize开辟空间，并初始化。reserve开辟空间，但不初始化.没有初始化的空间不能访问

6.reserve作用：如果容器要存储大量数据时，要先开辟空间，避免多次申请空间

7.swap作用:缩小容器的容量

07.deque容器

1.数据结构:逻辑上是连续的存储空间，实际上的由很多块定量的块空间，通过中控制连接起来

底层数据结构

deque则是一种双向开口的连续数据空间。所谓的双向开口，意思是可以在头尾两端分别做元素的插入和删除操作。

接着上面讲。deque由一段一段的连续空间所链接而成，一旦需要在deque的前端或尾端增加新空间，便配置一段定量的连续空间，并将该空间串接在deque的头部或尾部。deque复杂的迭代器架构，构建出了所有分段连续空间”整体连续“的假象。

2.迭代器:随机迭代器

 void printDeque(const deque<int> &deq)
 {
     for (deque<int>::const_iterator it = deq.begin(); it != deq.end(); ++it)
     {
         cout << *it << " ";
     }
     cout << endl;
 }

3.常用的api：

1.构造

 deque<T> deqT;//默认构造形式
 deque(beg, end);//构造函数将[beg, end)区间中的元素拷贝给本身。
 deque(n, elem);//构造函数将n个elem拷贝给本身。
 deque(const deque &deq);//拷贝构造函数。

2.赋值

 assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
 assign(n, elem);//将n个elem拷贝赋值给本身。
 deque&operator=(const deque &deq); //重载等号操作符
 swap(deq);// 将deq与本身的元素互换

3.大小

 deque.size();//返回容器中元素的个数
 deque.empty();//判断容器是否为空
 deque.resize(num);//重新指定容器的长度为num,若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
 deque.resize(num, elem); //重新指定容器的长度为num,若容器变长，则以elem值填充新位置,如果容器变短，则末尾超出容器长度的元素被删除。

4.双端插入和删除操作

 双端插入和删除操作
 push_back(elem);//在容器尾部添加一个数据
 push_front(elem);//在容器头部插入一个数据
 pop_back();//删除容器最后一个数据
 pop_front();//删除容器第一个数据

5.数据查找

 at(idx);//返回索引idx所指的数据，如果idx越界，抛出out_of_range。
 operator[];//返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错。
 front();//返回第一个数据。
 back();//返回最后一个数据

5.插入和删除操作

 

 插入操作
 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位置的数据，返回下一个数据的位置。

下载地址
https://kxd.lanzoul.com/iFudU0zjt7sj