1
int capacity()const;    //返回当前容量（即string中不必增加内存即可存放的元素个数）
2
int max_size()const;    //返回string对象中可存放的最大字符串的长度
3
int size()const;        //返回当前字符串的大小
4
int length()const;       //返回当前字符串的长度
5
bool empty()const;        //当前字符串是否为空
6
void resize(int len,char c);//把字符串当前大小置为len，并用字符c填充不足的部分
7

8
str1.begin()
9
str1.end()
10

11
string str4 = str1 + str3;
12

13
str1 < str3
14

15
reverse(str1.begin(), str1.end());
16

17
void swap(string &s2);    //交换当前字符串与s2的值
18

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

21
string &append(const char *s);            //把c类型字符串s连接到当前字符串结尾
22
string &append(const char *s,int n);//把c类型字符串s的前n个字符连接到当前字符串结尾
23
string &append(const string &s);    //同operator+=()
24
string &append(const string &s,int pos,int n);//把字符串s中从pos开始的n个字符连接到当前字符串的结尾
25
string &append(int n,char c);        //在当前字符串结尾添加n个字符c
26
string &append(const_iterator first,const_iterator last);//把迭代器first和last之间的部分连接到当前字符串的结尾
27

28
// c.c_str()
29
string c = "abc123";
30
char *d = new char[20];
31
strcpy(d, c.c_str());//因为这里没有直接赋值，所以指针类型可以不用const char *
32

33
//strcpy(d, c); ---> 这样会报错！！！！
34
strcpy(d,"123456"); // 这里"123456"直接使用了
35

36
//find-从指定位置起向后查找，直到串尾
37
string st1("babbabab");
38

39
//1.默认从位置0（即第1个字符）开始查找
40
cout << st1.find('a') << endl;
41

42
//2.在st1中，从位置2（b，包括位置2）开始，查找a，返回首次匹配的位置
43
cout << st1.find('a', 2) << endl;
44

45
string st2("aabcbcabcbabcc");
46
str1 = "abc";
47

48
//3.从st2的位置2（b）开始匹配，返回第一次成功匹配时匹配的串（abc）的首字符在st2中的位置，失败返回-1
49
cout << st2.find(str1, 2) << endl;
50

51
//4.取abcdefg得前3个字符（abc）参与匹配，相当于st2.find("abc", 2)
52
cout << st2.find("abcdefg", 2, 3) << endl;
53

54
//rfind-从指定位置起向前查找，直到串首
55
cout << st1.rfind('a', 7) << endl;
56

57
//find_first_of-在源串中从位置pos起往后查找，只要在源串中遇到一个字符，该字符与目标串中任意一个字符相同，就停止查找，返回该字符在源串中的位置；若匹配失败，返回-1
58
string str6("bcgjhikl");
59
string str7("kghlj");
60
cout << str6.find_first_of(str7, 0) << endl;//2,从str1的第0个字符b开始找，g与str2中的g匹配，停止查找，返回g在str1中的位置2
61

62
//find_last_of-与find_first_of函数相似，只不过查找顺序是从指定位置向前
63
string str("abcdecg");
64
cout << str.find_last_of("hjlywkcipn", 6) << endl;//5,从str的位置6(g)开始向前找，g不匹配，再找c，c匹配，停止查找，返回c在str中的位置5
65

66
//find_first_not_of-在源串中从位置pos开始往后查找，只要在源串遇到一个字符，与目标串中的任意字符都不相同，就停止查找，返回该字符在源串中的位置；若遍历完整个源串，都找不到满足条件的字符，则返回-1
67
cout << str.find_first_not_of("kiajbvehfgmlc", 0) << endl;//3   从源串str的位置0(a)开始查找，目标串中有a，匹配，..,找d，目标串中没有d（不匹配），停止查找，返回d在str中的位置3
68

69
//find_last_not_of-与find_first_not_of相似，只不过查找顺序是从指定位置向前
70
cout << str.find_last_not_of("kiajbvehfgmlc", 6) << endl;//3
71

72
string &replace(int p0, int n0,const char *s);//删除从p0开始的n0个字符，然后在p0处插入串s
73
string &replace(int p0, int n0,const char *s, int n);//删除p0开始的n0个字符，然后在p0处插入字符串s的前n个字符
74
string &replace(int p0, int n0,const string &s);//删除从p0开始的n0个字符，然后在p0处插入串s
75
string &replace(int p0, int n0,const string &s, int pos, int n);//删除p0开始的n0个字符，然后在p0处插入串s中从pos开始的n个字符
76
string &replace(int p0, int n0,int n, char c);//删除p0开始的n0个字符，然后在p0处插入n个字符c
77
string &replace(iterator first0, iterator last0,const char *s);//把[first0，last0）之间的部分替换为字符串s
78
string &replace(iterator first0, iterator last0,const char *s, int n);//把[first0，last0）之间的部分替换为s的前n个字符
79
string &replace(iterator first0, iterator last0,const string &s);//把[first0，last0）之间的部分替换为串s
80
string &replace(iterator first0, iterator last0,int n, char c);//把[first0，last0）之间的部分替换为n个字符c
81
string &replace(iterator first0, iterator last0,const_iterator first, const_iterator last);//把[first0，last0）之间的部分替换成[first，last）之间的字符串
82

83
string &insert(int p0, const char *s);
84
string &insert(int p0, const char *s, int n);
85
string &insert(int p0,const string &s);
86
string &insert(int p0,const string &s, int pos, int n);
87
//前4个函数在p0位置插入字符串s中pos开始的前n个字符
88
string &insert(int p0, int n, char c);//此函数在p0处插入n个字符c
89
iterator insert(iterator it, char c);//在it处插入字符c，返回插入后迭代器的位置
90
void insert(iterator it, const_iterator first, const_iterator last);//在it处插入[first，last）之间的字符
91
void insert(iterator it, int n, char c);//在it处插入n个字符c
92

93
iterator erase(iterator first, iterator last);//删除[first，last）之间的所有字符，返回删除后迭代器的位置
94
iterator erase(iterator it);//删除it指向的字符，返回删除后迭代器的位置
95
string &erase(int pos = 0, int n = npos);//删除pos开始的n个字符，返回修改后的字符串

1
//定义具有10个整型元素的向量（尖括号为元素类型名，它可以是任何合法的数据类型），不具有初值，其值不确定
2
vector<int>a(10);
3

4
//定义具有10个整型元素的向量，且给出的每个元素初值为1
5
vector<int>a(10,1);
6

7
//用向量b给向量a赋值，a的值完全等价于b的值
8
vector<int>a(b);
9

10
//将向量b中从0-2（共三个）的元素赋值给a，a的类型为int型
11
vector<int>a(b.begin(),b.begin+3);
12

13
 //从数组中获得初值
14
int b[7]={1,2,3,4,5,6,7};
15
vector<int> a(b,b+7）;
16

17
//二维数组初始化
18
vector<vector<int>> m(4);
19
//一定要初始化大小，不然下面m[i]就不能这样用
20
vector<int> res;
21
int k=1;
22
for(int i=0;i<4;i++){
23
    for(int j=0;j<4;j++){
24
        m[i].push_back(k++);
25
    }
26
}
27

28
//nums是已经定义好的二维数组，并且是非空的
29
vector<vector<int>> res(5, vector<int>(2, 0));
30
//定义的res的大小和nums一样，并且res所有的数均初始化为0

1
#include<vector>
2
vector<int> a,b;
3
//b为向量，将b的0-2个元素赋值给向量a
4
a.assign(b.begin(),b.begin()+3);
5
//a含有4个值为2的元素
6
a.assign(4,2);
7
//返回a的最后一个元素
8
a.back();
9
//返回a的第一个元素
10
a.front();
11
//返回a的第i元素,当且仅当a存在
12
a[i];
13
//清空a中的元素
14
a.clear();
15
//判断a是否为空，空则返回true，非空则返回false
16
a.empty();
17
//删除a向量的最后一个元素
18
a.pop_back();
19
//删除a中第一个（从第0个算起）到第二个元素，也就是说删除的元素从a.begin()+1算起（包括它）一直到a.begin()+3（不包括它）结束
20
a.erase(a.begin()+1,a.begin()+3);
21
//在a的最后一个向量后插入一个元素，其值为5
22
a.push_back(5);
23
//在a的第一个元素（从第0个算起）位置插入数值5,
24
a.insert(a.begin()+1,5);
25
//在a的第一个元素（从第0个算起）位置插入3个数，其值都为5
26
a.insert(a.begin()+1,3,5);
27
//b为数组，在a的第一个元素（从第0个元素算起）的位置插入b的第三个元素到第5个元素（不包括b+6）
28
a.insert(a.begin()+1,b+3,b+6);
29
//返回a中元素的个数
30
a.size();
31
//返回a在内存中总共可以容纳的元素个数
32
a.capacity();
33
//将a的现有元素个数调整至10个，多则删，少则补，其值随机
34
a.resize(10);
35
//将a的现有元素个数调整至10个，多则删，少则补，其值为2
36
a.resize(10,2);
37
//将a的容量扩充至100，
38
a.reserve(100); //修改a
39
//b为向量，将a中的元素和b中的元素整体交换
40
a.swap(b);
41
//b为向量，向量的比较操作还有 != >= > <= <
42
a==b;
43

44
//常见错误赋值方式
45
vector<int>a;
46
for(int i=0;i<10;++i){a[i]=i;}
47
//下标只能用来获取已经存在的元素
48

49
count(vector1.begin(),vector2.begin(),target);
50
//注意不是vector的类函数！！
51

52

53

54
a.erase(unique(a.begin(),a.end()),a.end())；
55
//容器元素相邻去重，如果要全体去重需要