C++——string类和标准模板库

一、string类

　　1、构造函数

　　string实际上是basic_string<char>的一个typedef，同时省略了与内存管理相关的参数。size_type是一个依赖于实现的整型，是在string中定义的。string类将string::npos定义为字符串的最大长度，通常为unsigned int的最大值。另外，使用缩写NBTS（null-terminated string）来表示以空字符结束的字符串——传统的C字符串。下面的表格中列出了string的构造函数：

构造函数	描述
string(const char * s)	将string对象初始化为s指向的NBTS
string(size_type n, char c)	创建一个包含n个元素的string对象，其中每个元素都被初始化为字符c
string(const string & str)	将一个string对象初始化为string对象str（复制构造函数）
string()	创建一个默认的string对象，长度为0（默认构造函数）
string(const char * s,size_type n)	将string对象初始化为s指向的NBTS的前n个字符，即使超过了NBTS结尾
template<class Iter> string(Iter begin,Iter end)	将string对象初始化为区间［begin，end）内的字符，其中begin和end的行为就像指针，用于指定位置，范围包括begin在内，但不包括end
string(const string & str, size_type pos = 0,size_type n = npos)	将一个string对象初始化为对象str中从位置pos开始到结尾的字符，或从位置pos开始的n个字符
string(string && str)noexcept	这是C++11新增的，他将一个string对象初始化为string对象str，并可能修改str（移动构造函数）
string(initializer_list<char> il)	这是C++11新增的，它将一个string对象初始化为初始化列表il中的字符

2、string类输入

　　对于类，需要知道有哪些输入方式可用。对于C风格字符串，有3种方式：
　　　　char info[100];

　　　　cin >> info;//读取一个词

　　　　cin.getline(info,100);//读取一行，遇到\n结束，并丢弃\n

　　　　cin.get(info, 100);//读取一行，遇到\n结束，将\n丢弃在输入队列中

　　对于string对象，有两种方式：

　　　　string stuff;

　　　　cin >> stuff;//读取一个词

　　　　getline(cin,stuff);//读取一行，遇到\n结束并丢弃\n

二、智能指针模板类

　　智能指针是行为类似于指针的类对象。

　　auto_ptr是C++98提供的解决方案，C++11已将其摒弃，并提供了另外两种解决方案。然而，虽然auto_ptr被摒弃，但它已经使用了多年；同时，如果编译器不支持其他两种解决方案，auto_ptr将是唯一的解决方案。

　　2.1、使用智能指针

　　auto_ptr、unique_ptr和shared_ptr这三个智能指针模板都定义了类似指针的对象，可以将new获得（直接或间接）的地址赋给这种对象。当智能指针过期，其析构函数将使用delete来释放内存。因此，如果将new返回的地址赋给这些对象，将无需记住稍后释放这些内存：在智能指针过期时，这些能存将自动被释放。

　　要创建智能指针对象，必须包含头文件memory，该文件模板定义。然后使用通常的模板语法来实例化所需类型的指针。例如，模板auto_ptr包含如下构造函数：

　　　　template<class X> class auto_ptr{

　　　　public:

　　　　　　explicit auto_ptr(X *p = 0) throw();

　　　　...};

　　throw()意味着构造函数不会引发异常；与auto_ptr一样，throw()也被摒弃。因此，请求X类型的auto_ptr将获得一个指向X类型的auto_ptr：

　　　　auto_ptr<double> pd(new double);

　　　　auto_ptr<string> ps(new string);

　　new double是new返回的指针，指向新分配的内存块。它是构造函数auto_ptr<double>的参数，即对应于原型中参数p的实参。同样，new string也是构造函数的实参。其他两种智能指针使用同样的语法:
　　　　unique_ptr<double> pdu(new double);

　　　　shared_ptr<string> pss(new string);

　　智能指针模板位于名称空间std中。下面的程序演示了如何使用全部三种智能指针。每个智能指针都放在同一个代码块内，这样离开代码的时候，指针将过期。Report类使用方法报告对象的创建和销毁。

 #include <iostream>
 #include <memory>

 class Report{
 private:
     std::string str;
 public:
     Report(const std::string & s):str(s){
         std::cout << "创建了对象" << str <<"！ \n";
     }
     ~Report(){
         std::cout << "销毁了对象" << str << "! \n";
     }
     void comment()const{
         std::cout << str << "\n";
     }
 };

 int main(int argc, char * argv[])
 {
     using namespace std;
     {
         auto_ptr<Report> ps(new Report("using auto_ptr"));
         ps->comment();
     }
     {
         shared_ptr<Report> ps(new Report("using shared_ptr"));
         ps->comment();
     }
     {
         unique_ptr<Report> ps(new Report("using unique_ptr"));
         ps->comment();
     }
     return ;
 }

 输出结果：
 创建了对象using auto_ptr！
 using auto_ptr
 销毁了对象using auto_ptr!
 创建了对象using shared_ptr！
 using shared_ptr
 销毁了对象using shared_ptr!
 创建了对象using unique_ptr！
 using unique_ptr
 销毁了对象using unique_ptr! 

　　所有智能指针都有一个explicit构造函数，该构造函数将指针作为参数。因此不需要自动将指针转换为智能指针对象。

　　由于智能指针模板定义方式，智能指针对象的很多方面都类似于常规指针。

　　2.2、有关智能指针的注意事项

　　为何使用三种智能指针呢？实际上有4种，另外一种是weak_ptr，但我们不讨论它。为何摒弃auto_ptr呢？

　　先来看下面的复制语句：

　　　　std::auto_ptr<std::string> ps(new std::string("Good morning!"));

　　　　std::auto_ptr<std::string> vocation;

　　　　vocation = ps;

　　上述赋值语句将完成什么工作呢？如果ps和vocation是常规指针，则两个指针将指向同一个string对象。这是不能接受的，因为程序将视图删除同一个对象两次——一次是ps过期时，另一次是vocation过期时。要避免这种问题，方法有多种。

　　　　＊定义赋值运算符，使之执行深度复制。这样两个指针将指向不同的对象，其中的一个对象是另一个对象的副本。

　　　　＊建立所有权（ownership）概念，对于特定的值，只能有一个智能指针可拥有它，这样只有拥有对象的智能指针的析构函数会删除该对象。然后，让赋值操作转让所有权。这就是用于auto_ptr和unique_ptr的策略，但unique_ptr的策略更严格。

　　　　＊创建智能更高的指针，跟踪引用特定对象的智能指针数。这称为引用计数（reference counting）。例如，赋值时，计数将加1，而指针过期时，计数将减1 。仅当最后一个指针过期时，才调用delete。这是shared_ptr采用的策略。

　　当然同样的策略也适用于复制构造函数。

　　每种方法都有用途。下面的程序清单是一个不适合auto_ptr的示例：

#include <iostream>
#include <memory>
#include <string>

int main(int argc, char * argv[])
{
    using namespace std;
    auto_ptr<string> films[] = {
        auto_ptr<string> (new string("卡卡西")),
        auto_ptr<string> (new string("佐助")),
        auto_ptr<string> (new string("宇智波鼬")),
        auto_ptr<string> (new string("凯")),
        auto_ptr<string> (new string("宁次"))
    };
    auto_ptr<string> pwin;
    pwin = films[];

    for (int i = ; i < ; i++) {
        cout << *films[i] << endl;
    }
    cout << *pwin << endl;
    cin.get();
    return ;
}

输出结果：
卡卡西
佐助
(lldb)  //程序崩溃了

　　程序崩溃的原因在于，下面的语句将所有权从film[2]转让给pwin：

　　　　pwin = films[2]; //films[2]丢失所有权

　　这导致films[2]不再引用该字符串。在auto_ptr放弃对象的所有权后，便可能使用它来反问该对象。当程序打印films[2]指向的字符串时，却发现这是一个空指针。

　　如果在上面的程序清单中用shared_ptr代替auto_ptr，则程序运行正常：

 #include <iostream>
 #include <memory>
 #include <string>

 int main(int argc, char * argv[])
 {
     using namespace std;
     shared_ptr<string> films[] = {
         auto_ptr<string> (new string("卡卡西")),
         auto_ptr<string> (new string("佐助")),
         auto_ptr<string> (new string("宇智波鼬")),
         auto_ptr<string> (new string("凯")),
         auto_ptr<string> (new string("宁次"))
     };
     shared_ptr<string> pwin;
     pwin = films[];

     for (int i = ; i < ; i++) {
         cout << *films[i] << endl;
     }
     cout << *pwin << endl;
     cin.get();
     return ;
 }

 输出结果：
 卡卡西
 佐助
 宇智波鼬
 凯
 宁次
 宇智波鼬

　　这次pwin和films[2]指向同一个对象，而引用计数从1增加到2 。在程序末尾，后声明的pwin首先调用其析构函数，该析构函数将引用计数降低到1 。然后，shared_ptr数组的成员被释放，对films[2]调用析构函数时，将引用计数降低到0，并释放以前分配的空间。

　　unique_ptr与auto_ptr一样，也采用所有权模型。但使用unique_ptr时，程序不会等到运行阶段崩溃，而在编译阶段出现错误。

　　2.3 unique_ptr为何优于auto_ptr 

　　先看下面的语句：

　　　　auto_ptr<string> p1(new string("Good morning!"));  //＃1

　　　　auto_ptr<string> p2;　　　　　　　　　　　　　　　　// ＃2

　　　　p2 = p1;　　　　　　　　　　　　　　　　　　　　　　//  ＃3

　　在语句＃3中，p2接管了string对象的所有权后，p1的所有权将会被剥夺。这是件好事，可防止p1和p2的析构函数试图删除同一个对象；但如果程序随后试图使用p1，这将是坏事，因为p1不再指向有效的数据。

　　下面来看使用unique_ptr的情况：

　　　　unique_ptr<string> p3(new string("auto"));　　　 // ＃4

　　　　uniqie_ptr<string> p4;　　　　　　　　　　　　　　//＃5

　　　　p4 = p3;　　　　　　　　　　　　　　　　　　　　　// #6

　　编译器认为语句＃6非法，避免了p3不再指向有效数据的问题。因此，unique_ptr比auto_ptr更安全（编译阶段错误比潜在的程序崩溃更安全）。

　　但有时候，将一个智能指针赋给另一个并不会留下危险的悬挂指针。假设有如下的函数定义：　　

　　　　unique_ptr<string> demo(const char * s){

　　　　　　unique_ptr<string> temp(new string(s));

　　　　　　return temp;

　　　　}

　　并假设编写如下的代码：

　　　　unique_ptr<string> ps;

　　　　ps = demo("Good morning!");

　　demo()返回一个临时unique_ptr，然后ps接管了原本归返回的unique_ptr所有的对象，而返回的unique_ptr被销毁。这没有问题，因为ps拥有了string对象的所有权。但这里的另一个好处是，demo()返回的临时unique_ptr很快被销毁，没有机会使用它来访问无效的数据。换句话说，没有理由禁止这种赋值。神奇的是，编译器允许这种赋值。

　　总之，程序试图将一个unique_ptr赋给另一个时，如果源unique_ptr是一个临时右值，编译器允许这样做；如果unique_ptr将存在一段时间，编译器将禁止这样做：

　　　　unsing namespace std;

　　　　unique_ptr<string> pu1(new string("Hello world!"));　　　　　

　　　　unique_ptr<string> pu2;

　　　　pu2 = pu1;　　　　　　　　　　　　　　　　　　　　　　//#1 不允许

　　　　unique_ptr<string> pu3;

　　　　pu3 = unique_ptr<string>(new string("Hello!"));　　//#2 允许

　　语句＃1将留下悬挂的unique_ptr(pu1)，这可能导致危险。语句＃2不会留下悬挂的unique_ptr，因为它调用unique_ptr的构造函数，该构造函数创建的临时对象在其所有权转让给pu3后就会被销毁。这种随情况而异的行为表明，unique_ptr优于允许两种赋值的auto_ptr。这也是禁止（只是一种建议，编译器并不会禁止）在容器对象中使用auto_ptr，但允许使用unique_ptr的原因。如果容器算法试图对包含unique_ptr的容器执行类似于语句＃1的操作，将导致编译错误；如果算法试图执行类似于＃2的操作，则不会有任何问题。而对于auto_ptr，类似于语句＃1的操作可能导致不确定的行为和神秘的崩溃。

　　当然，可能确实想执行类似语句＃1的操作。仅当以非智能的方式使用遗弃的智能指针（如解引用时），这种赋值才不安全。要安全地重用这种指针，可给它赋新值。C++有一个标准库函数std::move()，让您能够将一个unique_ptr赋给另一个。下面是一个使用前面demo()函数的例子，该函数返回一个unique_ptr<string>对象：

　　　　unsing namespace std;

　　　　unique_ptr<string> ps1, ps2;

　　　　ps1 = demo("Hello world!");

　　　　ps2 = move(ps1);

　　　　ps1 = demo("Good morning!");

　　　　cout << *ps2 << ps1 << endl;

　　相比于auto_ptr，unique_ptr还有另一个优点。它有一个可用于数组的变体。别忘了，必须将delete和new配对使用，将delete []和new []配对。模板auto_ptr使用delete而不是delete []，因此只能与new一起使用，而不能与new []一起使用。但unique_ptr有使用new []和delete []的版本：

　　　　std::unique_ptr<double []> pda(new double[5]);  //将会使用delete []

　　警告：使用new分配内存是，才能使用auto_ptr和shared_ptr，使用new []分配内存时，不能使用它们。不使用new分配内存时，不能使用auto_ptr和shared_ptr；不使用new或new []分配内存时，不能使用unique_ptr。

　　2.4 选择智能指针

　　应使用哪种智能指针呢？如果程序要使用多个指向同一个对象的指针，应选择shared_ptr。这种情况包括：有一个指针数组，并使用一些辅助指针来标示特定的元素，如最大的元素和最小的元素；两个对象包含都指向第三个对象的指针；STL容器包含指针。很多STL算法都支持复制和赋值操作，这些操作可用于shared_ptr，但不能用于unique_ptr（编译发出警告）和auto_ptr（行为不确定）。如果编译器没有提供shared_ptr，可使用Boost库提供的shared_ptr。

　　如果程序不需要多个指向同一个对象的指针，则可使用unique_ptr。如果函数使用new分配内存，并返回指向该内存的指针，将其返回类型声明为unique_ptr是不错的选择。这样，所有权将转让给接受返回值的unique_ptr，而该智能指针负责调用delete。可将unique_ptr存储到STL容器中，只要不调用将一个unique_ptr复制或赋值给另一个方法或算法（如sort()）。例如，可在程序中使用类似于下面的代码段，这里假设包含了正确的include和using语句：

　　　　unique_ptr<int> make_int(int n){

　　　　　　return unique_ptr<int> (new int(n));

　　　　}

　　　　void show(unique_ptr<int> & p){

　　　　　　cout << *p << '\n';

　　　　}

　　　　int main(){

　　　　...

　　　　　　vector<unique_ptr<int>> vp(size);

　　　　　　for(int i = 0; i < vp.size(); i++){

　　　　　　　　vp[i] = make_int(rand() % 1000);

　　　　　　}

　　　　　　vp.push_back(make_int(rand() % 1000));

　　　　　　for_each(vp.begin(), vp.end(), show);

　　　　...

　　　　}

　　其中的push_back()调用没有问题，因为它返回一个临时unique_ptr，该unique_ptr被赋值给vp中的一个unique_ptr。另外，如果按值而不是按引用给show()传递对象，for_each()将非法，因为这将导致使用一个来自vp的非临时unique_ptr初始化pi，而这时不允许的。前面说过，编译器将发现错误使用unique_ptr的企图。

　　在unique_ptr为右值时，可将其赋给shared_ptr，这与将一个unique_ptr赋给另一个需要满足的条件相同。与前面一样，在下面的代码中，make_int()返回的类型为unique_ptr<int>:

　　　　unique_ptr<int> pup(make_int(rand() % 1000));  //允许

　　　　shared_ptr<int> spp(pup); //不允许

　　　　shared_ptr<int> spr(make_int(rand() % 1000)) ; //允许

　　模板shared_ptr包含一个显式构造函数，可用于将右值unique_ptr转换为shared_ptr。shared_ptr将接管原来归unique_ptr所有的对象。

　　在满足unique_ptr要求的条件时，也可使用auto_ptr，但unique_ptr是更好的选择。如果编译器没有提供unique_ptr，可考虑使用BOOST库提供的scoped_ptr，它与unique_ptr类似。

三、标准模板库

　　STL提供了一组表示容器、迭代器、函数对象和算法的模板。容器是一个与数组类似的单元，可以存储若干个值。STL容器是同质的，即存储的值的类型相同；算法是完成特定任务（如对数组进行排序或在链表中查找特定的值）的处方；迭代器能够用来遍历容器的对象，与能够遍历数组的指针类似，是广义指针；函数对象是类似于函数的对象，可以是类对象或函数指针（包括函数名，因为函数名被用作指针）。STL使得能够构造各种容器（包括数组、队列和链表）和执行各种操作（包括搜索、排序和随机排列）。

　　STL不是面相对象的编程，而是一种不同的编程模式——范型编程（generic programming）。

　　3.1 模板类vector

　　在计算机中，矢量（vector）对应数组，而不是数学矢量（在数学中，可以使用N个分量来表示N维数学矢量，因此从这方面讲，数学矢量类似一个N维数组。然而，数学矢量还有一些计算机矢量不具备的其他特征，如内乘积和外乘积）。计算机矢量存储了一组可随机访问的值，即可以使用索引来直接访问矢量的第10个元素，而不必首先访问前面第9个元素。在头文件vector中定义了vector模板。

　　要创建vector模板对象，可使用通用的<type>表示法来指出要使用的类型。另外，vector模板使用了动态内存分配，因此可以用初始化参数来指出需要多少矢量：

　　　　#include <vector>

　　　　using namespace std;

　　　　vector<int> ratings(5);   //创建一个包含5个int值的vector对象

　　　　int n;

　　　　cin >> n;

　　　　vector<double> scores(n);  //创建一个包含n个double值的vector对象

　　由于运算符[]被重载，因此创建vector对象后，可以使用通用的数组表示法来访问各个元素：

　　　　ratings[0] = 9;

　　　　for(int i = 0; i < n; n++){

　　　　　　cout << scores[i] << endl;

　　　　}

分配器

　　与string类相似，各种STL容器模板都接受一个可选的模板参数，爱参数指定使用哪个分配器对象来管理内存。例如，vector模板的开头与下面类似：

　　　　template<class T, class Allcoator = allocator<T>>

　　　　　　class vector{...};

　　如果省略该模板参数的值，则容器模板将默认使用allocator<T>类。这个类使用new和delete。

　　下面的程序是一个要求不高的应用程序，它使用了这个类。该程序创建两个vector对象——一个是int规范，另一个是string规范，它们都包含5个元素。

 #include <iostream>
 #include <string>
 #include <vector>
 #include <iomanip>

 const int NUM = ;
 int main(int argc, char * argv[])
 {
     using namespace std;
     vector<int> scores(NUM);
     vector<string> students(NUM);
     cout << "依次输入五个学生的成绩和名字\n";
     for (int i = ; i < NUM; i++) {
         cout << "请输入第"<< i+ <<"个学生名字：";
         cin >> students[i];
         while (cin.get() != '\n');
         cout << "请输入学生的成绩:";
         cin >> scores[i];
         while (cin.get() != '\n');
     }
     cout << "\n这是学生的成绩：\n";
     for (int i = ; i < NUM; i++) {
         cout << setw() << right << students[i] << ": " << setw() << right << scores[i] << endl;
     }
     return ;
 }

 输出结果：
 依次输入五个学生的成绩和名字
 请输入第1个学生名字：xiaohong
 请输入学生的成绩:
 请输入第2个学生名字：xiaoming
 请输入学生的成绩:
 请输入第3个学生名字：xiaoyu
 请输入学生的成绩:
 请输入第4个学生名字：xiaonan
 请输入学生的成绩:
 请输入第5个学生名字：xiaohua
 请输入学生的成绩:

 这是学生的成绩：
             xiaohong:
             xiaoming:
               xiaoyu:
              xiaonan:
              xiaohua:   

　　3.2 可对矢量执行的操作

　　所有的STL容器都提供了一些基本方法，其中包括size()——返回容器中的元素数目、swap()——交换两个容器的内容、begin()——返回一个指向容器第一个元素的迭代器、end()——返回一个表示超过容器尾的迭代器。

　　迭代器是一个广义指针。事实上，它可以是指针，也可以是一个可对其执行类似指针的操作——如解除引用（如operator*()）和递增（如operator++()）——的对象。通过将指针广义化为迭代器，让STL能够为各种不同的容器类（包括那些简单指针无法处理的类）提供统一的接口。每个容器都定义了一个合适的迭代器，该迭代器的类型是一个名为iterator的typedef，其作用域为整个类。例如，要为vector的double类型规范声明一个迭代器，可以这样做：
　　　　vector<double>::iterator pd;

　　假设scores是一个vector<double>对象：

　　　　vector<double> scores;

　　则可以使用迭代器pd执行这样的操作：

　　　　pd = scores.begin();

　　　　*pd = 22.3;

　　　　++pd;

　　迭代器的行为就像指针。顺便说一句，还有一个C++11自动类型推断很有用的地方。例如，可以不这样做：

　　　　vector<double>::iterator pd = scores.begin();

　　　　而这样做：

　　　　auto pd = scores.begin();

　　什么是超过结尾（past-the-end）呢？它是一种迭代器，指向容器最后一个元素后面的那个元素。这与C－风格字符串最后一个字符后面的空字符类似，只是空字符是一个值，而“超过结尾”是一个指向元素的指针（迭代器）。end()成员函数标识超过结尾的位置。如果将迭代器设置为容器的第一个元素，并不断递增，则最终它将到达容器的结尾，从而遍历容器的内容。例如，假设students是一个vector<string>对象，则可以使用下面的方法遍历students：

　　　　for(auto pd = students.begin(); pd != students.end(); pd++)

　　　　　　cout << *pd << endl;

　　所有的容器都包含上面讨论的方法。vector模板类也包含一些只有某些STL容器才有的方法。push_back()是一个方便的方法，它将元素添加到矢量末尾。这样做时，它将负责内存管理，增加矢量的长度，使之能够容纳新的成员。这意味着可以这样编写代码：

　　　　vector<double> scores;

　　　　double temp;

　　　　while(cin >> temp && temp >= 0)

　　　　　　scores.push_back(temp);

　　　　cout << "You entered " << scores.size() << " scores.\n";

　　每次循环都给scores对象增加一个元素。在编写或运行程序时，无需了解元素的数目。只要能够取得足够的内存，程序就可以根据需要增加scores的长度。

　　erase()方法删除矢量中给定区间的元素。它接受两个迭代器参数，这些参数定义了要删除的区间。了解STL如何使用两个迭代器来定义区间至关重要。第一个迭代器指向区间的起始处，第二个迭代器位于区间终止处的后一个位置。例如，下述代码删除第一个和第二个元素，即删除begin()和begin()+1指向的元素（由于vector提供了随机访问功能，因此vector类迭代器定义了诸如begin()＋2等操作）：

　　　　scores.erase(scores.begin(), scores.begin() + 2);

　　如果it1和it2是迭代器，则STL文档使用[it1, it2)来表示从it1到it2（不包括it2）的区间。因此，区间[begin(), end()]将包括集合的所有内容，而区间[p1, p1)为空。[)表示法并不是C++的组成部分，因此不能在代码中使用，而只能出现在文档中。

　　insert()方法的功能与erase()相反。它接受三个迭代器参数，第一个参数指定了新元素的插入位置，第二个和第三个迭代器参数定义了被插入区间，该区间通常是另一个容器对象的一部分。例如，下面的代码将矢量new_v中除第一个元素外的所有元素插入到old_v矢量的第一个元素前面：

　　　　vecor<int> old_v;

　　　　vector<int> new_v;

　　　　...

　　　　old_v.insert(old_v.begin(), new_v.begin() + 1, new_v.end());

　　顺便说一句，拥有超尾元素是非常方便的，因为这使得在矢量尾部附加元素非常简单。下面的代码将新元素插入到old_v.end()前面，即矢量最后一个元素的后面：

　　　　old_v.insert(old_v.end(), new_v.begin() + 1, new_v.end());

　　下面的程序演示了size()、begin()、end()、push_back()、erase()和insert()的用法：

 #include <iostream>
 #include <string>
 #include <vector>
 struct Review{
     std::string title;
     int rating;
 };
 bool FillReview(Review & rr);
 void ShowReview(const Review & rr);
 int main(int argc, char * argv[])
 {
     using namespace std;
     vector<Review> books;
     Review temp;
     while (FillReview(temp)) {
         books.push_back(temp);
     }
     size_t num = books.size();
     if (num > ) {
         cout << "谢谢。下面是你输入的：\n" << "Rating\tBook\n";
         for (int i = ; i < num; i++) {
             ShowReview(books[i]);
         }
         cout << "重复：\n" << "Rating\tBook\n";
         for (auto pd = books.begin(); pd != books.end(); pd++) {
             ShowReview(*pd);
         }
         vector<Review> oldlist(books);
         if (num > ) {
             books.erase(books.begin() + , books.begin() + );
             cout << "删除数目后：\n";
             for (auto ps = books.begin(); ps != books.end(); ps++) {
                 ShowReview(*ps);
             }
         }

         books.insert(books.begin(), oldlist.begin() + , oldlist.begin() + );
         cout << "插入新数目后：\n";
         for (auto ps = books.begin(); ps != books.end(); ps++) {
             ShowReview(*ps);
         }
     }
     else{
         cout << "什么都没有输入\n";
     }
     return ;
 }

 bool FillReview(Review & rr){
     std::cout << "请输入书籍的名字(输入quit退出)：";
     std::getline(std::cin, rr.title);
     if (rr.title == "quit") {
         return false;
     }
     std::cout << "输入书的价格： ";
     std::cin >> rr.rating;
     while (std::cin.get() != '\n') {
         continue;
     }
     return true;
 }

 void ShowReview(const Review & rr){
     std::cout << rr.rating << "\t" << rr.title << std::endl;
 }

 输出结果：
 请输入书籍的名字(输入quit退出)：Juhua
 输入书的价格：
 请输入书籍的名字(输入quit退出)：Meigui
 输入书的价格：
 请输入书籍的名字(输入quit退出)：Lanhua
 输入书的价格：
 请输入书籍的名字(输入quit退出)：Huaishu
 输入书的价格：
 请输入书籍的名字(输入quit退出)：quit
 谢谢。下面是你输入的：
 Rating    Book
     Juhua
     Meigui
     Lanhua
     Huaishu
 重复：
 Rating    Book
     Juhua
     Meigui
     Lanhua
     Huaishu
 删除数目后：
     Juhua
     Huaishu
 插入新数目后：
     Meigui
     Juhua
     Huaishu

　　3.3 对矢量可执行的其他操作

　　STL从更广义的角度定义了非成员函数来执行诸如搜索、排序、随机排序等操作。这种设计理念省却了大量的重复工作。如果每个类都有自己的成员函数，则需要定义80（8*10）个成员函数。但采用STL方式时，只需要定义10个非成员函数即可。在定义新的容器类时，只要遵循正确的指导思想，则它也可以使用已有的10个非成员函数来执行查找、排序等操作。

　　另一方面，即使有执行相同任务的非成员函数，STL有时也会定义一个成员函数。这是因为对有些操作来说，类特定算法的效率比通用算法高，因此，vector的成员函数swap()的效率比非成员函数swap()高，但非成员函数可用来交换两个类型不同的容器的内容。

　　下面来看3个具有代表性的STL函数：for_each()、random_shuffle()和sort()。

　　for_each()函数可用于很多容器类，它接受3个参数。前两个是定义容器中区间的迭代器，最后一个是指向函数的指针（更普遍地说，最后一个参数是一个函数对象）。for_each()函数将被指向的函数应用于容器区间中的各个元素。被指向的函数不能修改容器元素的值。可以用for_each()函数代替for循环。例如，可以将代码：

　　　　vector<Review>::iterator pr;

　　　　for(pr = books.begin(); pr != books.end(); ps++)

　　　　　　ShowReview(*pr);

　　　　替换为：

　　　　for_each(books.begin(), books.end(), ShowReview);

　　　　这样可以避免显式地使用迭代器变量。

　　random_shuffle()函数接受两个指定区间的迭代器参数，并随机排列该区间中的元素。例如，下面的语句随机排列books矢量中所有元素：

　　　　random_shuffle(books.begin(), books.end());

　　　　与可用于任何容器类的for_each()不同，该函数要求容器类允许随机访问，vector类可以做到这一点。

　　sort()函数也要求容器支持随机访问。该函数有两个版本，第一个版本接受两个定义区间的迭代器参数，并使用为存储在容器中的类型元素定义的<运算符，对区间中的元素进行操作。例如，下面de1语句按升序对nums的内容进行排序，排序时使用内置的<运算符对值进行比较：

　　　　vector<int> nums;

　　　　....

　　　　sort(nums.begin(), nums.end());

　　如果容器元素是用户定义的对象，则要使用sort()，必须定义能够处理该类型对象的operator<()函数。

　　sort()函数的另一个版本接受3个参数，前两个参数也是用来指定区间的迭代器，最后一个参数是指向要使用的函数的指针（函数对象），而不是用比较的operator<()。返回值可转换为bool，false表示两个参数的位置不正确。

　　3.4 基于范围的for循环（C++11）

　　基于范围的for循环是为用于STL而设计的。先来看一个例子：

 int main(int argc, const char * argv[]) {
     using namespace std;
     double prices[] = {12.3, 33.5, 66.8, 22.5, 55.8};
     for (double var:prices) {
         cout << var << ", ";
     }
     return ;
 }
 输出结果：
 12.3, 33.5, 66.8, 22.5, 55.8, 

　　在这种for循环中，括号内的代码声明一个类型与容器存储的内容相同的变量，然后指出了容器的名称。接下来，循环体使用指定的变量依次访问容器的每个元素。还可以使用auto进行自动类型推断，例如：

 int main(int argc, const char * argv[]) {
     using namespace std;
     double prices[] = {12.3, 33.5, 66.8, 22.5, 55.8};
     for (auto var:prices) {
         cout << var << ", ";
     }
     return ;
 }

　　假设books是一个vector<string>类型，Show(const std::string & str)用来显示string对象的信息，因此可以将下面的代码：

　　　　for_each(books.begin(), books.end(), Show);

　　　　替换为：
　　　　for(auto x : books) Show(x);

　　不同于for_each()，基于范围的for循环可以修改容器的内容，诀窍是指定一个引用参数。例如：

 #include <iostream>

 int main(int argc, const char * argv[]) {
     using namespace std;
     int nums[] = {, , , , };
     for (auto & var : nums) {
         cout << var << ", ";
     }
     cout << '\n';
     for (auto & var : nums) {
         var += ;
     }
     for (auto var : nums) {
         cout << var << ", ";
     }
     return ;
 }

 输出结果：
 , , , , ,
 , , , , , 

四、泛型编程　　　　

　　STL是一种泛型编程。面相对象编程关注的是编程的数据方面，而泛型编程关注的是算法。它们之间的共同点是抽象和创建可重用代码，但它们的理念决然不同。

　　泛型编程旨在编写独立于数据类型的代码。在C++中，完成通用程序的工具是模板。当然，模板使得能够按泛型定义函数或类，而STL通过通用算法更进了一步。模板让这一切成为可能，但必须对元素进行仔细地设计。

　　4.1 为何使用迭代器

　　模板使得算法独立于存储的数据类型，而迭代器使算法独立于使用的容器类型。因此，它们都是STL通用方法的重要组成部分。