1、vector
// 定义了一个空的、类型为 T 的 vector v1
std::vector<T> v1;
// 等价于 std::vector<T> v2 = v1 用 v1 初始化 v2
std::vector<T> v2(v1);
// v3 包含了 n 个值为 默认值 的重复元素
std::vector<T> v3(n);
// v4 包含了 n 个值为 val 的重复元素
std::vector<T> v4(n, val);
// 等价于 std::vector<T> v5 = {a, b, c};
std::vector<T> v5{a, b, c};
// 定义二维 vector 数组
std::vector v6(n + 1, std::vector<int>(m + 1));
// 二维
std::vector<std::vector<std::array<int, 2>>> g(n);
// 三维
std::vector g(n, std::vector<std::array<int, 2>>(n));
std::vector<int> a;
// 判断是否为空。为空,返回真;否则返回假
a.empty();
// 返回 unsigned 型数据。循环语句使用时强制转换
a.size();
// 返回当前向量所能容纳的最大元素值 (int)
a.capacity();
// 返回最大可允许的 vector 元素数量值 (int)
a.max_size();
// 重新指定容器的长度为 n
// 若容器变长,则以默认值填充新位置;若容器变短,则末尾超出容器长度的元素被删除
a.resize(size_t n);
//重新指定容器的长度为 n。
//若容器变长,则以 t 值填充新位置;若容器变短,则末尾超出容器长度的元素被删除
a.resize(size_t n, size_t t);
for (int i = 0; i < (int)a.size(); i ++) {
// 把 i 压入 (push) a 的尾部 (back)
a.push_bacK(i);
// 比 push_back 更高效(只需一次构造)
a.emplace_back(i);
}
// 将 [begin, end) 区间中的元素赋值给 a
a.assign(iterator begin, iterator end);
// 将 n 个 t 赋值给 a
a.assign(size_t n, size_t t);
// 在指定位置 p 之前插入一个新元素 t,返回表示第一个新插入元素位置的迭代器
a.insert(iterator p, size_t t);
// 在迭代器 p 指定的位置之前插入 n 个新元素 t
a.insert(iterator p, size_t n, size_t t);
// 在迭代器 p 指定的位置之前插入位于 [begin, end) 区域的所有元素
a.insert(iterator p, iterator begin, iterator end);
// 在迭代器 p 指定的位置之前,插入初始化列表所有元素
a.insert(iterator p, {a, b, c});
// 每次只能插一个,更高效
a.emplace(iterator p, size_t t);
// 删除 v 中最后一个元素
a.pop_back();
// 删除 p 指向元素
a.erase(iterator p);
// 删除 [first, last) 区域的所有元素
a.erase(iterator first, iterator last);
// 等价于 a.erase(begin(), end()),清空
a.clear();
// 返回第一个元素的引用
a.front();
// 返回最后一个元素的引用
a.back();
// 返回 p 位置元素的引用,若 p >= a.size(),将会抛出 out_of_range 异常
a.at(size_t p);
for (int i = 0; i < (int)a.size(); i ++) {
std::cout << a[i] << " \n"[i == (int)a.size() - 1];
}
for (auto it = a.begin(); it != a.end(); it ++) {
std::cout << *it << " ";
}
// vector 支持下标引用、字典序比较
2、string
// 默认初始化,生成空字符串
std::string s1;
// 以 s1 初始化 s2,等价于 std::string s2 = s1
std::string s2(s1);
// 生成字符串 "1234456789"
std::string s3("123456789");
// 生成连续 n 个 'c' 字符的字符串
std::string s4(size_t n, 'c');
// 以字符串 s1 中从下标 i 开始、长度为 n 的部分初始化 s5
std::string s5(string s1, size_t i, size_t n);
// 以字符串 s1 中从下标 i 开始到字符串结束的位置初始化 s6
std::string s6(size_t s1, size_t i);
// 以 C_string 类型 cstr 的前 char_len 个字符串初始化 s7
std::string s7(char[] cstr, size_t char_len);
// 读取整行,包含空格。使用 std::cin 输入 std::string 遇到空格会停止输入
getline(std::cin, s);
// 判断是否为空,为空返回真;否则返回假
s.empty();
// 返回字符串长度, 等价于 s.length();
s.size();
// 返回 string 对象最多包含的字符数,超出会抛出 length_error 异常
s.max_size();
// 重新分配内存之前,string 对象能包含的最大字符数
s.capacity();
// 将字符串当前大小置为 n ,并用字符 c 填充不足的部分
s.resize(size_t n, char c);
// 成员函数 compare()。 返回 (1 : >) (0 : ==) (-1 : < )
std::string s1("aBcd");
std::string s2("abcd");
std::string s3("123456");
std::string s4("123dfg");
// "aBcd" 和 "abcd" 比较,返回 -1
s1.compare(s2);
// "cd" 和 "Abcd" 比较,返回 1
s1.compare(2, 3, s2);
// "cd" 和 "cd" 比较,返回 0
s1.compare(2, 3, s2, 2, 3);
// 0 表示下标,3 表示长度,"123" 和 "123" 比较,返回 0
s3.compare(0, 3, s4, 0, 3);
// 在末尾插入一个字符,等价于 s += 'a';
s.push_back('a');
// 在指定位置 p 前插入字符 c
s.insert(iteratior p, char c);
// 等价于 s += "xu";
s.append("xu");
for (int i = 0; i < (int)s.size() ; i ++) {
std::cout << s[i] << " \n"[i == (int)s.size() - 1];
}
for (auto it = s.begin(); it != s.end() ; it ++) {
std::cout << *it << " ";
}
//删除 p 所指的字符
s.erase(iterator p);
//删除 [first, last) 区间内所有字符
s.erase(iterator first, iterator last);
//删除从指定位置 p 开始的 n 个字符
s.erase(size_t p, size_t n);
// 等价于 s.erase(s.begin(), s.end()),清空
s.clear();
// 将从指定位置 p 开始的 n 个字符替换成字符串 ss
s.replace(size_t p, size_t n, const char *ss);
// 将从指定位置 p 开始的 n 个字符替换成 m 个字符 c
s.replace(size_t p, size_t n, size_t m, char c);
// 将 [begin, end) 区间内的字符替换为字符串 ss
s.replace(iterator begin, iterator end, const char* ss);
// 将字符串 ss 赋给 s (s 之前的字符被清空)
s.assign(const string &ss);
s.assign(const char *ss);
// 将 ss 的前 n 个字符赋给 s
s.assign(const char *ss, int n);
// 将 n 个字符 c 赋给 s
s.assign(size_t n, char c);
// 将 ss 中从 p 开始的 n 个字符赋给 s
s.assign(const string &ss, int p, int n);
// 使用迭代器赋值
s.assign(iterator begin, itertor end);
// 将 string 转换为 char[], 返回字符串所在字符数组的起始地址
s.c_str();
// c 语言的大小写转换函数,一次只能转换单个字符
for (int i = 0; i < (int)s.size(); i ++) {
// 小写转大写
s[i] = toupper(s[i]);
// 大写转小写
s[i] = tolower(s[i]);
}
// transform 算法配合 toupper 和 tolower 实现
transform(s.begin(), s.end(), s.begin(), ::toupper);
transform(s.begin(), s.end(), s.begin(), ::tolower);
// 返回 p 位置字符的引用
s.at(size_t p);
// 查找字符串,返回找到的位置索引,返回 std::string::npos (-1) 表示查找失败
s.find("xu");
// 从字符串的末尾开始查找字符串
s.rfind("jin");
// 从指定位置 p 开始,查找子串 ss
s.find (constchar* ss, size_t p);
// 从指定位置 p 开始,查找字符 c
s.find (char c, size_t p);
// 从指定位置 p 开始,反向查找子串 ss
s.rfind (constchar* ss, size_t p);
// 从指定位置 p 开始,反向查找字符 c
s.rfind (char c, size_t p) const;
// 从指定位置 p 开始,查找第一个属于字符串 ss 的字符
s.find_first_of (const char* ss, size_t p);
// 从指定位置 p 开始,查找第一个不位于子串 ss 的字符
s.find_first_not_of (const char* ss, size_t p);
// 从指定位置 p 开始,查找最后一个位于子串 ss 的字符
s.find_last_of(const char* ss, size_t p);
// 从指定位置 p 开始,查找最后一个不位于子串 ss 的字符
s.find_last_not_of (const char* ss, size_t p);
// 返回从索引位置 i 开始的 n 个字符子串
s.substr(size_t i, size_t n);
// c 库函数 strtok()
void demo() {
char str[] = "This is - a - demo";
const char s[2] = "-";
// 获取第一个子字符串
char *ch = strtok(str, s);
// 继续获取其他的子字符串
while (ch != NULL) {
std::cout << ch << "\n";
ch = strtok(NULL, s);
}
// 原字符串的改动是切分符原位置均更改为 '\0' ,所以内容都还在
for (int i = 0; i < (int)str.size(); i ++) {
std::cout << str[i];
}
}
// 输出
// This is
// a
// demo
// This is a demo
3、map && set
// set && multiset
insert() 插入一个数
find() 查找一个数
count() 返回某一个数的个数
erase()
(1) 输入是一个数x,删除所有x O(k + logn)
(2) 输入一个迭代器,删除这个迭代器
lower_bound()/upper_bound()
lower_bound(x) 返回大于等于 x 的最小的数的迭代器
upper_bound(x) 返回大于 x 的最小的数的迭代器
// map && multimap
insert() 插入的数是一个 pair
erase() 输入的参数是 pair 或者迭代器
find()
[] 时间复杂度是 O(logn)
lower_bound()/upper_bound()
// unordered_set/unordered_multiset
和上面类似,增删改查的时间复杂度是 O(1)
不支持 lower_bound()/upper_bound(), 迭代器的++,--
// unordered_map && unordered_multimap
和上面类似,增删改查的时间复杂度是 O(1)
不支持 lower_bound()/upper_bound(), 迭代器的++,--
4、array && queue && pair && deque && stack
// std::array 是具有固定大小的数组, 它不支持添加或删除元素等改变大小的操作
// 当定义一个 array 时,除了指定元素类型,还要指定容器大小
// 指定容器大小时,只能使用常量 (constexpr),不能使用变量
// 定义空的数组
std::array<int, 2> a1;
// 用 a1 初始化 a2
std::array<int, 2> a2 = a1;
// 序列初始化
std::array<int, 2> a3 = {0, 1, 2, 3, 4};
// 初始化一个空的 queue 对象
std::queue<T> q;
// 用 q 初始化 p
std::queue<T> p(q);
// 序列初始化
std::queue<int> q({size_t a, size_t b, size_t c});
// 在队尾添加元素 t
q.push(size_t t);
q.emplace(size_t t);
// 从队头移除第一个元素,无返回值
q.pop();
// 返回第一个元素的引用
q.front();
// 返回最后一个元素的引用
q.back();
// 判断是否为空
q.empty();
//返回队列的大小
q.size();
// 优先队列,默认是大根堆(最大元素被移至队首)
std::priority_queue<int> q;
// 定义成小根堆(最小元素被移至队首)
std::priority_queue<int, std::vector<int>, std::greater<int>> q;
// 判空
q.empty();
// 插入一个元素
q.push();
// 返回队顶元素的引用
q.top();
// 弹出队顶元素
q.pop();
// 创建一个空的 pair 对象(使用默认构造),它的两个元素分别是 T1 和 T2 类型
std::pair<T1, T2> p1;
// first 成员初始化为 v1,second 成员初始化为 v2。
std::pair<T1, T2> p1(v1, v2);
// 以 v1 和 v2 的值创建一个新的 pair 对象,其元素类型分别是 v1 和 v2 的类型。
std::make_pair(v1, v2);
// 返回对象 p 中名为 first 的公有数据成员
p.first;
// 返回对象 p1 中名为 first 的公有数据成员
p.second;
// 双端队列,实现类似 vector,支持随机访问
// 访问首元素的插入 push_front() 与删除 pop_front() 的速度要比 vector 快
// 当有大量的操作发生在序列的起始位置与结尾处,可以考虑用 deque
// 定义一个空的 deque
std::deque<T> dq;
// 用 dq 初始化 d
std::deque<T> d(dq);
// 用 n 个 t 初始化 deque
std::deque<T> d(size_t n, size_t t) dq;
// 判空
dq.empty();
// 返回长度
dq.size();
// 重新指定容器内元素的个数为 n
dq.resize(szie_t t);
// 将内存减少到等于当前元素实际所使用的大小
dq.shrink_to_fit();
// 在队头插入 t
dq.push_front(size_t t);
dq.emplace_front(size_t t);
// 在队尾插入 t
dq.push_back(size_t t);
dq.emplace_back(size_t t);
// 删除队头
dq.pop_front();
// 删除队尾
dq.pop_back();
// 使用经过边界检查的索引访问元素。
dq.at(size_t t);
// 返回第一个元素的引用
dq.front();
// 返回最后一个元素的引用
dq.back();
// 清空
dq.clear();
// 用新元素替换原有内容。
dq.assign();
// 在指定的位置插入一个或多个元素
dq.insert();
// 在指定的位置直接生成一个元素
dq.emplace();
// 移除一个元素或一段元素。
dq.erase();
// 初始化一个空的 stack 对象
std::stack<T> stk;
// 用 stk 初始化 sta
std::stack<T> sta(stk);
// 序列初始化
std::stack<T> sta({size_t a, size_t b, size_t c});
// 在栈顶添加元素 t
stk.push(size_t t);
stk.emplace(size_t t);
// 从栈顶移除第一个元素,无返回值
stk.pop();
// 判空
stk.empty();
//返回栈的大小
stk.size();
// 返回栈顶元素的引用
stk.top();
5、bitset
// 初始化空的 bitset
std::bitset<10000> s;
~, &, |, ^
>>, <<
==, !=
[]
count() 返回有多少个1
any() 判断是否至少有一个 1
none() 判断是否全为 0
set() 把所有位置成 1
set(k, v) 将第 k 位变成 v
reset() 把所有位变成 0
flip() 等价于 ~
flip(k) 把第 k 位取反
6、tuple