C++之STL

C++之STL

STL概述

STL(Standard Template Library,标准模板库)
STL的6大组件：容器、算法、迭代器、适配器、仿函数、空间配置
容器：存放数据
算法：操作数据
迭代器：算法 通过迭代器 操作容器
适配器：为算法 提供更多的接口
仿函数：为算法 提供策略
空间配置：为算法、容器提供动态空间
算法分类：质变算法、非质变算法
质变算法：会更改容器的值（拷贝，替换，删除等等）
非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等

容器

string容器

1、stirng的构造函数和赋值

1、stirng的构造函数：
 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个字符赋值给字符串

eg：

int main()
{
    //string(const char* s);//使用字符串s初始化
    string str("hello");
    //string(const string& str);//使用一个string对象初始化另一个string对象
    string str2=string(str);
    //string(int n, char c);//使用n个字符c初始化 v
    string h=string(5,'H');//HHHHH

    // string& operator=(const char* s);//char*类型字符串 赋值给当前的字符串

    str="world";

    //string& operator=(const string &s);//把字符串s赋给当前的字符串
    str=str2;
    //string& operator=(char c);//字符赋值给当前的字符串
    str='A';
    //string& assign(const char *s);//把字符串s赋给当前的字符串
    str.assign("hello");
    //string& assign(const char *s, int n);//把字符串s的前n个字符赋给当前的字符串
    str.assign("hello",3);
    //string& assign(const string &s);//把字符串s赋给当前字符串
    str.assign(str2);
    //string& assign(int n, char c);//用n个字符c赋给当前字符串
    h.assign(5,'H');
    //string& assign(const string &s, int start, int n);//将s从start开始n个字符赋值给字符串
    str.assign(str2,0,5);

    return 0;
}

2、string存取字符操作

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

    string str("hello");
    cout<<str[1]<<endl;//e
    cout<<str.at(1)<<endl;//e

两者区别：[] 越界不会抛出异常 ，at越界会抛出异常

try
 {
 //str1[1000]='A';
 str1.at(1000)='A';
 }
 catch(exception &e)
{
 cout<<"捕获到异常:"<<e.what()<<endl;
}

3、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

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

5、string比较操作

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

6、提取string子串

string substr(int pos = 0, int n = npos) const;
//返回由pos开始的n个字符组成的字符串  pos是起始位置，n是长度

void test06()
 {
 string str1="hehehe:hahaha:xixixi:lalala";
 int pos = 0;
 while(1)
 {
 int ret = str1.find(":", pos);
 string tmp = str1.substr(pos, ret‐pos);
 cout<<tmp<<endl;

 pos = ret+1;
 }
 }

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

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


int main()
{
    string str="hello";
    str.insert(2,"###");//he###llo
    cout<<str<<endl;
    str.erase(2,3);//hello
    cout<<str<<endl;
    return 0;
}

8、 string和c-style字符串转换

    string str="hello"; //char *  =>  string （认支持）
    char *h=str;        //string => char * 报错

string转换成char* 必须使用成员函数c_str(c_str的返回值是const char *)

   
    char *h=(char *)str.c_str();//强转,将const char *转成char*
    
    char *h2=const_cast<char *>(str.c_str());

vector容器

单端动态数组容器

push_back尾部插入元素、pop_back尾部删除元素
front()头元素、back()尾元素
begin()得到的是 容器的 起始迭代器（首元素的位置）
end() 得到的是 结束迭代器（尾元素的下一个元素位置

必须包含头文件：#include<vector>

#include <iostream>
#include<vector>
using namespace std;


int main()
{
    vector<int> v1;
    v1.push_back(10);
    v1.push_back(20);
    v1.push_back(30);
    v1.push_back(40);

    //遍历容器
    vector<int>::iterator it=v1.begin();//定义一个迭代器iterator 保存是元素的位置
    for(;it!=v1.end();it++){
        cout<<*it<<endl;
    }
    return 0;
}

vector的未雨绸缪机制：

#include <iostream>
#include<vector>
using namespace std;

int main()
{
    vector<int> v;
    cout<<"容量:"<<v.capacity()<<" "<<"大小:"<<v.size()<<endl;
    vector<int>::iterator it;
    int i=0;
    int count=0;
    for(i=1;i<=1000;i++){
        v.push_back(1);
        if(it!=v.begin()){
            count++;
            cout<<"第"<<count<<"开辟空间，容量为:"<<v.capacity()<<endl;
            it=v.begin();
        }
    }
    return 0;
}

容量:0 大小:0
第1开辟空间，容量为:1
第2开辟空间，容量为:2
第3开辟空间，容量为:4
第4开辟空间，容量为:8
第5开辟空间，容量为:16
第6开辟空间，容量为:32
第7开辟空间，容量为:64
第8开辟空间，容量为:128
第9开辟空间，容量为:256
第10开辟空间，容量为:512
第11开辟空间，容量为:1024

vector API

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

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，若容器变长，则以默认值0填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
resize(int num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

capacity();//容器的容量
reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问

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

巧用swap收缩空间：

int main()
{
    vector<int> v1;
    v1.reserve(1000);//预留1000个空间
    v1.assign(5,10);//存入5个10
    cout<<"大小:"<<v1.size()<<"容量:"<<v1.capacity()<<endl;
    vector<int>(v1).swap(v1);//拷贝构造一个和v1一样的匿名vector，再和v1交换
    cout<<"大小:"<<v1.size()<<"容量:"<<v1.capacity()<<endl;


    return 0;
}

大小:5容量:1000
大小:5容量:5

容器嵌套容器

int main()
{

    vector<int> v1(5,10);
     vector<int> v2(5,100);
    vector<int> v3(5,1000);
    vector<vector<int>> v;
    v.push_back(v1);
    v.push_back(v2);
    v.push_back(v3);
//遍历
          vector<vector<int>>::iterator mit;
          for(mit=v.begin();mit!=v.end();mit++){
              vector<int>::iterator it;
              for(it=(*mit).begin();it!=(*mit).end();it++){
                  cout<<*it<<" ";
              }
              cout<<endl;
          }

    return 0;
}

打印结果

10 10 10 10 10
100 100 100 100 100
1000 1000 1000 1000 1000

使用算法 对 vector容器排序

需要引入算法的头文件

#include<algorithm>

#include <iostream>
#include<vector>
#include<algorithm>
using namespace std;


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

bool myCompare(int a,int  b){
    return a<b;
}

int main()
{

     vector<int> v1;
     v1.push_back(20);
     v1.push_back(60)