c++提高学习笔记——05-c++STLday10

在学习c++提高-STL总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。

05-c++STLday10

目录：
一、STL概论
1、STL基本概念
2、STL六大组件简介
3、STL优点
二、STL三大组件
1、容器
2、算法
3、迭代器
练习：三大组件基本使用
三、常用容器
1、string容器
（1）构造、赋值
（2）练习string容器API
（3）重新分配内存
（4）练习——字母大小写更改
2、vector容器
（1）练习：容量动态改变
（2）API测试
》巧用swap收缩空间
3、deque容器
（1）测试API
（2）排序——sort
（3）作业——评委打分

 

一、STL概论

---

背景：

长久以来，软件界一直希望建立一种可重复利用的东西，以及一种得以制造出”可重复运用的东西”的方法,让程序员的心血不止于随时间的迁移，人事异动而烟消云散，从函数(functions)，类别(classes),函数库(function libraries),类别库(class libraries)、各种组件，从模块化设计，到面向对象(object oriented )，为的就是复用性的提升。

为了建立数据结构和算法的一套标准，并且降低他们之间的耦合关系，以提升各自的独立性、弹性、交互操作性(相互合作性,interoperability),诞生了STL。

---

1、STL基本概念

STL(Standard Template Library,标准模板库)，是惠普实验室开发的一系列软件的统称。现在主要出现在 c++中，但是在引入 c++之前该技术已经存在很长时间了。
       STL 从广义上分为: 容器(container) 算法(algorithm) 迭代器(iterator),容器和算法之间通过迭代器进行无缝连接。STL 几乎所有的代码都采用了模板类或者模板函数，这相比传统的由函数和类组成的库来说提供了更好的代码重用机会。STL(Standard Template Library)标准模板库,在我们 c++标准程序库中隶属于 STL 的占到了 80%以上。

 

2、STL六大组件简介

STL提供了六大组件，彼此之间可以组合套用，这六大组件分别是:容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器。

容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据，从实现角度来看，STL容器是一种class template。

算法：各种常用的算法，如sort、find、copy、for_each。从实现的角度来看，STL算法是一种function tempalte.

迭代器：扮演了容器与算法之间的胶合剂，共有五种类型，从实现角度来看，迭代器是一种将operator* , operator-> , operator++,operator--等指针相关操作予以重载的class template. 所有STL容器都附带有自己专属的迭代器，只有容器的设计者才知道如何遍历自己的元素。原生指针(native pointer)也是一种迭代器。

仿函数：行为类似函数，可作为算法的某种策略。从实现角度来看，仿函数是一种重载了operator()的class 或者class template

适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。

空间配置器：负责空间的配置与管理。从实现角度看，配置器是一个实现了动态空间配置、空间管理、空间释放的class tempalte.

 

STL六大组件的交互关系，容器通过空间配置器取得数据存储空间，算法通过迭代器存储容器中的内容，仿函数可以协助算法完成不同的策略的变化，适配器可以修饰仿函数。

 

3、STL优点
（1）STL 是 C++的一部分，因此不用额外安装什么，它被内建在你的编译器之内。
（2）STL 的一个重要特性是将数据和操作分离。数据由容器类别加以管理，操作则由可定制的算法定义。迭代器在两者之间充当“粘合剂”,以使算法可以和容器交互运作
（3）程序员可以不用思考 STL 具体的实现过程，只要能够熟练使用 STL 就 OK 了。这样他们就可以把精力放在程序开发的别的方面。
（4）STL 具有高可重用性，高性能，高移植性，跨平台的优点。
》高可重用性：STL 中几乎所有的代码都采用了模板类和模版函数的方式实现，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。关于模板的知
识，已经给大家介绍了。
》高性能：如 map 可以高效地从十万条记录里面查找出指定的记录，因为 map 是采用红黑树的变体实现的。
》高移植性：如在项目 A 上用 STL 编写的模块，可以直接移植到项目 B 上。

二、STL三大组件

1、容器
容器，置物之所也。
研究数据的特定排列方式，以利于搜索或排序或其他特殊目的，这一门学科我们称为数据结构。大学信息类相关专业里面，与编程最有直接关系的学科，首推数据结构与算法。几乎可以说，任何特定的数据结构都是为了实现某种特定的算法。STL容器就是将运用最广泛的一些数据结构实现出来。

常用的数据结构：数组(array),链表(list),tree(树)，栈(stack),队列(queue),集合(set),映射表(map),根据数据在容器中的排列特性，这些数据分为序列式容器和关联式容器两种。
》 序列式容器强调值的排序，序列式容器中的每个元素均有固定的位置，除非用删除或插入的操作改变这个位置。Vector容器、Deque容器、List容器等。
》关联式容器是非线性的树结构，更准确的说是二叉树结构。各元素之间没有严格的物理上的顺序关系，也就是说元素在容器中并没有保存元素置入容器时的逻辑顺序。关联式容器另一个显著特点是：在值中选择一个值作为关键字key，这个关键字对值起到索引的作用，方便查找。Set/multiset容器 Map/multimap容器

2、算法
算法，问题之解法也。
以有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法(Algorithms).
广义而言，我们所编写的每个程序都是一个算法，其中的每个函数也都是一个算法，毕竟它们都是用来解决或大或小的逻辑问题或数学问题。STL收录的算法经过了数学上的效能分析与证明，是极具复用价值的，包括常用的排序，查找等等。特定的算法往往搭配特定的数据结构，算法与数据结构相辅相成。

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

再好的编程技巧，也无法让一个笨拙的算法起死回生。

3、迭代器
迭代器(iterator)是一种抽象的设计概念，现实程序语言中并没有直接对应于这个概念的实物。在<<Design Patterns>>一书中提供了23中设计模式的完整描述，其中iterator模式定义如下：提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。
迭代器的设计思维-STL的关键所在，STL的中心思想在于将容器(container)和算法(algorithms)分开，彼此独立设计，最后再一贴胶着剂将他们撮合在一起。从技术角度来看，容器和算法的泛型化并不困难，c++的class template和function template可分别达到目标，如果设计出两这个之间的良好的胶着剂，才是大难题。

迭代器的种类:

输入迭代器	提供对数据的只读访问	只读，支持++、==、！=
输出迭代器	提供对数据的只写访问	只写，支持++
前向迭代器	提供读写操作，并能向前推进迭代器	读写，支持++、==、！=
双向迭代器	提供读写操作，并能向前和向后操作	读写，支持++、--，
随机访问迭代器	提供读写操作，并能以跳跃的方式访问容器的任意数据，是功能最强的迭代器	读写，支持++、--、[n]、-n、<、<=、>、>=

 

 

 

 

 

 

 

 

 

 

 

 

练习：三大组件基本使用

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

//容器vector
#include<vector>

//使用系统算法的头文件
#include<algorithm>

//迭代器，遍历功能，用指针理解
//普通指针也算一种迭代器
void test01()
{
    int array[5] = { 1, 3, 5, 6, 8};
    
    int* p = array;//指针指向数组首地址array[0]
    
    for(int i = 0; i < 5; i++)
    {
        //cout << array[i] << endl;
        cout << *(p++) << endl;
    }
    
}

void myPrint(int v)
{
    cout << v << endl;
}

void test02()
{
    //声明容器
    vector<int> v;//声明一个容器，这个容器中存放int类型数据，对象名称v
    //向容器中加入数据
    
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);
    
    //遍历容器中的数据
    
    /*
    //第一种遍历
    
    //利用迭代器
    vector<int>::iterator itBegin = v.begin();//itBegin指向的是v容器中的起始位置
    
    vector<int>::iterator itEnd = v.end();//itEnd指向v容器中最后一个位置的下一个地址
    
    while(itBegin != itEnd)
    {
        cout << *itBegin << endl;
        
        itBegin++;
        
    }
    */
    /*
    //第二种遍历方式
    //for(int i = 0; i < 5; i++)//对比
    for(vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << endl;
    }
    */
    
    //第三种遍历方式——利用算法
    for_each(v.begin(), v.end(), myPrint);
    
}

//操作自定义的数据类型
class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    
    string m_Name;
    int m_Age;
}

void test03()
{
    vector<Person> v;
    Person p1("大头儿子", 10);
    Person p1("小头爸爸", 32);
    Person p1("隔壁王叔叔", 30);
    Person p1("围裙妈妈", 28);
    
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    
    //遍历
    //注意：(*it)是<Person>，it是迭代器iterator，是一个指针
    for(vector<Person>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << "姓名：" << (*it).m_Name << "年龄：" << it->m_Age << endl;
    }
    
}

//存放自定义数据类型的指针
void test04()
{
    vector<Person*> v;
    Person p1("大头儿子", 10);
    Person p1("小头爸爸", 32);
    Person p1("隔壁王叔叔", 30);
    Person p1("围裙妈妈", 28);
    
    v.push_back(&p1);
    v.push_back(&p2);
    v.push_back(&p3);
    v.push_back(&p4);
    
    //遍历
    //注意：(*it)是<Person*>
    for(vector<Person*>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << "姓名：" << (*it)->m_Name << "年龄：" << (*it)->m_Age << endl;
    }
    
}

//容器嵌套容器
void test05()
{
    vector<vector<int>> v;
    
    vector<int>v1;
    vector<int>v2;
    vector<int>v3;
    
    for(int i = 0; i < 5; i++)
    {
        v1.push_back(i);
        v2.push_back(i + 10);
        v3.push_back(i + 100);
    }
    //将小容器放入到大容器中
    v.push_back(v1);
    v.push_back(v2);
    v.push_back(v3);
    
    //遍历所有数据
    for(vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++)
    {
        for(vector<int>::iterator vit = (*it).begin(); vit != (*it).end; vit++)
        {
            cout << *vit << endl;
        }
        cout << endl;
    }
    
}



int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

 

三、常用容器

1、string容器

---

C风格字符串(以空字符结尾的字符数组)太过复杂难于掌握，不适合大程序的开发，所以C++标准库定义了一种string类，定义在头文件<string>。

String和c风格字符串对比：
》Char*是一个指针，String是一个类
string封装了char*，管理这个字符串，是一个char*型的容器。
》String封装了很多实用的成员方法
查找find，拷贝copy，删除delete 替换replace，插入insert
》不用考虑内存释放和越界
 string管理char*所分配的内存。每一次string的复制，取值都由string类负责维护，不用担心复制越界和取值越界等。

 

string和c-style字符串转换

在c++中存在一个从const char*到string的隐式类型转换，却不存在从一个string对象到C_string的自动类型转换。对于string类型的字符串，可以通过c_str()函数返回string对象对应的C_string.

  通常，程序员在整个程序中应坚持使用string类对象，直到必须将内容转化为char*时才将其转换为C_string.

为了修改string字符串的内容，下标操作符[]和at都会返回字符的引用。但当字符串的内存被重新分配之后，可能发生错误.

---

（1）构造、赋值

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

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

string基本赋值操作
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赋给当前字符串
string& assign(const string &s, int start, int n);//将s从start开始n个字符赋值给字符串
*/

void test01()
{
    string str;//默认构造
    string str2(str);//拷贝构造
    string str3 = str;//等价于上面的
    
    string str4 = "abcd";
    string str5(10, 'a');
    
    cout << str4 << endl;
    cout << str5 << endl;
    
    //基本赋值
    str = "hello";
    str2 = str4;
    
    //string& assign(const char *s);//把字符串s赋给当前的字符串
    str3.assign("abcdef", 4);
    cout << str3 << endl;
    
    //string& assign(const string &s, int start, int n);//将s从start开始n个字符赋值给字符串
    str6.assign(str, 1, 3);//ell?hel？从0索引
    cout << str6 << endl;
}

int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

（2）练习string容器API

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
//系统标准异常头文件
#include<stdexcept>

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

void test01()
{
    string s = "hello world";
    
    for(int i = 0; i < s.size(); i++)
    {
        //cout << s[i] << endl;
        cout << s.at(i) << endl;
    }
    //[]和at区别？访问越界，[]直接挂掉，at会抛出异常
    
    try
    {
        //cout << s[100] << endl;
        cout << s.at(100) << endl;
    }
    catch(out_of_range& e)
    {
        cout << e.what() << endl;
    }
    catch(...)
    {
        cout << "越界异常" << endl;
    }
}

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

//string查找和替换
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
*/

void test02()
{
    //拼接
    string s1 = "我";
    string s2 = "爱北京";
    s1 += s2;
    cout << s1 << endl;
    
    s1.append("天安门");
    cout << s1 << endl;
    
    //查找
    string s = "abcdefg";
    int pos = s.find("bcf");//找不到返回是-1
    cout << "pos = " << pos << endl;
    
    int pos2 = s.rfind("bc");//rfind和find结果一样，内部查找顺序相反
    cout << "pos2 = " << pos2 << endl;//2
    
    //替换
    string s3 = "hello";
    s3.replace(1, 3, "1111");
    cout << s3 << endl;//h1111o
}

/*
//string比较操作
compare函数在>时返回 1，<时返回 -1，==时返回 0。
比较区分大小写，比较时参考字典顺序，排越前面的越小。
大写的A比小写的a小。
int compare(const string &s) const;//与字符串s比较
int compare(const char *s) const;//与字符串s比较
*/
void test03()
{
    string s1 = "abc";
    string s2 = "abcd";
    
    if(s1.compare(s2) == 0)
    {
        cout << "s1等于s2" << endl;
    }
    else if(s1.compare(s2) == 1)
    {
        cout << "s1大于s2" << endl;
    }
    else
    {
        cout << "s1小于s2" << endl;
    }
}

/*
//string子串
string substr(int pos = 0, int n = npos) const;//返回由pos开始的n个字符组成的字符串
*/
void test04()
{
    string s1 = "abcde";
    string s2 = s1.substr(1, 3);
    cout << s2 << endl;
    
    //需求查找一个邮件的用户名
    string email = "zhangtao@sina.com";
    
    int pos = email.find("@");//8
    cout << "pos" << pos << endl;
    
    string usrName = email.substr(0, pos);
    cout << "用户名：" << usrName << endl;
}

/*
//string插入和删除操作
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个字符 
*/
void test05()
{
    string s1 = "hello";
    s1.insert(1, "111");
    cout << s1 << endl;//h111ello
    
    //删除
    s1.erase(1, 3);
    cout << s1 << endl;
}

/*
string和c-style字符串转换
*/
void func(string s)
{
    cout << s << endl;
}
void func2(const char* s)
{
    cout << s << endl;
}

void test06()
{
    string s = "abc";
    
    //string -> const char*
    const char* p = s.c_str();
    
    func(p);//const char* 隐式类型转换为string
    
    //const char* -> string
    string s2(p);
    //func2(s2);//string不能隐式类型转换为char*
}



int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

（3）重新分配内存

练习：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

void test01()
{
    string s = "abcdefg";
    char& a = s[2];
    char& b = s[3];

    a = '1';
    b = '2';

    cout << s << endl;//ab12efg
    cout << (int*)s.c_str() << endl;//输出地址

    s = "pppppppppppppppppppppppp";//内存不够，重新分配内存，下边操作出错

    //a = '1';
    //b = '2';

    cout << s << endl;
    cout << (int*)s.c_str() << endl;

    
}

int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

（4）练习——字母大小写更改

写一个函数，函数内部将string字符串中的所有小写字母都变为大写字母

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

/*
写一个函数，函数内部将string字符串中的所有小写字母都变为大写字母
*/

void test01()
{
    string s = "abCdEfg";
    for(int i = 0; i < s.size(); i++)
    {
        s[i] = toupper(s[i]);
        
        //全变小写
        //s[i] = tolower(s[i]);
    }
    cout << s << endl;
    
    
}

int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

 

2、vector容器

---

vector的数据安排以及操作方式，与array非常相似，两者的唯一差别在于空间的运用的灵活性。Array是静态空间，一旦配置了就不能改变，要换大一点或者小一点的空间，可以，一切琐碎得由自己来，首先配置一块新的空间，然后将旧空间的数据搬往新空间，再释放原来的空间。Vector是动态空间，随着元素的加入，它的内部机制会自动扩充空间以容纳新元素。因此vector的运用对于内存的合理利用与运用的灵活性有很大的帮助，我们再也不必害怕空间不足而一开始就要求一个大块头的array了。

Vector的实现技术，关键在于其对大小的控制以及重新配置时的数据移动效率，一旦vector旧空间满了，如果客户每新增一个元素，vector内部只是扩充一个元素的空间，实为不智，因为所谓的扩充空间(不论多大)，一如刚所说，是”配置新空间-数据移动-释放旧空间”的大工程,时间成本很高，应该加入某种未雨绸缪的考虑，稍后我们便可以看到vector的空间配置策略。

Vector维护一个线性空间，所以不论元素的型别如何，普通指针都可以作为vector的迭代器，因为vector迭代器所需要的操作行为，如operaroe*, operator->, operator++, operator--, operator+, operator-, operator+=, operator-=, 普通指针天生具备。Vector支持随机存取，而普通指针正有着这样的能力。所以vector提供的是随机访问迭代器(Random Access Iterators).

根据上述描述，如果我们写如下的代码：

Vector<int>::iterator it1;

Vector<Teacher>::iterator it2;

it1的型别其实就是Int*,it2的型别其实就是Teacher*.

 

vector的数据结构
Vector所采用的数据结构非常简单，线性连续空间，它以两个迭代器_Myfirst和_Mylast分别指向配置得来的连续空间中目前已被使用的范围，并以迭代器_Myend指向整块连续内存空间的尾端。
为了降低空间配置时的速度成本，vector实际配置的大小可能比客户端需求大一些，以备将来可能的扩充，这边是容量的概念。换句话说，一个vector的容量永远大于或等于其大小，一旦容量等于大小，便是满载，下次再有新增元素，整个vector容器就得另觅居所。

注意：
所谓动态增加大小，并不是在原空间之后续接新空间(因为无法保证原空间之后尚有可配置的空间)，而是一块更大的内存空间，然后将原数据拷贝新空间，并释放原空间。因此，对vector的任何操作，一旦引起空间的重新配置，指向原vector的所有迭代器就都失效了。这是程序员容易犯的一个错误，务必小心。

---

（1）练习：容量动态改变

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
//加入vector头文件
#include<vector>

void test01()
{
    vector<int> v;
    for (int i = 0; i < 10;i ++){
        v.push_back(i);
        cout << v.capacity() << endl;  // v.capacity()容器的容量
    }
    
}

int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

（2）API测试

测试1：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
//加入vector头文件
#include<vector>

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

//例子 使用第二个构造函数 我们可以...
15 int arr[] = {2,3,4,1,9};
16 vector<int> v1(arr, arr + sizeof(arr) / sizeof(int));

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

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


*/

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

void test01()
{
    vector<int> v;
    int arr[] = {2,3,4,1,9};
    vector<int> v1(arr, arr + sizeof(arr) / sizeof(int));
    
    vector<int> v2(v1.begin(), v1,end());
    
    printVector(v2);
    
    vector<int>v3{10, 100};
    printVector(v3);
    
    //赋值使用
    vector<int>v4;
    v4.assign(v3.begin(), v3.end());
    printVector(v4);
    
    v4.swap(v2);
    cout << "交换后的v4:" << endl;
    printVector(v4);//2 3 4 1 9
    
    cout << "v4容器的大小" << v4.size() << endl;//5
    
    if(v4.empty())
    {
        cout << "v4空" << endl;
    }
    else
    {
        cout << "v4不空" << endl;
    }
    
    v4.resize(10);//第二个参数是默认值，默认是0
    printVector(v4);//2 3 4 1 9 0 0 0 0 0
    
    v4.resize(10, -1);
    printVector(v4);//2 3 4 1 9 -1 -1 -1 -1 -1
    
    v4.resize(3);
    printVector(v4);//2 3 4
    
}

int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

测试2：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
//加入vector头文件
#include<vector>
//加入list头文件
#include<list>

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

//例子 使用第二个构造函数 我们可以...
int arr[] = {2,3,4,1,9};
vector<int> v1(arr, arr + sizeof(arr) / sizeof(int));

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

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

*/

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

void test01()
{
    vector<int> v;
    int arr[] = {2,3,4,1,9};
    vector<int> v1(arr, arr + sizeof(arr) / sizeof(int));
    
    vector<int> v2(v1.begin(), v1,end());
    
    printVector(v2);
    
    vector<int>v3(10, 100);
    printVector(v3);
    
    //赋值使用
    vector<int>v4;
    v4.assign(v3.begin(), v3.end());
    printVector(v4);
    
    v4.swap(v2);
    cout << "交换后的v4:" << endl;
    printVector(v4);//2 3 4 1 9
    
    cout << "v4容器的大小" << v4.size() << endl;//5
    
    if(v4.empty())
    {
        cout << "v4空" << endl;
    }
    else
    {
        cout << "v4不空" << endl;
    }
    
    v4.resize(10);//第二个参数是默认值，默认是0
    printVector(v4);//2 3 4 1 9 0 0 0 0 0
    
    v4.resize(10, -1);
    printVector(v4);//2 3 4 1 9 -1 -1 -1 -1 -1
    
    v4.resize(3);
    printVector(v4);//2 3 4
    
}

//巧用swap收缩空间
void test02()
{
    vector<int>v;
    for(int i = 0; i < 100000; i++)
    {
        v.push_back(i);
    }
    
    cout << "v的容量：" << v.capacity() << endl;//大于100000
    cout << "v的大小：" << v.size() << endl;//100000
    
    v.resize(3);
    cout << "v的容量：" << v.capacity() << endl;//大于100000
    cout << "v的大小：" << v.size() << endl;//3
    
    //巧用swap收缩空间
    vector<int>(v).swap(v);
    //vector<int>(v)利用v初始化匿名对象，swap交换指针
    
    cout << "v的容量：" << v.capacity() << endl;//3
    cout << "v的大小：" << v.size() << endl;//3
}
//reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问
void test03()
{
    vector<int>v;
    
    v.reserve(100000);//预留空间
    
    int* p = NULL;
    int num = 0;
    for(int i = 0; i < 100000; i++)
    {
        v.push_back(i);
        if(p != &v[0])
        {
            p = &v[0];
            num++;
        }
    }
    cout << num << endl;//放置100000个数据开辟过多少次空间
}

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

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

*/

void test04()
{
    vector<int>v;
    v.push_back(10);
    v.push_back(30);
    v.push_back(20);
    v.push_back(50);
    
    cout << "v的front为：" << v.front() << endl;//10
    cout << "v的front为：" << v.back() << endl;//50
    
    
    v.insert(v.begin(), 2, 100);//参数1：迭代器；参数2：个数N；参数3：具体插入的内容
    printVector(v);//100 100 10 30 20 50
    
    v.pop_back();//尾删
    printVector(v);//100 100 10 30 20
    
    v.erase(v.begin());
    printVector(v);//100 10 30 20
    
    v.erase(v.begin(),v.end());
    //v.clear();//清空所有数据
    if(v.empty())
    {
        cout << "v为空" << endl;
    }
    
}

void test05()
{
    //逆序遍历
    vector<int>v;
    for(int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    //printVector(v);//0 1 ... 9
    
    //reverse_iterator逆序迭代器
    for(vector<int>::reverse_iterator it = v.rbegin(); it != v.rend(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
    
    //vector迭代器是随机访问的迭代器，支持跳跃式访问
    vector<int>::iterator itBegin = v.begin();
    itBegin = itBegin + 3;
    //如果上述写法不报错，这个迭代器是随机访问迭代器
    
    list<int>l;
    for(int i = 0; i < 10; i++)
    {
        l.push_back(i);
    }
    list<int>::iterator lIt = l.begin();
    //lIt = lIt + 1;//list不支持随机访问
    
}

int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

3、deque容器

---

deque容器基本概念
Vector容器是单向开口的连续内存空间，deque则是一种双向开口的连续线性空间。所谓的双向开口，意思是可以在头尾两端分别做元素的插入和删除操作，当然，vector容器也可以在头尾两端插入元素，但是在其头部操作效率奇差，无法被接受。


Deque容器和vector容器最大的差异，一在于deque允许使用常数项时间对头端进行元素的插入和删除操作。二在于deque没有容量的概念，因为它是动态的以分段连续空间组合而成，随时可以增加一段新的空间并链接起来，换句话说，像vector那样，”旧空间不足而重新配置一块更大空间，然后复制元素，再释放旧空间”这样的事情在deque身上是不会发生的。也因此，deque没有必须要提供所谓的空间保留(reserve)功能.
虽然deque容器也提供了Random Access Iterator,但是它的迭代器并不是普通的指针，其复杂度和vector不是一个量级，这当然影响各个运算的层面。因此，除非有必要，我们应该尽可能的使用vector，而不是deque。对deque进行的排序操作，为了最高效率，可将deque先完整的复制到一个vector中，对vector容器进行排序，再复制回deque.

deque容器实现原理
Deque容器是连续的空间，至少逻辑上看来如此，连续现行空间总是令我们联想到array和vector,array无法成长，vector虽可成长，却只能向尾端成长，而且其成长其实是一个假象，事实上(1) 申请更大空间 (2)原数据复制新空间 (3)释放原空间 三步骤，如果不是vector每次配置新的空间时都留有余裕，其成长假象所带来的代价是非常昂贵的。
Deque是由一段一段的定量的连续空间构成。一旦有必要在deque前端或者尾端增加新的空间，便配置一段连续定量的空间，串接在deque的头端或者尾端。Deque最大的工作就是维护这些分段连续的内存空间的整体性的假象，并提供随机存取的接口，避开了重新配置空间，复制，释放的轮回，代价就是复杂的迭代器架构。
既然deque是分段连续内存空间，那么就必须有中央控制，维持整体连续的假象，数据结构的设计及迭代器的前进后退操作颇为繁琐。Deque代码的实现远比vector或list都多得多。
Deque采取一块所谓的map(注意，不是STL的map容器)作为主控，这里所谓的map是一小块连续的内存空间，其中每一个元素(此处成为一个结点)都是一个指针，指向另一段连续性内存空间，称作缓冲区。缓冲区才是deque的存储空间的主体。

---

（1）测试API

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
//加入deque头文件
#include<deque>

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

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

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


*/

void printDeque(const deque<int>& d)
{
    //iterator 普通迭代器；reverse_iterator 逆序迭代器；const_iterator 只读迭代器
    for(deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    {
        //*it = 10000;//能修改，为避免修改，参数加入const，并把迭代器更改为只读迭代器
        cout << *it << " ";
    }
    cout << endl;
}

void test01()
{
    deque<int>d;
    
    d.push_back(10);
    d.push_back(40);
    d.push_back(30);
    d.push_back(20);
    
    printDeque(d);//10 40 30 20
    
    deque<int>d2(d.begin(), d.end());
    d2.push_back(10000);
    
    //交换
    d.swap(d2);
    printDeque(d);//10 40 30 20 10000
    
    if(d1.empty())
    {
        cout << "d1为空" << endl;
    }
    else
    {
        cout << "d1不为空，大小为：" << d1.size() << endl;
    }
}

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

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

//deque插入操作
insert(pos,elem);//在pos位置插入一个elem元素的拷贝，返回新数据的位置。
insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。

//deque删除操作
clear();//移除容器的所有数据
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);//删除pos位置的数据，返回下一个数据的位置。

*/

void test02()
{
    deque<int>d;
    d.push_back(10);
    d.push_back(30);
    d.push_back(20);
    d.push_front(100);
    d.push_front(200);
    
    printDeque(d);//200 100 10 30 20
    
    //删除 头删 尾删
    d.pop_back();
    d.pop_front();
    printDeque(d);//100 10 30
    
    cout << "front为：" << d.front() << endl;//100
    cout << "back为：" << d.back() << endl;//30
    
    //插入
    deque<int>d2;
    d2.push_back(50);
    d2.push_back(60);
    
    d2.insert(d2.begin(), d.begin(), d.end());
    printDeque(d2);//100 10 30 50 60
    
}

int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

（2）排序——sort

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
//加入deque头文件
#include<deque>
//加入算法
#include<algorithm>

void printDeque(const deque<int>& d)
{
    //iterator 普通迭代器；reverse_iterator 逆序迭代器；const_iterator 只读迭代器
    for(deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    {
        //*it = 10000;//能修改，为避免修改，参数加入const，并把迭代器更改为只读迭代器
        cout << *it << " ";
    }
    cout << endl;
 }

//排序规则
bool myCompare(int v1, int v2)
{
    return v1 > v2;
}


//排序 sort
void test01()
{
    deque<int>d;
    d.push_back(5);
    d.push_back(15);
    d.push_back(3);
    d.push_back(40);
    d.push_back(7);
    
    printDeque(d);
    
    //排序
    sort(d.begin(), d.end());
    printDeque(d);
    
    //从大到小
    sort(d.begin(), d.end(), myCompare);
    printDeque(d);
}



int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

（3）作业——评委打分

有5名选手：选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分。
//1. 创建五名选手，放到vector中
//2. 遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中
//3. sort算法对deque容器中分数排序，pop_back pop_front去除最高和最低分
//4. deque容器遍历一遍，累加分数，累加分数/d.size()
//5. person.score = 平均分

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include<vector>
#include<deque>
#include<algorithm>
#include<string>

/*
有5名选手：选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分。
//1. 创建五名选手，放到vector中
//2. 遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中
//3. sort算法对deque容器中分数排序，pop_back pop_front去除最高和最低分
//4. deque容器遍历一遍，累加分数，累加分数/d.size()
//5. person.score = 平均分
*/



//排序 sort
void test01()
{
    //1. 创建五名选手，放到vector中
    vector<char>vPerson{ 'A', 'B', 'C', 'D', 'E' };
    //2. 遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中
    deque<int>dScore;
    for (vector<char>::iterator it = vPerson.begin(); it != vPerson.end(); it++)
    {
        cout << "为选手" << *it << "打分" << endl;
        for (int num = 1; num < 11; ++num)
        {
            cout << "第" << num << "个评委" << "为选手" << *it << "打分为：" << endl;
            int Score;
            //判断分数的合法性
            while (true)
            {
                cin >> Score;
                //if (Score >= 0 && Score <= 100)
                //{
                //    dScore.push_back(Score);
                //    break;
                //}
                if (cin.fail())
                {
                    cout << "对不起，请输入正确的分数：" << endl;
                    //重置标志位
                    cin.clear();
                    char buf[1024];
                    cin.getline(buf, 1024);
                    //cin.sync();//清空缓冲区
                }
                else if (Score >= 0 && Score <= 100)
                {
                    dScore.push_back(Score);
                    break;
                }

            }
            
        }
        //3. sort算法对deque容器中分数排序，pop_back pop_front去除最高和最低分
        sort(dScore.begin(), dScore.end());
        dScore.pop_back();
        dScore.pop_front();
        double sumScore = 0;
        double avgScore = 0;
        //4. deque容器遍历一遍，累加分数，累加分数/d.size()
        for (deque<int>::const_iterator itd = dScore.begin(); itd != dScore.end(); itd++)
        {
            sumScore = sumScore + *itd;
        }
        //5. person.score = 平均分
        avgScore = sumScore / dScore.size();

        //清空容器dScore
        dScore.clear();
        //清空屏幕
        system("cls");

        //显示A的分数
        cout << "选手" << *it << "平均分为：" << avgScore << endl;
    }


}



int main()
{
    test01();

    system("pause");
    return EXIT_SUCCESS;
}

 

 

四、总结

1    三大组件
1.1    容器 vector
1.2    算法 for_each 头  algorithm
1.3    迭代器  iterator  每个容器有专属迭代器
1.3.1    vector<int >v  
1.3.2    vector<int>::iterator  it = …..
1.3.3    v.begin() 指向第一个数据
1.3.4    v.end 指向 最后一个数据的下一个地址
2    string容器
2.1    构造 、 赋值 assign
2.2    对字符存取 [] at区别
2.2.1    []访问越界 直接挂
2.2.2    at 抛出 异常 out_of_range
2.3    substr  配合 find查找 邮件用户名
2.4    char *  string 互转
2.4.1    char * 隐式转换 string 反之不可以
2.5    转大写 toupper  
2.6    find  如果找不到  返回 -1
2.6.1    找到返回第一次出现的位置
3    vector容器  单端数组、动态数组
3.1    构造、赋值、
3.2    大小 size 重置大小 resize 容量 capacity
3.3    是否为空 empty 交换 swap
3.4    巧用swap收缩空间
3.5    reserve 预留空间
3.6    insert 插入（迭代器） erase删除 （迭代器） clear（）清空容器
3.7    pop_back 尾删 front 第一个数据  back最后一个数据
3.8    逆序遍历 reverse_iterator    rbegin rend
3.9    如果区分迭代器是否支持随机访问   
4    deque容器
4.1    双端数组  没有容量
4.2    API  赋值、构造、大小、交换、插入 、删除
4.3    头部删除 头部插入
4.3.1    pop_front
4.3.2    push_front
4.4    3中迭代器  iterator 普通  reverse_iterator 逆序迭代器  const_iterator只读迭代器
4.5    排序 sort 引用头文件 algorithm  
4.5.1    sort(d.begin(),d.end()) 从小到大

 

在学习c++提高-STL总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。