string类
string自动调整大小的功能：
string字符串是怎么占用内存空间的？
前景：
如果只给string字符串分配string字符串大小的空间，当一个string字符串附加到另一个string字符串上，这个string字符串是以占用相邻内存的方式进行扩容的，相邻的内存不够存放这个附加的字符串的时候，就需要将拼接起来的这两个string字符串迁移去一个新的内存空间来存放，如果多次这样的分配，会使得效率就很低。
因此,c++会为一个string字符串提前预留空间，该空间比string字符串本身还大一些，当字符串的内存大于原本分配的这个内存的时候，程序会再分配一个原来大小两倍的内存块用来存储该string字符串，这样可以避免不断地分配内存。
即c++会为String字符串分配更多的内存空间，而不是按需分配内存，这样可以减少因字符串扩大而导致需要迁移到新的内存空间的次数，从而提高效率。
string的两个方法：
string str;
cout << str.capacity() << endl;//输出分配给str的内存空间的大小
str.reserve(50);//将分配给字符串的空间设置为50字节如图：
//使用了虚方法
#include <iostream>
#include <string>
using namespace std;int main(){string str = "12345";cout << "str: " << str.capacity() << endl;string *pr = new string("12345");cout << "*pr: " << pr->capacity() << endl;return 0;
}
由图可知，不管是用直接用构造函数创建的对象还是new间接创建的对象（new后面加类名，那么就会调用构造函数来创建对象），他们所分配的内存空间都一样，且比原来string字符串本身大一些。
举个栗子：
一个抽屉里面原来放着a，现在想把b也放进一个同一个抽屉里面，如果放不下了怎么办，当然是找一个能放的下a，b的抽屉来存放a，b，这样拿来拿去也很麻烦，我们还可以每次放东西的时候都预留出一些空间，这样下次再放东西的东西就不至于马上就满了或者直接放不下，就是这样的思想。
智能指针模板类
前景：
我们一般使用动态内存分配的时候，可能会忘记delete而导致开辟了的内存一直被占用，而这个指针消失后（比如在函数中开辟的内存空间，函数结束后该指针就被销毁了），该指针所指向的内存空间就再也无法收回了，这种情况就叫做内存泄漏，内存泄漏可能会导致程序的运行速度变慢，甚至崩溃。
(局部变量pd指针消失，地址为10000的内存无法再回收)
因此就有了智能指针，智能指针的作用就是能够自动帮你回收动态分配的内存，不再需要自己主动delete。
怎么使用智能指针？
要想使用智能指针，则需要包含头文件#include<memory>
智能指针有哪几种？
1.auto_ptr
2.shared_ptr
3.unique_ptr
如何使用智能指针？
我们知道智能指针是一个模板类，因此我们就需要使用模板类的方式创建智能指针
auto_ptr<> p(new );
//<>中填充智能指针要指向的类型，()中需要使用new来创建类型，new返回的指针作为智能指针的参数
//举例
auto_ptr<double > p1(new double);//智能指针p1指向了一个动态分配的double内存空间
shared_ptr<double > p2(new double);
unique_ptr<double > p3(new double);
使用智能指针的时候需要注意什么问题？
1. 智能指针只能指向使用了动态内存分配的类或类型，不能指向非堆内存
string str = "hello world";
auto_pt<string > p(&str);
/*
这样会导致在智能指针p过期以后,
调用智能指针的析构函数将指针所指向的对象使用delete
但是str并没有动态开辟内存，这将导致段错误
实际上就是智能指针不能指向非堆内存
*/
2. 不能将指针直接赋值给智能指针
原因是，每一个类型的智能指针中都有一个explicit声明的构造函数，这将禁止隐式调用构造函数来生成智能指针，比如：
//我们本意是将一个指针的值赋值给智能指针
//让智能指针指向这片内存空间
double *p1 = new double;
shared_ptr<double > p2;
p2 = p1;
//我们知道等号左右两边类型不相同，在没有重载赋值运算符的情况下
//p1可能会作为智能指针构造函数的参数，隐式转换成智能指针对象然后再赋值给p2
//相当于p2 = shared_ptr<double > (p1);
//但因为我们智能指针的构造函数声明explicit，因此不能生成智能指针对象
//则导致等号两边类型不同而报错
当我们使用指针的时候，可能还会引发什么问题？
一个就是浅拷贝的问题，也就是多个对象指向同一片内存空间，多个对象被析构时，可能会对这片内存空间进行多次删除。
如：
class A
{private:char *name;public:A(const char *str){name = new [strlen(str)+1];strcpy(name, s);}~A{delete []name;}}int main(void)
{A a1("hello world!");A a2 = a1;//调用默认的复制构造函数，进行浅拷贝,此时a2的name和a1的name同指向同一片内存空间return 0;
}
//当程序运行结束的时候，对象a1和a2调用析构函数，对同一片内存空间进行回收两次，导致段错误智能指针就可以很好的解决这个问题，原因是什么呢？
上面提到的auto_ptr和unique_ptr提出了所有权的概念，对于特定的对象，只能有一个智能指针可以拥有它，并只有该智能指针可以调用析构函数来删除该对象。
那么auto_ptr和unique_ptr就没有什么不同吗？如果都一样为什么要定义两种智能指针模板？
auto_ptr已经在c++98就已经被摒弃了，因为auto_ptr存在指针悬挂的问题，而unique_ptr就解除了这个指针悬挂的问题，unique_ptr在所有权的问题上更加严格。
什么是指针悬挂？怎么会有的指针悬挂？
我们知道auto_ptr和unique_ptr拥有所有权的概念，一个对象只能被一个智能指针拥有，而所有权是可以传递的，如果一个智能指针a将对象的所有权让给另一个智能指针b，那么指针a就悬挂了，就像一个空指针，那么如果再对这个智能指针进行操作就可能会给程序带来危险。
如
auto_ptr<double > p1(new double);
auto_ptr<double > p2 = p1;//p1将所有权传递给p2，此时p1就变成了一个悬挂的指针在unique_ptr中，悬挂指针是不允许存在的，编译器会报错错误，而auto_ptr则不会。怎么区分什么样的智能指针赋值够能存在，什么样的智能智能赋值后不能存在，实际上unique_ptr是不允许存在一个长期存在的悬挂智能指针，但允许存在临时右值智能指针。
unique_ptr<string > demo(const char *s)
{unique_ptr<string > temp(new string(s));return temp;
}int main(void)
{unique_ptr<string > p1(new string("hello"));//创建一个指向字符串的智能指针;unique_ptr<string > p2;p2 = p1;//这将不被允许，因为智能指针p1交出所有权后仍存在在程序中;p2 = demo("world");//demo函数返回一个临时的智能指针对象，然后将所有权转交给p2//这句话运行结束后临时的智能指针对象消失,这将被允许。return 0;
}即在unique_ptr中，交出所有权后消失是允许的，交出所有权后仍然存在在程序中这是不被允许的，即程序中存在被遗弃的智能指针，有被操作的风险。
如果我就要将一个智能指针赋值给另一个智能指针呢？
那就得使用c++中的std::move函数，这将声明赋值后的智能指针没有被抛弃，后面还会重新指向其他对象。
如：
using namespace std;
unique_ptr<string > p1(new string("hello"));
unique_ptr<string > p2;
p2 = move(p1);
p1 = demo("world");//p1重获另一个对象的所有权，而不是一个被抛弃的智能指针
那么shared_ptr呢？
它与对象的关系和auto_ptr和unique_ptr与对象的关系不太一样，shared_ptr允许多个智能指针指向一个对象（这也是shared名字的由来），会对对象拥有的智能指针数进行基数，只有当计数器为0时，才会调用析构函数来删除该对象。
那么什么时候使用shared_ptr?什么时候使用unique_ptr和auto_ptr呢?
不使用auto_ptr，程序要使用多个指向一个对象的智能指针的时候使用shared_ptr，其他情况用unique_ptr。
标准模板库
迭代器
什么是迭代器?
可以认为迭代器就是一个广义指针，指针怎么用，迭代器就怎么用，迭代器可以看作是容器的指针。
介绍一个算法for_each
for_each在头文件algorithm中，作用：作用于一对迭代器之间（一个范围），然后对范围中的每一个元素作为参数来执行特定的函数或者函数对象,注意：第三个参数传入的是函数的指针或者函数对象，而不是调用函数，也就是说后面不用加()。
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;class functor
{public:void operator()(int n){cout << n << endl;}//一元函数;
};void show(int n)
{cout << n << endl;
}int main(void)
{vector<int >v;functor f;//定义一个函数对象;for(int i = 0; i < 10; i++)v.push_back(i);for_each(v.begin(), v.end(), f);//在迭代器begin到end（左闭右开）的范围内，将元素作为参数传入到f中，每个元素都调用一次f();for_each(v.begin(), v.end(), show);
/*for_each(v.begin(), v.end(), f());//错误的写法for_each(v.begin(), v.end(), show());//错误的写法*/return 0;
}
什么是函数对象？
函数对象就是假装自己是函数的对象，本质是一个对象，但是对运算符"()"进行了重载，这样这个类的对象就可以在自己的后面使用()运算符，这样看起来就像一个函数一样。
class functor//函数对象，也叫做函数符(functor)
{public://void operator();//不用参数就可以调用的函数符，叫做生成器//void operator(int n);//用一个参数可以调用的函数符，叫做一元函数//void operator(int n, double m);//用两个参数可以调用的函数符，叫做二元函数//bool operator(int n);//返回类型为bool且为一元函数的函数符叫做谓词//bool operator(int n, double m);//返回类型为bool且是二元函数的函数符叫做谓词}对于for_each来说，for_each的第三个参数适合使用一元函数作为函数对象，原因是每次只处理一个元素。
介绍容器中的一种方法
然后后面都是介绍一些STL库里面的内容了，这种东西用到的时候再学吧，学算法的时候也算了蛮多的了。
