string

一般第一个参数表示下标，第二个参数表示长度或者字符串

在字符串中插入

string& insert (size_t pos, const string& str); //在pos位置上插入string对象
string& insert (size_t pos, const char* s);     //在pos位置上插入字符串
iterator insert (iterator p, char c);           //在迭代器p的位置上插入字符c

在字符串中删除

string& erase (size_t pos = 0, size_t len = npos);  //删除pos位置开始的n个字符
iterator erase (iterator p);    //删除pos位置的字符
iterator erase (iterator first, iterator last);//删除[pos1，pos2)上所有字符

交换

void swap (string& x, string& y);
void swap (string& str);

    string s1("Hello");
    string s2("World");

    //void swap (string& x, string& y);
    s1.swap(s2);

    //void swap (string& str);
    swap(s1, s2);

清空

void clear();

for遍历

string s("CSDN");
    //使用范围for访问对象元素
    for (auto e : s)
    {
        cout << e;
    }
    cout << endl; //CSDN

    //使用范围for访问对象元素，并对其进行修改
    for (auto& e : s) //需要修改对象的元素，e必须是引用类型
    {
        e = 'x';
    }
    cout << s << endl; //xxxx
    return 0;

迭代器遍历

//使用迭代器访问对象元素
    string s1("Hello csdn");

    for (auto it = s1.begin(); it != s1.end(); it++)
    {
        *it = toupper(*it);
    }
    cout << s1;     //HELLO CSDN

获取子串

string substr (size_t pos = 0, size_t len = npos) const;

查找

第一种，algorithm头文件的find（）。使用方法：find（begin，end，value）解释：第一个参数是容器或者数组的起始地址（容器.begin（）或者数组名），也可以是任意地址，不非法即可；第二个参数是结束查找的地址（容器.end()或者数组名+长度），value是想要查找的字符或者字符串。查找成功将返回迭代器（容器）或者指针（数组），否则返回end（）。
第二种，string自带的find（）。使用方法：1.例如在string1中查找string2，string1.find(string2)；将返回string2第一次在string1中出现的位置。如果希望在特定位置开始查找，使用 string1.find(string2，location);

int pos = str.find(sub);//从0开始找！！！
if(pos == -1)//判断是否查到到了

str.find("字符串") 返回值是字符在母串s中的下标位置；

str.find("字符串",9)从s的下标9开始，查找字符串，返回字符串在s中的下标；

pos = s.find(str,pos)查找s中str出现的所有位置`

int i=1;
    while((pos=s.find(str,pos))!=string::npos){
        cout<<"位置"<<i<<":"<<pos<<endl;
        pos++;
        i++;
    }

pos = s.find_first_of(str) 返回str出现在母串s中的首次出现的位置

pos = s.find_last_of(str)返回str出现在母串s中的最后一次出现的位置

若查找不到则返回string::npos，为一个常数，该值用赋值为int后表示为-1，可以直接判断

二分

若查找不到则返回尾指针或尾迭代器
习惯性区间都是左开右闭

lower_bound：查找第一个大于或等于某个元素的位置。
a.函数模板：lower_bound(arr[],arr[]+size , indx):
b.参数说明：
arr[]： 数组首地址
size：数组元素个数
indx:需要查找的值

int l = lower_bound(a, a+n, k)-a;//该函数返回>=k的元素指针，注意-a

upper_bound：查找第一个大于某个元素的位置。
a.函数模板：upper_bound(arr[],arr[]+size , indx):
b.参数说明：
arr[]： 数组首地址
size：数组元素个数
indx:需要查找的值

int r = upper_bound(a, a+n, k)-a;//该函数返回<k的元素指针

vector中的用法

//返回一个迭代器，若想知道下标位置可以it-vec.begin(),取值可用*it
//若查找不到则返回vec.end()
auto it = lower_bound(vec.begin(), vec.end(), a[i]);

vector

const int m = 100;
vector<int> v1(m);      //size = 100

//初始化大小并赋值为0
vector<int> v1(m, 0);       //size = 100;  every item = 0

//拷贝vector数组
vector<int> a(m, 0);
vector<int> b(a);

（1）a.assign(b.begin(), b.begin()+3); //b为向量，将b的0~2个元素构成的向量赋给a
（2）a.assign(4,2); //是a只含4个元素，且每个元素为2
（3）a.back(); //返回a的最后一个元素
（4）a.front(); //返回a的第一个元素
（5）a[i]; //返回a的第i个元素，当且仅当a[i]存在2013-12-07
（6）a.clear(); //清空a中的元素
（7）a.empty(); //判断a是否为空，空则返回ture,不空则返回false
（8）a.pop_back(); //删除a向量的最后一个元素
（9）a.erase(a.begin()+1,a.begin()+3); //删除a中第1个（从第0个算起）到第2个元素，也就是说删除的元素从a.begin()+1算起（包括它）一直到a.begin()+ 3（不包括它）
（10）a.push_back(5); //在a的最后一个向量后插入一个元素，其值为5
（11）a.insert(a.begin()+1,5); //在a的第1个元素（从第0个算起）的位置插入数值5，如a为1,2,3,4，插入元素后为1,5,2,3,4
（12）a.insert(a.begin()+1,3,5); //在a的第1个元素（从第0个算起）的位置插入3个数，其值都为5
（13）a.insert(a.begin()+1,b+3,b+6); //b为数组，在a的第1个元素（从第0个算起）的位置插入b的第3个元素到第5个元素（不包括b+6），如b为1,2,3,4,5,9,8 ，插入元素后为1,4,5,9,2,3,4,5,9,8
（14）a.size(); //返回a中元素的个数；
（15）a.capacity(); //返回a在内存中总共可以容纳的元素个数
（16）a.resize(10); //将a的现有元素个数调至10个，多则删，少则补，其值随机
（17）a.resize(10,2); //将a的现有元素个数调至10个，多则删，少则补，其值为2
（18）a.reserve(100); //将a的容量（capacity）扩充至100，也就是说现在测试a.capacity();的时候返回值是100.这种操作只有在需要给a添加大量数据的时候才 显得有意义，因为这将避免内存多次容量扩充操作（当a的容量不足时电脑会自动扩容，当然这必然降低性能）
（19）a.swap(b); //b为向量，将a中的元素和b中的元素进行整体性交换
（20）a==b; //b为向量，向量的比较操作还有!=,>=,<=,>,<

set

原文链接

插入操作：
insert(val)：将值为val的元素插入set容器中。
insert(start, end)：将迭代器范围内的元素插入set容器中。
emplace(args)：在set容器中构造一个新元素，使用args参数传递构造参数。

删除操作：
erase(val)：从set容器中删除值等于val的元素。
erase(iterator)：删除按照迭代器指定的元素。
erase(start, end)：删除迭代器范围内的元素。
clear()：删除set容器中的所有元素。

查找操作：

count(val)：返回set容器中值等于val的元素的个数（由于set中元素唯一，所以返回值只能是0或1）。
find(val)：返回一个迭代器，指向set容器中值等于val的元素，如果未找到则返回指向容器末尾的迭代器 end()。
lower_bound(val)：返回一个迭代器，指向set容器中第一个不小于val的元素。
upper_bound(val)：返回一个迭代器，指向set容器中第一个大于val的元素。
equal_range(val)：返回一个pair，包含两个迭代器，分别指向set容器中等于val的元素的起始位置和结束位置。

统计操作：
size()：返回set容器中元素的个数。

自定义排序

#include <iostream>
#include <set>

int main() {
  std::set<int> mySet = {1, 2, 3, 4, 5};

  // 查找操作
  int count = mySet.count(3);
  std::cout << "值为3的元素在set中出现的次数：" << count << std::endl;

  auto it = mySet.find(4);
  if (it != mySet.end()) {
    std::cout << "找到了值为4的元素" << std::endl;
  } else {
    std::cout << "未找到值为4的元素" << std::endl;
  }

  auto lower = mySet.lower_bound(3);
  auto upper = mySet.upper_bound(3);
  std::cout << "大于等于3的第一个元素：" << *lower << std::endl;
  std::cout << "大于3的第一个元素：" << *upper << std::endl;

  auto range = mySet.equal_range(3);
  std::cout << "等于3的元素范围：" << *range.first << " - " << *range.second << std::endl;

  // 统计操作
  std::cout << "set的大小：" << mySet.size() << std::endl;

  return 0;
}

map

begin() 返回指向map头部的迭代器

clear(） 删除所有元素

count() 返回指定元素出现的次数, (因为key值不会重复，所以只能是1 or 0)

empty() 如果map为空则返回true

end() 返回指向map末尾的迭代器

equal_range() 返回特殊条目的迭代器对

erase() 删除一个元素

find() 查找一个元素

insert() 插入元素

size() 返回map中元素的个数

swap() 交换两个map

upper_bound() 返回键值>给定元素的第一个位置

/*
stringstream 主要被用于以下几种情况：

字符串和其他数据类型之间的转换。
从字符串中逐个提取数据。
向字符串中逐个插入数据。
作为一般的字符串处理工具。
*/

string line;
getline(cin, line);//cin属于istram流，getline属于string流，混用时记得将缓冲区最后的回车过滤掉
    while(m--)
    {
        int a[N] = {};
        getline(cin, line);//读取一整行字符串
        stringstream ssin(line);//定义一个新的流，提取字符串中的元素
        int cnt = 0, p; //cnt记录当前有多少个元素，p读取当前的元素
        while(ssin >> p) a[cnt++] = p;//将ssin中的元素存到a数组中