一. 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类

1. C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。
   

2. 标准库中的string类

string是在STL之前，并没有什么参考，它是独立弄出来的。so它可能偏乱偏多一些

1. 首先，我们要学会看文档（此处注意，句子里的单词翻译的顺序并不是最佳的，只是反映了自己翻译时的第一反应）

string是在STL之前就设计出来了，所以比较复杂，总共有100多个接口（什么是接口，就是提供给我们，可以去调用的），但是我们只需要记住重要的20多个，剩下的使用时查询即可。

2. 使用string类的时候，必须包含头文件#include<string>以及using namespace std(这个可以选择不写)
3. string实际上是个模板，但是它的参数一定确定了，so我们不太用关注它。
4. 先使用默认构造，构造一个空的字符串。

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方括号呢？

1. 可以用来修改某个位置的字符（因为是引用返回，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;
}

2. 可用来遍历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]++;
	}
	

3. 可以很好的防止越界

这个返回值不可以被修改

（2）迭代器

1.迭代器的使用

在此先声明，迭代器会先学习4种：迭代器，反向迭代器，const迭代器，const反向迭代器

（像指针一样的东西，但并不是指针）

1. 迭代器的使用
   
   

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声明的变量：变量的类型由编译器在编译时期推导而得。（根据右边的值推导左边变量的类型）

1. 在早期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;
}

2. 用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;
}

3. 当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量

 auto aa = 1, bb = 2;
 // 编译报错：error C3538: 在声明符列表中，“auto”必须始终推导为同一类型
auto cc = 3, dd = 4.0;

4. 类型包含“auto”的符号必须具有初始值设定项
   即不可以auto j;，没有初始值的话，就没有办法判断auto代表的什么类型，会报错。所以必须有初始值auto j = 4.3;
5. 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就还是原来的数据了。

那如何修改数据呢？

1. 我们可以不拷贝，去引用
   
2. 刚刚修改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+=