文章目录
  1. vector容器
  2. 迭代器
  3. list容器
  4. string
  5. deque容器

vector容器

vector类是C++为内置数组引入的一种替代表示，建议使用。要使用vector类，需包含头文件vector。通过动态数组实现。定义于<vector>

构造

1
2
3
4
5
6
7
8
9
10
11
12
13
/* 默认初始化：定义一个空的vector容器 */
vector<int> ivec;

/* 赋值构造 */
vector<int> ivec={3, 6,9, 2, 5, 7};
/* 构造包含为7个值为3的元素的vector容器，若3未指定，则默认为0 */
vector<int> ivec(7, 3);

/* 拷贝复制 */
vector<int> ivec(ivec_0);

/* 通过数组arr[0:3]（左闭右开）构造 */
vector<int> ivec(arr, arr+3);

插入

1
2
/* 从vector容器尾部添加一个值为num的元素 */
ivec.push_back(num);

注：虽然使用insert泛型算法可以在容器的任意位置插入元素，但是不建议这么做，因为vector是通过动态数组实现，在其他位置插入元素会有很大的开销，如果需要在任意位置插入，建议选择其他的容器类型。

删除

1
2
/* 删除vector容器尾部的元素*/
ivec.pop_back();

迭代器

除了使用下标访问vector的元素，还可以使用迭代器进行访问。以vector为例，其他容器同理。

1
2
vector<int>::iterator it;
for(it=ivec.begin(); it != ivec.end(); ++it)

其中，支持迭代器的容器类型有：vector、list、string、deque、set、map；不支持的有：stack、queue、priority_queue。

对于支持迭代器的顺序容器，其具有访问第一个与最后一个元素的捷径：front方法与back方法；除此之外，queue也具有。

list容器

list容器是对C语言中链表的替代表示，内存区域非连续，通过双向链表实现。定义于<list>

构造

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/* 默认初始化：定义一个空的list容器 */
list<int> ilist;

/* 赋值构造 */
list<int> ilist={3, 6,9, 2, 5, 7};

/* 构造包含为7个值为3的元素的list容器，若3未指定，则默认为0 */
list<int> ilist(7, 3);

/* 拷贝复制 */
list<int> ilist(ilist_0);

/* 通过数组arr[0:3]（左闭右开）构造 */
list<int> ilist(arr, arr+3);
/* 通过其他类型的容器的一部分（左闭右开）构造 */
list<int> ilist(ivec.begin(), ivec.begin()+3);

插入

1
2
3
4
5
6
7
8
/* 从list容器头部添加一个值为num的元素 */
ilist.push_front(num);

/* 从list容器尾部添加一个值为num的元素 */
ilist.push_back(num);

/* list_it为迭代器，在list_it所在位置插入num */
ilist.insert(list_it, num);

删除

1
2
3
4
5
6
7
8
9
10
/* 从list容器头部删除一个元素 */
ilist.pop_front();

/* 从list容器尾部删除一个元素 */
ilist.pop_back();

/* list_it为迭代器，删除list_it所在位置的元素 */
ilist.erase(list_it);
/* 删除list_it_low与list_it_high之间的元素（不包含* list_it_high）*/
ilist.erase(list_it_low, list_it_high);

string

C++标准库提供了字符串类抽象的一个公共实现——string。定义于<string>

构造

1
2
3
4
5
6
7
8
9
10
11
12
13
/* 默认初始化：定义一个空的list容器 */
string str;

/* 构造包含为7个'a'的元素的string*/
string str(7, 'a');

/* 拷贝复制 */
string str(str_0);
string str("hello");

/* 通过C风格字符串构造 */
string str(const char * str_c);
string str="hello";

插入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/* 在字符串str后添加一个字符ch */
str.push_back(ch);

/* 在str的pos处插入字符串str_str */
str.insert(pos, string str_str);
str.insert(pos, const char * str_str);

/* 在str的pos处插入字符子串str_str[subpos: (subpos+sublen)]（左闭右开）*/
str.insert(pos, string str_str, subpos, sublen);

/* 在str的pos处插入字符串str_str的前n个字符 */
str.insert(pos, const char * str_str, n);

/* 在str的pos处插入n个字符ch */
str.insert(pos, n, ch);

/* 在迭代器it所在位置插入字符ch，并返回插入后迭代器的位置 */
str.insert(it, ch);

/* 在迭代器it所在位置插入n个字符ch，并返回插入后迭代器的位置 */
str.insert(it, n, ch);

删除

1
2
3
4
5
6
7
8
/* 删除从pos（默认为0）处开始的len个字符 */
str.erase(pos, len);

/* 删除it所在位置的字符，并返回删除后迭代器的位置 */
str.erase(it);

/* 删除从it_low到it_high（不包含* it_high）的字符 */
str.erase(it_low, it_high);

拼接

1
2
str.append("hello");
str.append(str_str);

比较

1
2
3
4
5
6
7
8
9
10
11
12
str.compare(string str_str);
str.compare(const char * str_str);

/* 将str[pos（默认为0）: (pos+len)]（左闭右开）与str_str比较 */
str.compare(pos, len, string str_str);
str.compare(pos, len, const char * str_str);

/* 将str[pos（默认为0）: (pos+len)]（左闭右开）与str_str[subpos: (subpos+sublen)]（左闭右开）比较 */
str.compare(pos, len, string str_str, subpos, sublen);

/* 将str[pos（默认为0）: (pos+len)]（左闭右开）与str_str的前n个字符组成的字符串比较 */
str.compare(pos, len, const char * str_str, n);

子串

1
str.substr(pos, len);

查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
/* 从pos（默认为0）开始查找字符串str_str
 * 若未找到字符串str_str则返回str.npos（表示在str中不存在的位置）
 */
str.find(const string str_str, pos);
str.find(const char * str_str, pos);

/* 从pos（默认为0）开始查找字符ch
 * 若未找到字符ch则返回str.npos（表示在str中不存在的位置）
 */
str.find(ch, pos);

/* 从pos（默认为str.size()-1）开始向前查找字符串str_str
 * 若未找到字符串str_str则返回str.npos（表示在str中不存在的位置）
 */
str.rfind(const string str_str, pos);
str.rfind(const char * str_str, pos);

/* 从pos（默认为str.size()-1）开始向前查找字符ch
 * 若未找到字符ch则返回str.npos（表示在str中不存在的位置）
 */
str.rfind(ch, pos);

/* 查找字符串str_str中任一字符第一次出现的位置
 * 若未找到则返回str.npos（表示在str中不存在的位置）
 */
str.find_first_of(const string str_str);
str.find_first_of(const char * str_str);

/* 查找字符串str_str中任一字符最后一次出现的位置
 * 若未找到则返回str.npos（表示在str中不存在的位置）
 */
str.find_last_of(const string str_str);
str.find_last_of(const char * str_str);

/* 查找第一个str_str未包含的字符
 * 若未找到则返回str.npos（表示在str中不存在的位置）
 */
str.find_first_not_of(const string str_str);
str.find_first_not_of(const char * str_str);

/* 查找最后一个str_str未包含的字符
 * 若未找到则返回str.npos（表示在str中不存在的位置）
 */
str.find_last_not_of(const string str_str);
str.find_last_not_of(const char * str_str);

获取输入

1
getline(cin, str);

deque容器

deque容器为双向队列的抽象表示。通过双端数组实现，内存区域连续。定义于<deque>

构造

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/* 默认初始化：定义一个空的deque容器 */
deque<int> ideque;

/* 构造包含为7个值为3的元素的deque容器，若3未指定，则默认为0 */
deque<int> ideque(7, 3);

/* 赋值构造 */
deque<int> ideque={3, 6,9, 2, 5, 7};

/* 拷贝复制 */
deque<int> ideque(ideque_0);

/* 通过其他类型的容器的一部分（左闭右开）构造 */
deque<int> ideque(list_it_low, list_it_high);

插入

1
2
3
4
5
/* 从deque容器头部添加一个值为num的元素 */
ideque.push_front(num);

/* 从deque容器尾部添加一个值为num的元素 */
ideque.push_back(num);

删除

1
2
3
4
5
/* 从deque容器头部删除一个元素 */
ideque.pop_front();

/* 从deque容器尾部删除一个元素 */
ideque.pop_back();