STL模板库学习记录（1）

概述

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

STL就是把数据结构和算法的代码制定了标准代码，其他人直接使用就可以了

数据结构和算法：
数据结构的含义：研究的是数据和数据之间的关系
数据结构的概念：数据结构指的是数据的逻辑结构、存储结构以及操作
逻辑结构：
一对一的关系：线性表、栈（先进后出）、队列（先进先出）
一对多的关系：树、二叉树
多对多：图
存储结构：
顺序存储：需要开辟一块连续的空间
链式存储：不需要开辟连续的空间
操作：
增、删、改、查

例如：
    单链表：线性表的链式存储
        
    算法：实现功能的方法

STL(Standard Template Library,标准模板库)，是惠普实验室开发的一系列软件的统
称。现在主要出现在 c++中，但是在引入 c++之前该技术已经存在很长时间了。

STL 从广义上分为: 容器(container) 算法(algorithm) 迭代器(iterator),容器和算法之间通过迭代器进
行无缝连接。STL 几乎所有的代码都采用了模板类或者模板函数，这相比传统的由函数和类组成的库来说提供了更好的代码重用机会。STL(Standard Template Library)标准模板库,在我们 c++标准程序库中隶属于 STL 的占到了 80%以上。

STL的六大组件

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

容器：

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

算法：

各种常用的算法，如sort、find、copy、for_each。从实现的角度来看，STL算法是一种函数模板

迭代器：

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

仿函数：

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

适配器：

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

空间配置器：

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

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

STL最重要的三大组件

容器

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

算法

算法，问题之解法也。
以有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法(Algorithms).
广义而言，我们所编写的每个程序都是一个算法，其中的每个函数也都是一个算法，毕竟它们都是用来解决或大或小的逻辑问题或数学问题。STL收录的算法经过了数学上的效能分析与证明，是极具复用价值的，包括常用的排序，查找等等。特定的算法往往搭配特定的数据结构，算法与数据结构相辅相成。
算法分为:质变算法和非质变算法。
质变算法：是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等等
非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等

迭代器

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

迭代器的种类:

STL案例

#include <iostream>
//每一个容器都有自己固定的头文件，头文件名字一般就是容器名字
#include <vector>
#include <string>
#include <algorithm> //算法的头文件，大多数算法都在这个里面
#include <numeric> //算法的头文件，保存少部分

using namespace std;

//vector容器的基本简单操作
//容器中保存普通数据
void PrintFromVector(int val)
{
    cout << val << " ";
}

void test1()
{
    //实例化一个vector容器的对象
    //注意：类模板实例化对象时，必须显式调用并制定数据类型
    vector<int> v;

    //调用算法插入数据
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);
    v.push_back(50);
    v.push_back(60);

    //如果获取容器中的数据，需要借助迭代器
    //vector已经定义好了一些迭代器begin() end()
    //定义一个迭代器并保存第一个数据的迭代器
    vector<int>::iterator it = v.begin();

    //遍历容器
#if 0
    while(it != v.end())
    {
        cout << *it << " ";
        it++;
    }
    cout << endl;
#endif

    for_each(v.begin(), v.end(), PrintFromVector);
    cout << endl;
}


//容器中保存类的对象
class Person
{
public:
    Person()
    {

    }

    Person(int id, string name, char sex)
    {
        this->id = id;
        this->name = name;
        this->sex = sex;
    }

    void getMsg()
    {
        cout << this->id << " " << this->name << " " << this->sex << endl;
    }

private:
    int id;
    string name;
    char sex;
};

void PrintFromPerson(Person p)
{
    p.getMsg();
}

void test2()
{
    vector<Person> v;

    v.push_back(Person(1001, "zhangsan", 'B'));
    v.push_back(Person(1002, "lisi", 'G'));
    v.push_back(Person(1003, "wangwu", 'G'));
    v.push_back(Person(1004, "zhaoliu", 'B'));

    //遍历容器
    //遍历方法1：使用while循环
#if 0
    vector<Person>::iterator it = v.begin();
    while(it != v.end())
    {
        //it此时相当于保存的是；类的对象的地址，所以*it就等价于类的对象
        (*it).getMsg();

        it++;
    }
#endif

    //遍历方法2：使用for循环
#if 0
    for(vector<Person>::iterator it = v.begin(); it < v.end(); it++)
    {
        (*it).getMsg();
    }
#endif

    //遍历方法3：使用STL中的算法
    //template<typename InputIterator, typename Function>
    //Function for_each(InputIterator beg, InputIterator end, Function f) {
    //  while(beg != end)
    //    f(*beg++); --> f(*beg); beg++;
    //}
    for_each(v.begin(), v.end(), PrintFromPerson);
}

int main(int argc, char *argv[])
{
    test2();

    return 0;
}

Result:

常用容器

String容器

基本概念

C风格字符串(以空字符结尾的字符数组)太过复杂难于掌握，不适合大程序的开发，所以C++标准库定义了一种string类，定义在头文件。
String和c风格字符串对比：
Char*是一个指针，String是一个类
string封装了char，管理这个字符串，是一个char型的容器。
 String封装了很多实用的成员方法
查找find，拷贝copy，删除delete 替换replace，插入insert
不用考虑内存释放和越界
string管理char*所分配的内存。每一次string的复制，取值都由string类负责维护，不用担心复制越界和取值越界等

String容器常用操作

1.构造函数

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

2.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个字符赋值给字符串

案例：

#include <iostream>
#include <string> //string容器的头文件

using namespace std;

//string的构造函数和赋值操作
void test1()
{
    //构造函数
    //实例化一个string的对象
    string s1("hello world");
    string s2 = string(s1);
    cout << "s1 = " << s1 << endl;
    cout << "s2 = " << s2 << endl;

    string s3 = string(10, 'h');
    cout << "s3 = " << s3 << endl;

    //赋值操作
    string s4;
    s4 = "nihao beijing";

    string s5;
    s5 = s4;

    cout << "s4 = " << s4 << endl;
    cout << "s5 = " << s5 << endl;
}

int main(int argc, char *argv[])
{
    test1();

    return 0;
}

Result：

3.string存取字符操作

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

//string存取字符操作
void test2()
{
    string s1 = "nihao beijing";
    cout << s1[2] << endl;
    cout << s1[7] << endl;
    cout << s1.at(4) << endl;
    cout << s1.at(8) << endl;
    try{
        //[]不会抛出异常
        //cout << "s1[1000] = " << s1[1000] << endl;
        
        //at会抛出异常
        cout << "s1.at(1000) = " << s1.at(1000) << endl;
    }
    catch(exception &e)
    {
        cout << e.what() << endl;
    }
}

Result：

4.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

5.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

6.string比较操作

/*
compare函数在>时返回 1，<时返回 -1，==时返回 0。
比较区分大小写，比较时参考字典顺序，排越前面的越小。
大写的A比小写的a小。
*/
int compare(const string &s) const;//与字符串s比较
int compare(const char *s) const;//与字符串s比较

案例

void test3()
{
    //拼接操作
    string s1 = string("hello world");
    s1 += "nihao beildng";
    cout << "s1 = " << s1 << endl;

    string s2 = string("hahahaha");
    s1 += s2;
    cout << "s1 = " << s1 << endl;

    //查找替换
    int ret;
    //find返回的都是实际字符串第一次出现的位置，找不到则返回-1
    ret = s1.find("ld", 0);
    cout << "ret = " << ret << endl;

    ret = s1.find("ld", 4);
    cout << "ret = " << ret << endl;

    s1 += "hello world";
    cout << "s1 = " << s1 << endl;
    //rfind:指定位置，从当前位置之前的内容中找最后一次指定字符串出现的位置
    ret = s1.rfind("ld", 20);
    cout << "ret = " << ret << endl;

    //replace：从指定位置开始将原本的n个数据替换成第三个参数
    s1.replace(5, 100, "123456");
    cout << "s1 = " << s1 << endl;
}

Result：

7.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 test4()
{
    string s1 = string("hello world");
    s1.insert(5, "666666");
    cout << "s1 = " << s1 << endl;

    s1.erase(5, 6);
    cout << "s1 = " << s1 << endl;
}

Result：

8.string子串

string substr(int pos = 0, int n = npos) const;//返回由pos开始的n个字符组成的字符串

案例：

//子串
void test5()
{
    string s1 = string("123456789");
    cout << "s1 = " << s1 << endl;

    string s2 = s1.substr(0, 4);
    cout << "s2 = " << s2 << endl;

    s2 = s1.substr(4, 4);
    cout << "s2 = " << s2 << endl;
}

void test6()
{
    //使用vector保存切割后的数据
    string s1 = string("11111:222222222:3333333:444444:55555555");

//    int pos = s1.find(':', 0);
//    cout << "pos = " << pos << endl;

//    string s2 = s1.substr(0, pos);
//    cout << "s2 = " << s2 << endl;

//    int ret = pos;
//    pos = s1.find(':', pos + 1);
//    s2 = s1.substr(ret + 1, pos - ret - 1);
//    cout << "s2 = " << s2 << endl;

    //定义vector对象
    vector<string> v;

    int pos = 0, ret;
    pos = s1.find(':', pos);
    v.push_back(s1.substr(0, pos));

    ret = pos;
    while((pos = s1.find(':', pos + 1)) != -1)
    {
        v.push_back(s1.substr(ret + 1, pos - ret - 1));
        ret = pos;
    }

    //处理最后一部分内容
    //cout << "s1.size = " << s1.size() << endl;
    v.push_back(s1.substr(ret + 1, s1.size() - ret - 1));

    for(vector<string>::iterator it = v.begin(); it < v.end(); it++)
    {
        //it --> string *
        //*it --> string
        cout << *it << endl;
    }
}

Result：

9.string和c-style字符串转换

//string 转 char*
string str = "itcast";
const char* cstr = str.c_str();
//char* 转 string
char* s = "itcast";
string str(s);

string空间的使用问题

void test7()
{
    string s = string("abcdefghijk");
    cout << "容量：" << s.capacity() << endl;
    char &s1 = s[5];
    char &s2 = s[7];

    cout << "s = " << s << endl;
    s1 = '8';
    s2 = '5';
    cout << "s = " << s << endl;

    s = "kkkkkkkkkk";
    cout << "s = " << s << endl;
    cout << "s1 = " << s1 << ", s2 = " << s2 << endl;
    cout << "容量：" << s.capacity() << endl;
    cout << (int*)s.c_str() << endl;

    s = "hhhhhhhhhhhhhhhhhhhhhhhhhh";
    cout << "s = " << s << endl;
    cout << "s1 = " << s1 << ", s2 = " << s2 << endl;
    cout << "容量：" << s.capacity() << endl;
    cout << (int*)s.c_str() << endl;
}

Result:

vector容器

概念

vector的数据安排以及操作方式，与array非常相似，两者的唯一差别在于空间的运用的灵活性。Array
是静态空间，一旦配置了就不能改变，要换大一点或者小一点的空间，可以，一切琐碎得由自己来，首先配置一块新的空间，然后将旧空间的数据搬往新空间，再释放原来的空间。Vector是动态空间，随着元素的加入，它的内部机制会自动扩充空间以容纳新元素。因此vector的运用对于内存的合理利用与运用的灵活性有很大的帮助，我们再也不必害怕空间不足而一开始就要求一个大块头的array了。
vector迭代器是一个随机访问迭代器，所以可以执行任意操作
Vector维护一个线性空间，所以不论元素的型别如何，普通指针都可以作为vector的迭代器，因为
vector迭代器所需要的操作行为，如operaroe, operator->, operator++, operator–, operator+,
operator-, operator+=, operator-=, 普通指针天生具备。

vector的未雨绸缪机制

#include <iostream>
#include <vector>
#include <stdio.h>

using namespace std;

//vector的未雨绸缪机制
//vector会随着数据插入的个数增多而扩大开辟的空间
//但是他会事先多开辟一些空间，减少每次开辟空间的个数和时间，提高效率
//只要容量不够，会先释放原来的空间，然后开辟新空间
void test1()
{
    vector<int> v;
    cout << "容量：" << v.capacity() << endl;
    cout << "实际使用：" << v.size() << endl;

    for(int i = 1; i <= 10; i++)
    {
        v.push_back(i + 10);
        cout << "i = " << i << endl;
        cout << "容量：" << v.capacity() << endl;
        cout << "实际使用：" << v.size() << endl;
        printf("&v[0] = %p\n", &v[0]);
    }
}

int main(int argc, char *argv[])
{
    test1();

    return 0;
}

Result：

vector常用API操作

1.构造函数

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));

2.常用赋值操作

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

案例

//构造函数和赋值操作
void test2()
{
    int a[] = {6, 5, 8, 9, 4};
    vector<int> v = vector<int>(a, a + sizeof(a) / sizeof(a[0]));
    PrintVectorInt(v);

    vector<int> v1;
    v1 = v;
    PrintVectorInt(v1);

    for(int i = 1; i <= 20; i++)
    {
        v1.push_back(i);
    }
    PrintVectorInt(v1);

    cout << "v容量：" << v.capacity() << "， 实际使用："<< v.size() << endl;
    cout << "v1容量：" << v1.capacity() << "， 实际使用："<< v1.size() << endl;
    
    //swap函数是将两个容器的容量和实际使用个数都直接交换
    v.swap(v1);

    cout << "v容量：" << v.capacity() << "， 实际使用："<< v.size() << endl;
    cout << "v1容量：" << v1.capacity() << "， 实际使用："<< v1.size() << endl;
}

Result：

3.大小操作

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

4.数据存取操作

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

5.插入和删除操作

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();//删除容器中所有元素

vector容量问题

//vector容量问题
void test5()
{
    vector<int> v;
    int *p = NULL;
    int num = 0;

    //如果事先知道插入容器的数据的个数，可以提前预留空间，减少重新开辟空间的次数
    v.reserve(100);

    for(int i = 1; i <= 100; i++)
    {
        v.push_back(i);

        if(p != &v[0]) //只要重新开辟空间，v[0]地址就会改变
        {
            num++;
            p = &v[0];
        }
    }

    cout << "开辟空间的次数为：" << num << endl;
}

void test6()
{
    vector<int> v;
    v.reserve(1000);

    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);
    v.push_back(50);

    cout << "容量：" << v.capacity() << "， 实际使用：" << v.size() << endl;

    //v.resize(5);
    //v.reserve(5);

    {
        vector<int> v1;
        v1 = v;
        v.swap(v1);
    }

    //vector<int>(v) --> vector<int> v1; v1 = v; v1.swap(v);
    //如果预留的空间过多，则会导致空间浪费，所以需要改变原本容器的容量
    //可以使用匿名对象调用有参构造函数并交换
    vector<int>(v).swap(v);

    cout << "v容量：" << v.capacity() << "， 实际使用：" << v.size() << endl;
}

本次记录先到这里~下一章继续学习奇怪的知识啦！！