一. STL
1.概念
STL(standard template libaray-标准模板库)：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。
2.版本
- 原始版本
Alexander Stepanov、Meng Lee 在惠普实验室完成的原始版本，本着开源精神，他们声明允许任何人任意运用、拷贝、修改、传播、商业使用这些代码，无需付费。唯一的条件就是也需要向原始版本一样做开源使用。 HP 版本–所有STL实现版本的始祖。
P. J. 版本
由P. J. Plauger开发，继承自HP版本，被Windows Visual C++采用，不能公开或修改，缺陷：可读性比较低，符号命名比较怪异。
RW版本
由Rouge Wage公司开发，继承自HP版本，被C+ + Builder 采用，不能公开或修改，可读性一般。
SGI版本
由Silicon Graphics Computer Systems，Inc公司开发，继承自HP版 本。被GCC(Linux)采用，可移植性好，可公开、修改甚至贩卖，从命名风格和编程 风格上看，阅读性非常高。我们后面学习STL要阅读部分源代码，主要参考的就是这个版本。
二. string类
2.1 为什么学习string类
- C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。
2. 标准库中的string类
string是在STL之前，并没有什么参考，它是独立弄出来的。so它可能偏乱偏多一些
- 首先，我们要学会看文档（此处注意，句子里的单词翻译的顺序并不是最佳的，只是反映了自己翻译时的第一反应）
string是在STL之前就设计出来了，所以比较复杂，总共有100多个接口（什么是接口，就是提供给我们，可以去调用的），但是我们只需要记住重要的20多个，剩下的使用时查询即可。
- 使用string类的时候，必须包含头文件
#include<string>以及using namespace std(这个可以选择不写) - string实际上是个模板，但是它的参数一定确定了，so我们不太用关注它。
- 先使用默认构造，构造一个空的字符串。
std::string str1;
2.2.1 构造（7个）
我们可以先简单看一看接口，进行猜测（它的参数的名字都是有意义的，所以猜测的还是很接近的）。具体的内容看下面的接口介绍
记住：initialize是初始化
规定：string的结尾一定是‘\0’结尾
#include<stdio.h>
#include<iostream>
using namespace std;
int main()
{
//1.创建空的字符串
string str1; //构造空的string类对象str1
//2.填充:string(size_t n, char c);
string str2(5, 'r'); //用5个'r'初始化
cout << str2 << endl;
//3.copy--->string(const string & str);
string str3(str2); //用str2初始化str3
cout << str3 << endl;
//4.from c-string--->string(const char* s);
char s1[5] = "abcd";
string str4(s1); //用字符串s1初始化str4
cout << str4 << endl;
//5.将字符串s的地址传过来，复制n个它的字符:string (const char* s, size_t n);
char s[4] = { 'a','b','c','d' };
string str5(s, 3); //用字符串s的前三个字符初始化str5
cout << str5 << endl;
//注意:字符串传递过去默认也是首地址
string str6("abcd", 3); //常量(const)字符串的类型的地址是const char*
cout << str6 << endl;
//6.substring--->string(const string & str, size_t pos, size_t len = npos);
string str7("abcdefghijklmn",14);
string str8(str7, 3, 9);
cout << str8 << endl;
//如果没有写复制几个字符，则拷贝到str7结束
string str9(str7, 3);
cout << str9 << endl;
return 0;
}
2.2.2 对string类对象进行“访问和修改”
一共有三种方法：下标+方括号；迭代器；范围for(看目录，在最后面写着呢)
（1）operator[]
std::string::operator[]的底层大致意思是：
class string
{
public:
char& operator[](size_t pos)
{
assert(pos < _size);//防止越界
return _str[pos];
}
private:
char* _str;
size_t _size;
size_t _capacity;
};
它是用来返回pos这个位置的字符的别名。
接下来，如何使用operator方括号呢？
- 可以用来修改某个位置的字符（因为是引用返回，so可直接修改）
#include<stdio.h>
#include<iostream>
#include<assert.h>
#include<string>
using namespace std;
int main()
{
//char& std::string::operator[](size_t pos)
string str1("abcdefg");
//str1.operator[](0)='p';
str1[0] = 'p';
std::cout << str1 << std::endl;
return 0;
}
- 可用来遍历string的每个字符
int main()
{
string str1("abcdefg");
for (size_t i = 0; i < str1.size(); i++)
{
cout << str1[i] << " ";
}
return 0;
}
循环遍历，将每个字符都加1
int main()
{
string str1("abcdefg");
for (size_t i = 0; i < str1.size(); i++)
{
//将所有的字符都加1
str1[i]++;
}
- 可以很好的防止越界
这个返回值不可以被修改
（2）迭代器
1.迭代器的使用
在此先声明，迭代器会先学习4种：迭代器，反向迭代器，const迭代器，const反向迭代器
（像指针一样的东西，但并不是指针）
- 迭代器的使用
begin()返回第一个位置的迭代器
end()指的是最后一个有效字符的下一个位置（即\0)的迭代器（\0是标识字符，不是有效字符）
#include <iostream>
#include<stdio.h>
#include<assert.h>
#include<string>
using namespace std;
int main()
{
string str1("hello world");
//在string这个类里面，有iterator这个类型
// 类域 :: 类型 定义的对象 begin()返回第一个位置的迭代器
string::iterator it1 = str1.begin();
while (it1 != str1.end()) //end()指的是最后一个字符的下一个位置
// 不到最后一个\0
{
cout << *it1 << " "; //it1是地址
it1++; //++就到下一个地址了，在解引用就是下一个字符
}
//在字符串打印完之后,换行
cout << endl;
return 0;
}
同样的，在遍历读取的时候，也可以修改数据。
while (it1 != str1.end())
{
(*it1)++;
cout << *it1 << " ";
it1++;
}
如果像倒着遍历，则使用反向迭代器
2.迭代器的价值（list）
（链表的那个list，带头双向循环的链表）
list的遍历和修改只能借助迭代器，push_back等等
#include <iostream>
#include<stdio.h>
#include<assert.h>
#include<string>
#include<list>
using namespace std;
int main()
{
list<int> lt1;
lt1.push_back(9);
lt1.push_back(8);
lt1.push_back(7);
lt1.push_back(6);
//定义list的迭代器
list<int>::iterator it1 = lt1.begin();
while (it1 != lt1.end())
{
cout << *it1 << " ";
it1++;
}
return 0;
}
3. 为什么有operator[]之后还需要迭代器
下标[]确实很方便，但并不是通用的。它只适用于string和vector（它们的底层是连续的物理空间）。
像链表等等，它们的结点的地址并没有什么大小关系。
（3） 范围for
在后面讲解
三. 补充的小知识点：auto（语法糖）
C++11引入
1.auto介绍
auto声明的变量：变量的类型由编译器在编译时期推导而得。（根据右边的值推导左边变量的类型）
- 在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，后来这个不重要了。C++11中，标准委员会变废为宝赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。
int main()
{
int i = 9;
int j = i;
//所以j的类型是int
//用auto自动推导类型
auto m = j; //右边变量j的类型是int.m的类型是int
auto n = 1.2;//右边常量1.2的类型是double,n的类型是double
return 0;
}
- 用auto声明引用类型时则必须加&
int main()
{
int i = 9;
int& j = i; //j是i的别名，是int&类型
//但是后面再使用j的时候，它的本质和i一样，是int类型
auto m = j; //j的本质还是int,所以m的类型也还是int
//用auto声明'引用类型'时则必须加&
auto& n = m; //m是int类，n是int&类
return 0;
}
- 当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量
auto aa = 1, bb = 2;
// 编译报错：error C3538: 在声明符列表中，“auto”必须始终推导为同一类型
auto cc = 3, dd = 4.0;
- 类型包含“auto”的符号必须具有初始值设定项
即不可以auto j;，没有初始值的话，就没有办法判断auto代表的什么类型，会报错。所以必须有初始值auto j = 4.3; - auto不可以做参数，可以作为函数返回值
// 不能做参数
void func2(auto a)
{}
// 可以做返回值，但是建议谨慎使用
auto func3()
{
return 3;
}
2.auto的使用价值
在前面介绍中所使用的案例，我们会觉得，也不需要编译器去判断呀，我们可以直接写它们的类型的。那么什么时候auto会很方便呢？
简化代码，替代类型很长的类型
在前面我们曾写过
string str1("aassddff");
std::string::iterator it1 = str1.begin();
在有了auto之后，可以怎么写呢？
string str1("aassddff");
//std::string::iterator it1 = str1.begin();
auto it1 = str1.begin();
四. 补充的小知识点：范围for（语法糖）
1.使用
C++11引入
简答：范围for是遍历容器的东西（底层是迭代器）
在此之前，对于一个有范围的集合，遍历都是程序员自己写循环的范围。而C++11引入的基于范围的for循环，不再需要程序员自己写循环的范围了。
书写：for后面括号里的内容，由冒号:分为两部分。第一个部分：变量（被迭代的变量，变量名自己写）；第二个部分：被迭代的集合。【自动迭代，自动取数据，自动判断结束。】
自动迭代(即：自动取容器的数据赋值给左边的值)
- 范围for可以作用到数组和容器对象上进行遍历
- 范围for的底层很简单，容器遍历实际就是替换为迭代器，这个从汇编层也可以看到
int main()
{
string str1("aassddff");
// 变量名:迭代的范围(集合)
for (char ch : str1)
cout << ch << " ";
cout << endl;
// for (int i = 0; i < str1.size(); i++)
// {
// cout << str1[i] << " ";
// }
// cout << endl;
return 0;
}
注意：如果想通过范围for修改数据。有一种方法是错误的。
为什么我们已经ch++了，再次for循环打印str1却还是原来的数据？
因为我们是将str1的数据拷贝给ch的，修改了ch，并没有修改str1。再次范围for打印str1就还是原来的数据了。
那如何修改数据呢？
- 我们可以不拷贝，去引用
- 刚刚修改ch，就将ch打印出来。但是要明白，str1里的数据并没有被修改，只是ch修改了。【如果想减少拷贝，使用了引用&，但不想数据被修改，则使用const修饰（const auto& ch : str1）】
int main()
{
string str1("aassddff");
for (auto ch : str1)
{
ch++;
cout << ch << " ";
}
cout << endl;
return 0;
}
2. 两个语法糖融合
int main()
{
string str1("aassddff");
// 变量名:迭代的范围(集合)
for (auto ch : str1)
cout << ch << " ";
cout << endl;
return 0;
}
二. string类的2.2.3
迭代器：正向迭代器iterator，反向迭代器reverse_iterator
2.2.3 反向迭代器
int main()
{
string str1("aassddff");
std::string::reverse_iterator it1 = str1.rbegin();
//或者auto it1 = str1.rbegin();
while (it1 != str1.rend()) //rend就相当于正向迭代器中的end()
{
cout << *it1 << " " ;
it1++; //一定要记得将it1++，不然会陷入死循环，一直打印最后一个字符
}
cout << endl;
return 0;
}
2.2.4 const迭代器
const迭代器在string类对象是const的时候使用。
const对象无法使用普通迭代器
编译器会调用最匹配的函数：
-
普通对象调用普通begin()，const对象调用普通const begin()
-
const迭代器可以遍历，但无法修改数据
int main()
{
const string str1("aassddff"); //const对象
std::string::const_iterator it1 = str1.begin(); //调用const begin()
//const
//或者auto it1 = str1.begin();
while (it1 != str1.end())
{
cout << *it1 << " ";
it1++;
}
cout << endl;
return 0;
}
2.2.5 const反向迭代器
当对象是const类型，且想倒着遍历的时候，可以选择const反向迭代器。
但是仍然无法修改数据哈。
int main()
{
const string str1("aassddff");
std::string::const_reverse_iterator it1 = str1.rbegin();
//const反向迭代器
//或者auto it1 = str1.rbegin();
while (it1 != str1.rend())
{
cout << *it1 << " ";
it1++;
}
cout << endl;
return 0;
}
2.2.6 Capacity相关的
1. size()和length()
size和length都是在计算string对象的长度。
int main()
{
string str1("abcdefg");
//STL经常使用size()
cout << str1.size() << endl;//不要忘记()
cout << str1.length() << endl;
return 0;
}
2. max_size()
意思就是：这个长度是----->字符串可以达到那么长，但是对象不一定可以达到那么长。（感觉这个没有意义，且不同平台的返回结果可能不一样）
3. capacity()
capacity是容量的意思。即空间大小
图中的意思是：开了15个空间，只放了7个字符。
4. clear()
clear()清除内容但是不清除空间
5. empty()
可以在判断的时候用
while(str1.empty());
2.2.7 Element access(元素访问)相关的
operator[]（前面已经了解）
1. at
用的比较少。
at也是用来访问元素的，它和operator有什么区别呢？
operator[]越界是通过断言处理的（暴力报错），而at(pos)是通过抛异常来反应错误的，我们需要捕获异常try catch，如果是标准库的异常，就捕获一个叫exception的东西。
3. back
这个是返回最后一个字符的别名。不经常使用，因为operator[]下标写成0就是第一个字符，写成size-1就是最后一个字符。
4. front
返回字符串第一个字符的参考。
2.2.8 修改相关的
1. 尾插一个字符push_back
容易忽视的: 记得一个字符，使用的是单引号‘’
int main()
{
string str1("hounuli");
str1.push_back(' ');
str1.push_back('a');
cout << str1 << endl;
return 0;
}
2. 尾插一个字符串append
且append支持一堆的接口
int main()
{
//string& append(const string & str);
string str1("my name is hou nu li");
string str2; //可以在另一个string后面加
str2.append(str1);
str1.append(str1); //在自己后面加
return 0;
}
int main()
{
//string& append(const string & str, size_t subpos, size_t sublen);
string str1("my name is hou nu li！");
str1.append(str1,0,7);
//0是被复制给对象的第一个字符的位置，我想在str1的后面再加一个my name,首字符位置是0
//7是子串的长度
cout << str1 << endl;//my name is hou nu li！my name
return 0;
}
int main()
{
//string& append (const char* s);
string str1("my name is hou nu li！");
str1.append("asdf");
cout << str1 << endl;//my name is hou nu li！asdf
//string& append (const char* s, size_t n);
str1.append("asdf",1);
cout << str1 << endl;//my name is hou nu li！asdfa
return 0;
}
int main()
{
//string& append (size_t n, char c);
string str1("my name is hou nu li！");
str1.append(5, 'x');//在str1后面+5个x
cout << str1 << endl;//my name is hou nu li！xxxxx
return 0;
}
int main()
{
//插入一段迭代器区间
//string& append (InputIterator first, InputIterator last);
string str1("my name is hou nu li！");
string str2("abcdefg");
str1.append(str2.begin(),str2.end());//将str2全部复制
str1.append(str2.begin()+3, str2.end());//从d开始
cout << str1 << endl;//my name is hou nu li！abcdefg
return 0;
}
3. operator+=
