[系统运维]C++ Study Notes 6

->
Standard Template Library
STL广义上分为:
    容器、算法、迭代器
    容器和算法之间通过迭代器无缝连接
    STL几乎所有代码都采用了模板类或者模板函数

c++面向对象和泛型编程思想,目的就是复用性的提升

STL大体分为六大组件:
    容器        各种数据结构
    算法        sort、copy、for_each等
    迭代器       扮演了容器和算法之间的胶合剂
    仿函数          行为类似函数,可以作为算法的某种策略
    适配器(配接器)  一种用来修饰容器或者仿函数或迭代器接口的东西
    空间配置器      负责空间的配置和管理

算法通过迭代器才能访问容器中的元素、每个容器都有自己专属的迭代器

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

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

->
容器:vector
算法:for_each
迭代器:vector<int>::iterator

    #include <vector>
    #include <algorithm>
    void myPrint(int val)
    {
        cout << val << endl;
    }
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    // 第一种遍历方式
    // vector<int>::iterator itBegin = v.begin(); //起始迭代器,指向容器中第一个元素
    // vector<int>::iterator itEnd = v.end();     //结束迭代器,指向容器中最后一个元素的下一个位置
    // while (itBegin != itEnd)
    // {
    //     cout << *itBegin << endl;
    //     itBegin++;
    // }

    //第二种遍历方式
    // for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    // {
    //     cout << *it << endl;
    // }

    //第三种遍历方式,利用STL提供的遍历算法
    for_each(v.begin(), v.end(), myPrint);

->
容器嵌套
    vector<vector<int>> v;
    vector<int> v1;
    vector<int> v2;
    vector<int> v3;
    vector<int> v4;

    for (int i = 0; i < 5; 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 it = v.begin(); it != v.end(); it++)
    {
        for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
        {
            cout << *vit << " ";
        }
        cout << endl;
    }

->
string本质上是一个类
char * 是一个指针
string 是一个类,类内部封装了char *,管理这个字符串,是一个char *型的容器

特点:
    string类封装了很多成员方法  find、copy、delete、replace、insert
    string管理char *分配的内存,不用担心复制越界和取值越界等,由类内部进行负责

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

->
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);          把字符串赋值给当前字符串
    string & assign(itn n,char c);              用 n 个字符 c 赋给当前字符串


->
string拼接
实现字符串末尾拼接字符串
函数原型:
    string & operator+=(const char * str);
    string & operator+=(const char c);
    string & operator+=(const string & str);
    string & append(const char * s);            把字符串 s 连接到当前字符串结尾
    string & append(const char * s,int n);      把字符串 s 的前 n 个字符连接到当前字符串结尾
    string & append(const string & s);          
    string & append(const string & s,int pos,int n);
        字符串 s 中从pos开始的n个字符连接到当前字符串的结尾
    
->
string查找和替换
函数原型:
    返回的是位置,从0开始算
    没找到返回-1
    find从左往右找
    rfind从右往左找
    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

    string s1 = "abcdefg";
    s1.replace(1, 3, "1111");
    结果为 a1111efg  相当于bcd替换为1111

->
字符串比较
按字符的ASCII码逐个进行对比
"只有这3个返回值,不像c的strcmp"
=   返回    0
>   返回    1
<   返回    -1

函数原型:
    int compare(const string & s) const;        
    int compare(const char * s) const;          

->
访问单个字符(读)
方式:
    1. [idx]
    2. str.at(idx)

->
修改单个字符(写)
方式:
    1. [idx]='x'
    2. str.at(idx)='x'

->
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 个字符

->
从字串中获取想要的子串
string substr(int pos=0,int n=npos) const;