STL, string, vector,deque

STL的诞生

• 长久以来, 软件界一直希望建立一种可重复利用的东西
• C++的面向对象和泛型编程的思想, 目的就是服用性的提升
  • 封装 : 把属性和行为相似的对象抽象成一个类, 把属性和行为封装成一个整体描述这种类型
  • 继承 : 子类继承父类的属性和行为
  • 多态 : 一个函数名称多个接口, 根据对象不同,调用不同的行为
• 大多情况下, 数据结构和算法未能有一套标准, 导致被迫重复大量工作.
• 为了建立数据结构和算法的一套标准, 诞生了STL

STL的基本概念

• STL : Standard Template Library 标准模板库
• STL从广义上分为 : 容器(container) 算法(algorithm) 迭代器(iterator)
• 容器和算法之间通过迭代器无缝连接
• STL几乎所有代码都包含了模板类和模板函数

STL六大组件

• 容器, 算法, 迭代器, 仿函数, 适配器, 空间配置器
• 容器 : 各种数据结构, 如vector, list, queue, set, map, 用来存放数据
• 算法 : 各种常用的算法, 如sort, find, copy, for_each
• 迭代器 : 容器和算法之间的胶合剂
• 仿函数 : 行为类似函数, 可以作为算法的某种策略
• 适配器 : 一种用来修饰容器或者仿函数或者迭代器接口的东西
• 空间配置器 : 负责空间的配置和管理

容器

• 序列式容器 和 关联式容器
  • 序列式容器 : 强调值的排序, 序列式容器中每个元素都有固定位置
  • 关联式容器 : 二叉树结构, 各元素之间没有严格的物理上的顺序.

算法

• 质变算法 和 非质变算法
  • 质变算法 : 运算过程中会更改区间内的元素内容, 如拷贝, 替换, 删除
  • 非质变算法 : 运算过程中不会更改区间内的元素内容, 如查找, 计数, 遍历, 寻找极值.

迭代器

• 容器用来提供数据, 算法用来解决问题. 而算法需要通过迭代器才能访问到容器中的数据

• 每个容器都有自己专属的迭代器

• 迭代器的使用非常类似指针

• 迭代器的种类

  • 输入迭代器 : 对数据只读访问
  • 输出迭代器 : 对数据只写访问
  • 前向迭代器 : 读写操作, 并能向前推进迭代器
  • 双向迭代器 : 读写操作, 并能向前和向后操作
  • 随机访问迭代器 : 读写操作, 可以跳跃的方式访问任意数据, 功能最强的迭代器

• 常用容器中的迭代器种类为双向迭代器 和 随机访问迭代器

vector容器存放内置数据类型

void printV(int val)
{
    cout<<val<<endl;
}

void test02()
{
    // 创建容器对象, 通过模板参数确定容器中存放的数据类型
    vector<int> v;
    
    // 想容器中插入数据
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);
    
    // 每一个容器都有自己的迭代器, 用来遍历容器中的元素
    // v.begin()返回一个迭代器, 指向容器中的第一个元素
    // v.end()返回一个迭代器, 指向容器中最后一个元素的下一位
    // vector<int>::iterator 拿到vector<int>这种容器的迭代器的类型
    vector<int>::iterator itBegin = v.begin();
    vector<int>::iterator itEnd = v.end();
    
    // 第一种遍历方式
    while(itBegin != itEnd)
    {
        cout<<*itBegin<<endl;
        itBegin++;
    }
    cout<<endl;
    
    // 第二种遍历方式
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout<<*it<<endl;
    }
    cout<<endl;
    
    // 第三种遍历方式, 第三个参数是一个函数名, 会传入一个*iterator参数
    for_each(v.begin(), v.end(), printV);
    
}

vector容器存放自定义数据类型

• . 运算符比 * 运算法优先级高, 所以要加()

class Person
{
public:
    Person(string name, int age) : m_age(age), m_name(name){}
    int m_age;
    string m_name;
};

void test03()
{
    vector<Person> v;
    
    Person p1("y", 10);
    Person p2("yy", 20);
    Person p3("yyy", 30);
    Person p4("yyyy", 40);
    Person p5("yyyyy", 50);
    
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    v.push_back(p5);
    
    for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
    {
//        cout<<"name : "<<it->m_name<<"   age : "<<it->m_age<<endl;
        cout<<"name : "<<(*it).m_name<<"   age : "<<(*it).m_age<<endl;
    }
    
}

void test04()
{
    vector<Person*> v;
    
    Person p1("y", 10);
    Person p2("yy", 20);
    Person p3("yyy", 30);
    Person p4("yyyy", 40);
    Person p5("yyyyy", 50);
    
    v.push_back(&p1);
    v.push_back(&p2);
    v.push_back(&p3);
    v.push_back(&p4);
    v.push_back(&p5);
    
    for(vector<Person*>::iterator it = v.begin(); it != v.end(); it++)
    {
//        cout<<"name : "<<(*it)->m_name<<"   age : "<<(*it)->m_age<<endl;
        cout<<"name : "<<(*(*it)).m_name<<"   age : "<<(*(*it)).m_age<<endl;
    }
}

容器嵌套容器

• *it 查看<>中的内容即可, <>里是什么, *it就是什么

void test05()
{
    vector<vector<int>> v;
    
    vector<int> v1;
    vector<int> v2;
    vector<int> v3;
    vector<int> v4;
    
    for(int i = 0; i < 4; i++)
    {
        v1.push_back(i + 1);
        v2.push_back(i + 2);
        v3.push_back(i + 3);
        v4.push_back(i + 4);
    }
    
    v.push_back(v1);
    v.push_back(v2);
    v.push_back(v3);
    v.push_back(v4);
    
    // 遍历大容器
    for(vector<vector<int>>::iterator it1 = v.begin(); it1 != v.end(); it1++)
    {
        // 遍历小容器
        for(vector<int>::iterator it2 = (*it1).begin(); it2 != (*it1).end(); it2++)
        {
            cout<<*it2<<" ";
        }
        cout<<endl;
    }
}

string

• 本质
  • C++风格的字符串, 本质是一个类
• string 和 char* 的区别
  • char* 是一个指针
  • string 是一个类, 封装了char*, 管理这个字符串, 是一个char*的容器
• 特点
  • string 内部封装了很多成员方法, 例如find, copy, replace, insert
  • string管理char*分配的内存, 不用担心越界问题, 由类内不负责处理

构造函数

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

void test06()
{
    string s1;
    
    const char* str = "hello world";
    string s2(str);
    cout<<"s2 = "<<s2<<endl;
    
    string s3(s2);
    cout<<"s3 = "<<s3<<endl;
    
    string s4(3, 'y');
    cout<<"s4 = "<<s4<<endl;
    
}

string 赋值操作

• string字符串, c字符串, 字符
• string, const char*, char

string字符串拼接

• const char* 和 string 是一样的
• string& append(char * s, int n); 把s的前n个字符拼接到字符串结尾
• string& append(const string& s, int pos, int n); 字符串s从pos开始的n个字符拼接到字符串结尾
  

字符串查找和替换

• find 从左往右, rfind从右往左(最后一个字符串)
• find找不到返回 -1
• replace(起始位置, 多少个, 替换字符串);
  
  
  

字符串比较

• 字符串比较主要是比较是否相等, 比较大小意义不大.

字符串存取

string插入和删除

string子串

• 从哪个位置起, 截取多少个 (第二个参数是个数, 而不是末位置)
  
  

vector容器

• vector和数组非常相似, 称为单端数组
• 不同之处在于, 数组是静态的, vector是动态扩展的
• 动态扩展 : 不是在原空间续新空间, 而是找更大的空间, 然后将原数据拷贝到新空间, 释放原空间.

vector构造函数

• 默认构造函数是一个空vector

void test08()
{
    vector<int> v1;  // 默认构造, 空vector
    for(int i = 0; i < 10; i++)
    {
        v1.push_back(i);
    }
    
    // 将一个区间中的元素拷贝构造
    vector<int> v2(v1.begin(), v1.end());
    
    // 将n个element拷贝构造
    vector<int> v3(5, 10);
    
    // 拷贝构造
    vector<int> v4(v3);
    printVector(v4);
}

vector 赋值操作

• 先利用默认构造函数创建一个空容器, 然后进行赋值

vector的容量和大小

• 重新指定容器长度是指元素个数改变, 默认填充的是0, 容量并没有变;
• 是否为空指的也是元素个数.

void test09()
{
    vector<int> v;
    for(int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    cout<<"是否为空: "<<v.empty()<<endl;
    cout<<"元素个数: "<<v.size()<<endl;
    cout<<"容器大小: "<<v.capacity()<<endl;
    printVector(v);
    v.resize(20, 2);
    cout<<"是否为空: "<<v.empty()<<endl;
    cout<<"元素个数: "<<v.size()<<endl;
    cout<<"容器大小: "<<v.capacity()<<endl;
    printVector(v);
    v.resize(5);
    cout<<"是否为空: "<<v.empty()<<endl;
    cout<<"元素个数: "<<v.size()<<endl;
    cout<<"容器大小: "<<v.capacity()<<endl;
    printVector(v);
}

vector插入和删除

• 删除的时候容量并不会跟着缩小
• 只有插入的时候, 如果超过了容量, 才会需找更大的容量, 拷贝过去.

void test10()
{
    vector<int> v;
    for(int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    printVector(v);
    v.push_back(11);
    v.push_back(12);
    v.push_back(13);
    v.pop_back();
    printVector(v);
    v.insert(v.begin(), 100);   // 位置是一个迭代器
    printVector(v);
    cout<<"是否为空: "<<v.empty()<<endl;
    cout<<"元素个数: "<<v.size()<<endl;
    cout<<"容器大小: "<<v.capacity()<<endl;
    v.insert(v.begin(), 3, 1000);
    printVector(v);
    v.erase(v.begin());
    printVector(v);
    v.erase(v.begin(), v.end());    // 位置也是一个迭代器
    printVector(v);
    cout<<"是否为空: "<<v.empty()<<endl;
    cout<<"元素个数: "<<v.size()<<endl;
    cout<<"容器大小: "<<v.capacity()<<endl;
}

vector数据存取

void test11()
{
    vector<int> v;
    for(int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    printVector(v);
    cout<<v.front()<<endl;
    cout<<v.back()<<endl;
    cout<<v[3]<<endl;
    cout<<v.at(2)<<endl;
}

vector 互换容器

• 容器互换, 不仅是元素互换, 容量也互换, 所有都互换了 (指针交换)

• 用来收缩内存

	vector<int> v3(10000, 1);
    cout<<v3.size()<<endl;
    cout<<v3.capacity()<<endl;
    v3.resize(3);
    cout<<v3.size()<<endl;
    cout<<v3.capacity()<<endl;
    vector<int>(v3).swap(v3);
    cout<<v3.size()<<endl;
    cout<<v3.capacity()<<endl;

• vector(v3) 利用拷贝构造函数, 创建了一个匿名对象, 这个匿名对象的大小和容量都是3, 然后和原来的v3进行指针互换, 匿名对象调用完后立即释放, 因此原来占据的10000的空间也自动被系统释放.

vector预留空间

• 只是分配了内存, 内存上并未初始化, 也不可访问.

void test13()
{
    vector<int> v;
    v.reserve(100000); // 19->1
    int num = 0;
    int *p = NULL;
    for(int i = 0; i < 100000; i++)
    {
        v.push_back(i);
        if(p != &v[0])
        {
            p = &v[0];
            num++;
        }
    }
    cout<<num<<endl;
}

deque 容器

• 双端数组, 两端都可以进行插入和删除
• deque和vector的区别
  • vector对头部的插入删除效率较低, 数据量越大, 效率越低
  • deque对头部的插入删除相较于vector速度较快
  • vector访问元素的速度比deque快, 这和他们的内部实现有关

内部工作原理

deque构造函数

• 和vector类似
  

• 如果想让容器中的元素只读, 相应的迭代器也要修改成const_iterator

void printDeque(const deque<int>& d)
{
    for(deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    {
        // *it = 100;  只读传入, 不能修改deque内容, 迭代器也要相应更改
        cout<<*it<<" ";
    }
    cout<<endl;
}
void test01()
{
    deque<int> d1;
    for(int i = 0; i < 10; i++)
    {
        d1.push_back(i);
    }
    printDeque(d1);
    
    deque<int> d2(d1.begin(), d1.end());
    printDeque(d2);
    
    deque<int> d3(4, 100);
    printDeque(d3);
    
    deque<int> d4(d3);
    printDeque(d4);
}

deque赋值操作

• = , 区间, n个元素, 和vector相同
  

deque大小操作

• 没有容量, 因为内部实现和vector不同, 他只需要一个中空气, 容量不限制

deque插入和删除

deque数据存取

deque排序