string

• C++中的string是表示字符串的类，它提供了许多操作字符串的函数和方法。
• 要使用string，需要包含头文件<string>

string 定义和初始化

#include <string>               // 需要调用头文件
string str;                     // 声明一个空的字符串
string str = "Hello, world!";   // 声明并初始化一个字符串
string str(5, 'X');             // 声明一个由5个字符'X'组成的字符串

string 读入

getline(cin, s);    // 一行
cin >> s;           // 遇见空格/回车结束
scanf("%s", s);     // 遇见空格/回车结束

string 长度

s.size();       // 字符串长度
s.length();     // 字符串长度

string 拼接

string str1 = "Hello";
string str2 = "world!";
string result = str1 + ", " + str2;   // 字符串连接

string 插入元素

s.insert(pos, t);   // 在第 pos 个下标后插入 t 字符串
s.append(t, pos, len);  // 添加从 t 的第 pos 个下标开始 len 个字符

string 删除元素

s.erase(pos, len);  // 从第 pos 个下标位置开始删除 len 个字符 
s.erase(pos);       // 删除 pos 下标开始往后的字符
s.erase();          // 删除所有字符

string 查找元素

s.find(t);  // 正序查找，返回查找到的元首下标，没有查找到返回 -1
s.rfind(t); // 逆序查找

string 替换元素

s.replace(pos, len, t);     // 从第 pos 个位置开始往后 len 个字符 替换 t 

string 元素类型转换

• 转换为整数类型：

• 使用std::stoi函数将string转换为int类型。

• 使用std::stol函数将string转换为long类型。

• 使用std::stoll函数将string转换为long long类型。

string myString = "12345";
int myInt = stoi(myString);
long myLong = stol(myString);
long long myLongLong = stoll(myString);

• 转换为浮点数类型：

• 使用std::stof函数将string转换为float类型。

• 使用std::stod函数将string转换为double类型。

• 使用std::stold函数将string转换为long double类型。

string myString = "3.14";
float myFloat = stof(myString);
double myDouble = stod(myString);
long double myLongDouble = stold(myString);

• 转换为布尔类型：
• 使用自定义函数或逻辑判断来将string转换为bool类型。

string myString = "true";
bool myBool = (myString == "true");

& 需要注意的是，如果转换过程中出现无效的字符串或转换不完全，这些函数将引发std::invalid_argument或std::out_of_range异常。因此，在进行类型转换时，应该处理异常或确保字符串的有效性。

string 翻转

reverse(s.begin() + c1, s.end() - c2);  // 通过 begin, end 指针操控翻转区间 (c1, c2 >= 0)

string 截取

s.substr(pos, len); // 从第 pos 下标开始截取 len 个长度的字符
s.substr(pos);      // 从第 pos 下标开始截取后面的所有字符

string 比较

/*  
    比较 s1 与 s2 的大小 ASSIC 码顺序比较;
    比较两个字符串，返回0表示相等，
    负值表示 str1 小于 str2，
    正值表示 str1 大于 str2
*/
s1.compare(s2); 

string 匹配

s1 == s2    // 直接判断

char 判断

isdigit(c); // 是否是数字
isupper(c); // 是否是大写
islower(c); // 是否是小写
isalpha(c); // 是否是字母，大写返回 1， 小写返回 2，否则返回 0

vector

• C++中的vector是一个动态数组容器，可以存储不同类型的元素。它提供了快速随机访问的能力，可以根据需要自动调整大小。

• 要使用vector，需要包含头文件<vector>

vector 定义和初始化

#include <vector>   // 需要调用库函数
/*  
    T 表示类型，如（int, double, vector<?>）类型，不可省略
    len 表示初始定义的长度， 可以省略
    value 表示对vector数组进行初始化值，可以省略，省略默认为 (0，'\0',NULL) 
*/
vector<T> vec(len, value);  
vector<int> a{1, 2, 3}; // 定义一个长度为 3， 值分别为 {1, 2, 3} 的数组

/*
    对 vec 的长度进行初始化，
    len 表示重新给定 vec 的长度空间， 
    value 表示将总空间里的 空 / NULL 值进行赋默认值 
*/
vec.resize(len, value); 

vector 插入

vec.insert(vec.begin() + pos, value); // 在 vec 的 第 pos 个下标插入 value
vec.push_back(value); // 在 vec 的末端插入 value

vector 删除

vec.erase(vec.begin() + pos) // 删除第 pos 下标位置的元素
vec.erase(vec.begin() + left, vec.begin() + right); // 删除 在区间 ( left, right ) 的元素, left <= right
vec.erase(vec.begin() + left, vec.end() - right);   // 删除 在区间 ( left, vec.size() - right ] 的元素
vec.pop_back();     // 删除最后一个元素

vector 查找

#include <algorithm> // 包含 find_if 函数的头文件 
auto it =  find(vec.begin(), vec.end(), target);    // it 是迭代器并非下标，target 是要查找的元素
if(it != vec.end()) cout << 查找到元素 << *it;
else cout << 未查到元素;

vector 交换

swap(vec[a], vec[b]);   // 下标 a， 下标 b 的元素交换
vecA.swap(vecB);        // vecA 和 vecB 交换

vector 填充

vec.assign(otherVector);    // 将 otherVector 复制给 vec
vec.assign({...})           // 将 vec 清空再填充 {...} 里的数据

vector 访问元素

int firstElement = vec.front();            // 访问第一个元素
int lastElement = vec.back();              // 访问最后一个元素
int thirdElement = vec[pos];               // 访问指定位置的元素

vector 迭代遍历

vector<int> vec = {1, 2, 3, 4, 5};

for (auto it = vec.begin(); it != vec.end(); ++it) {
    cout << *it << " ";                         // 输出每个元素的值
}
cout << endl;

for (int element : vec) {
    cout << element << " ";                     // 使用范围 for 循环输出每个元素的值
}
cout << endl;

vector 长度

vec.size();     // vec 容量长度大小   

vector 空

vec.empty();    // 用于检查列表是否为空。如果列表为空，返回 true；否则返回 false。

deque

• C++中的deque（双端队列）是一种容器，类似于vector，但允许在两端高效地进行插入和删除操作。deque可以存储不同类型的元素，并提供随机访问的能力。

• 要使用deque，需要包含头文件<deque>。

deque 定义和初始化

#include <deque>
deque<T> myDeque;                              // T 表示类型，如：int, double，不可省略
deque<int> myDeque = {1, 2, 3, 4, 5};          // 声明并初始化一个 int 类型的 deque
deque<string> myStringDeque(num, value);       // 声明一个包含 num 个字符串 value 的 deque

deque 插入元素

myDeque.push_back(value);                      // 在尾部插入元素 value
myDeque.push_front(value);                     // 在头部插入元素 value
myDeque.insert(vec.begin() + pos, value);      // 在 myDeque 的第 pos 个位置插入 value

deque 删除元素

myDeque.pop_back();                            // 删除尾部元素
myDeque.pop_front();                           // 删除头部元素
myDeque.erase(vec.begin() + pos);              // 删除第 pos 个位置的元素

deque 访问元素

int firstElement = myDeque.front();            // 访问第一个元素
int lastElement = myDeque.back();              // 访问最后一个元素

auto it = myDeque.begin() + pos;               // 获取指向第 pos 个元素的迭代器
int thirdElement = *it;                        // 访问指定位置的元素

deque 迭代遍历

deque<int> myDeque = {1, 2, 3, 4, 5};

for (auto it = myDeque.begin(); it != myDeque.end(); ++it) {
    cout << *it << " ";                         // 输出每个元素的值
}
cout << endl;

for (int element : myDeque) {
    cout << element << " ";                     // 使用范围for循环输出每个元素的值
}
cout << endl;

请注意，deque 具有与 list 类似的功能，但它内部使用了不同的数据结构。deque 和 list 在不同的场景下有不同的性能表现，请根据自己的需求选择适当的容器类型。

list

• C++中的list是一个双向链表容器，可以存储不同类型的元素。它与vector和deque相比具有一些独特的特点，例如插入和删除操作的效率更高，但对于随机访问的性能较差。
• 要使用list，需要包含头文件<list>

list 定义和初始化

#include <list>
list<T> myList;                            // T 表示类型，如（int, double...）类型，不可省略
list<int> myList = {1, 2, 3, 4, 5};        // 声明并初始化一个 int 类型 list
list<string> myStringList(num, value);     // 声明一个包含 num 个字符串 value 的 list

list 插入元素

myList.push_back(value);                      // 在末尾插入元素 value
myList.push_front(value);                     // 在开头插入元素 value

auto it = myList.begin();                     // myList 的第一个位置的迭代器
advance(it, pos);                             // 往后移 pos 个位置
myList.insert(it, value);                     // 在 myList 的第 pos 个下标插入 value

list 删除元素

myList.pop_back();                        // 删除末尾的元素
myList.pop_front();                       // 删除开头的元素

auto it = myList.begin();                 // myList 的第一个位置的迭代器
advance(it, pos);                         // 往后移 pos 个位置
myList.erase(it);                         // 删除第 pos 下标位置的元素

list 访问元素

int firstElement = myList.front();        // 访问第一个元素
int lastElement = myList.back();          // 访问最后一个元素

iterator it = myList.begin();             // 获取迭代器指向第一个元素的位置
advance(it, pos);                         // 将迭代器向后移动 pos 个位置
int thirdElement = *it;                   // 访问指定位置的元素

list 迭代遍历

list<int> myList = {1, 2, 3, 4, 5};

for (auto it = myList.begin(); it != myList.end(); ++it) {
    cout << *it << " ";                    // 输出每个元素的值
}
cout << endl;

for (int element : myList) {
    cout << element << " ";                // 使用范围for循环输出每个元素的值
}
cout << endl;

queue

• deque（双端队列）与queue（队列）是不同的概念。deque是一种容器，可以在两端进行高效的插入和删除操作，而queue是一种特殊的容器适配器，它基于其他容器（例如deque、list或vector）实现了先进先出（FIFO）的数据结构。

• 在使用C++中的queue时，需要包含头文件<queue>。

queue 定义和初始化

#include <queue>

queue<T> myQueue;                   // T 表示类型，如：int, double，不可省略
queue<int> myQueue;                 // 声明一个 int 类型的 queue

queue 元素操作

/* 
    使用`push`函数将元素添加到队列的尾部，
    使用`pop`函数移除队列头部的元素。
    要访问当前队列的头部元素和尾部元素，分别使用 front 和 back 函数。 
*/
myQueue.push(value);                // 将元素 value 添加到队列尾部
myQueue.pop();                      // 移除队列头部的元素

T frontElement = myQueue.front();    // 返回队列头部的元素
T backElement = myQueue.back();      // 返回队列尾部的元素

queue 容量操作

/*
    使用`empty`函数可以检查队列是否为空，如果队列为空则返回`true`，否则返回`false`。
    使用`size`函数可以返回队列中元素的数量。
*/
bool isEmpty = myQueue.empty();      // 检查队列是否为空
int queueSize = myQueue.size();      // 返回队列中元素的数量

queue是一个适用于实现先进先出（FIFO）数据结构的容器适配器，它封装了底层容器的方法，提供了一种更方便和易于理解的方式来实现队列操作。但需要注意的是，queue并不提供迭代器，因此无法使用迭代器来遍历或访问队列中的元素。

pair

• pair 是 C++ 标准库中的类模板，用于表示一个有序的键值对。它通过将两个值组合在一起，形成一个元素。

pair 定义和初始化

/*
要使用 pair，首先需要包含头文件 `<utility>`。
然后使用 `pair<T1, T2>` 声明一个 pair 对象，其中 T1 表示第一个值的类型，T2 表示第二个值的类型。
可以使用花括号或 make_pair 函数进行初始化。
*/
#include <utility>

pair<T1, T2> myPair;                        // T1 表示第一个值的类型，T2 表示第二个值的类型，如：<int, string>，不可省略
pair<int, string> myPair;                   // 声明一个 int 类型的第一个值和 string 类型的第二个值的 pair

myPair = {value1, value2};                  // 使用花括号初始化 pair
myPair = make_pair(value1, value2);         // 使用 make_pair 函数初始化 pair

pair 访问和修改

/*
可以使用 `first` 和 `second` 成员来访问 pair 中的第一个和第二个值。
也可以通过赋值将新的值赋给 pair。
*/
myPair.first;                               // 访问 pair 的第一个值
myPair.second;                              // 访问 pair 的第二个值

myPair.first = newValue1;                   // 修改 pair 的第一个值
myPair.second = newValue2;                  // 修改 pair 的第二个值

​

map

• map（映射）是C++标准库中的关联容器之一，它提供了键-值对的存储和访问功能。
• 内部使用红黑树实现，可以保持键的有序性。
• 插入、查找、删除操作的平均时间复杂度为O(logN)，其中N是元素数量。
• 元素按照键的升序进行遍历。
• 使用比较函数或运算符来确定元素的顺序。
• 需要额外的空间来维护红黑树的结构。
• 适用于需要有序访问和元素顺序要求的场景。

map 定义

/*
要使用map，首先需要包含头文件`<map>`。
然后使用`map<K, V>`声明一个map对象，其中K表示键的类型，V表示值的类型。
*/
#include <map>

map<K, V> myMap;               // K 表示键的类型，V 表示值的类型，如：<int, string>，不可省略
map<int, string> myMap;        // 声明一个 int 类型的键和 string 类型的值的 map

map 插入键值对

/*
使用`[]`操作符将键值对插入到map中，或使用`insert`函数插入键值对。
*/
myMap[key] = value;                   // 插入键值对
myMap.insert(make_pair(key, value));  // 使用 insert 函数插入键值对，也可以使用 pair 构造函数 make_pair

map 查找键

/*
使用`find`函数可以查找指定键在map中对应的迭代器。
如果找到了键，则返回指向对应键值对的迭代器；如果未找到，则返回`myMap.end()`。
*/
myMap.find(key);  // 返回指向键值对的迭代器，如果找不到则返回 myMap.end()

map 删除键值对

/*
使用`erase`函数可以删除map中指定键对应的键值对。通过指定键作为参数，将对应的键值对从map中删除。
使用`clear`函数可以删除map中的所有键值对，清空map。
*/
myMap.erase(key);  // 删除指定键对应的键值对
myMap.clear();     // 清空map，删除所有键值对

map 容量和个数

/*
使用`empty`函数可以检查map是否为空，当map中没有键值对时返回`true`，否则返回`false`。
使用`size`函数可以返回map中键值对的数量。
*/
bool isEmpty = myMap.empty();  // 检查map是否为空，如果为空则返回 true，否则返回 false
int mapSize = myMap.size();    // 返回map中键值对的数量

map 迭代遍历

/*
可以使用迭代器来遍历map中的所有键值对，或使用范围循环。
*/
// 使用迭代器进行遍历
for (auto it = myMap.begin(); it != myMap.end(); ++it) {
    cout << "Key: " << it->first << ", Value: " << it->second << endl;
}

// 使用范围循环进行遍历（C++11及以上版本）
for (const auto& pair : myMap) {
    cout << "Key: " << pair.first << ", Value: " << pair.second << endl;
}

unordered_map

• unordered_map是C++标准库中的关联容器之一，它提供了键-值对的存储和访问功能。
• 内部使用哈希表实现，可以以近似常量时间复杂度O(1)进行插入、查找和删除操作。
• 元素的存储顺序是无序的。
• 使用哈希函数确定元素的位置，在处理哈希冲突时会使用开放定址法。
• 需要额外的内存来存储哈希表。
• 适用于对元素顺序没有严格要求，或需要快速插入、查找和删除操作的场景。

unordered_map 定义

/*
要使用unordered_map，首先需要包含头文件`<unordered_map>`。
然后使用`unordered_map<K, V>`声明一个unordered_map对象，其中K表示键的类型，V表示值的类型。
*/
#include <unordered_map>

unordered_map<K, V> myUnorderedMap;      // K 表示键的类型，V 表示值的类型，如：<int, string>，不可省略
unordered_map<int, string> myUnorderedMap;   // 声明一个 int 类型的键和 string 类型的值的 unordered_map

unordered_map 插入键值对

/*
使用`[]`操作符将键值对插入到unordered_map中，或使用`insert`函数插入键值对。
*/
myUnorderedMap[key] = value;                   // 插入键值对
myUnorderedMap.insert(make_pair(key, value));  // 使用 insert 函数插入键值对，也可以使用 pair 构造函数 make_pair

unordered_map 查找键

/*
使用`find`函数可以查找指定键在unordered_map中对应的迭代器。
如果找到了键，则返回指向对应键值对的迭代器；如果未找到，则返回`myUnorderedMap.end()`。
*/
myUnorderedMap.find(key);  // 返回指向键值对的迭代器，如果找不到则返回 myUnorderedMap.end()

unordered_map 删除键值对

/*
使用`erase`函数可以删除unordered_map中指定键对应的键值对。通过指定键作为参数，将对应的键值对从unordered_map中删除。
使用`clear`函数可以删除unordered_map中的所有键值对，清空unordered_map。
*/
myUnorderedMap.erase(key);  // 删除指定键对应的键值对
myUnorderedMap.clear();     // 清空unordered_map，删除所有键值对

unordered_map 容量和个数

/*
使用`empty`函数可以检查unordered_map是否为空，当unordered_map中没有键值对时返回`true`，否则返回`false`。
使用`size`函数可以返回unordered_map中键值对的数量。
*/
bool isEmpty = myUnorderedMap.empty();  // 检查unordered_map是否为空，如果为空则返回 true，否则返回 false
int unorderedMapSize = myUnorderedMap.size();    // 返回unordered_map中键值对的数量

unordered_map 迭代遍历

/*
可以使用迭代器来遍历unordered_map中的所有键值对，或使用范围循环。
*/
// 使用迭代器进行遍历
for (auto it = myUnorderedMap.begin(); it != myUnorderedMap.end(); ++it) {
    cout << "Key: " << it->first << ", Value: " << it->second << endl;
}

// 使用范围循环进行遍历（C++11及以上版本）
for (const auto& pair : myUnorderedMap) {
    cout << "Key: " << pair.first << ", Value: " << pair.second << endl;
}

set

• set是C++标准库中的一个容器，它是一个集合（Set）类型的容器。
• set存储一组唯一且已排序的元素，不允许重复。
• 使用set可以实现快速的查找、插入和删除操作。

set 定义和初始化

#include <set>      // 要使用`set`，首先需要包含`<set>`头文件，并使用`std`命名空间。

set<int> mySet;                                  // 空的int类型set
set<int> mySet = {1, 2, 3, 4, 5};                // 初始化带有元素的set
set<string> mySet = {"apple", "banana"};    // 初始化带有元素的set，存储字符串

set 插入元素

// 可以使用`insert`函数向`set`中插入元素，插入元素的时间复杂度为O(log n)。
mySet.insert(1);                    // 插入单个元素
mySet.insert({2, 3, 4});            // 插入多个元素

set 删除元素

// 可以使用`erase`函数删除指定的元素或者范围内的元素。
mySet.erase(value);                     // 删除值为 value 的元素
mySet.erase(mySet.begin());             // 删除集合中的第一个元素
mySet.erase(mySet.begin(), mySet.end());  // 删除整个集合中的所有元素

set 查找元素

// 可以使用`find`函数查找指定的元素，如果找到则返回该元素的迭代器，否则返回`end()`迭代器。

auto it = mySet.find(value);            // 查找值为 value 的元素
if (it != mySet.end()) {
    cout << "Found: " << *it << endl;
} else {
    cout << "Not found" << endl;
}

set 迭代遍历

// 可以使用迭代器进行`set`的遍历，遍历的顺序是按照元素的大小从小到大进行遍历。
for (auto it = mySet.begin(); it != mySet.end(); ++it) {
    cout << *it << " ";                    // 输出每个元素的值
}
cout << endl;

for (int element : mySet) {
    cout << element << " ";                // 使用范围for循环输出每个元素的值
}
cout << endl;

set 集合大小

// 可以使用`size`函数获取`set`中元素的个数。
mySet.size();    // 输出集合的大小

set 判断元素是否存在

// 可以使用`count`函数或`find`函数来判断某个元素在`set`中是否存在。
mySet.count(value);     // 大于 0 表示存在， 否则不存在
mySet.find(value);      // 找到则返回该元素的迭代器，否则返回`end()`迭代器

algorithm

sort()

std::sort() 是 C++ 标准库算法的一部分，用于对容器中的元素进行排序。它可以按升序或降序排列元素。

#include <algorithm>

std::sort(container.begin(), container.end());

其中，container 是你要排序的容器（如 vector、array 等），begin() 和 end() 分别表示容器的起始和结束位置迭代器。通过调用 std::sort() 函数，你可以将容器中的元素按照默认的升序进行排序。

如果你想按照自定义的排序规则进行排序，可以使用自定义比较函数或者 lambda 表达式。例如，按照降序对容器进行排序：

#include <algorithm>

std::sort(container.begin(), container.end(), [](const auto& a, const auto& b) {
    return a > b;
});

在这个示例中，我们使用了一个 lambda 表达式作为比较函数，比较元素 a 和 b 的大小。返回 true 表示 a 应该排在 b 前面，从而实现了降序排序。

find()

std::find() 函数用于在容器中查找指定的元素。如果找到了该元素，它将返回指向该元素的迭代器；如果未找到，则返回容器的 end() 迭代器。

#include <algorithm>

auto it = std::find(container.begin(), container.end(), value);

if (it != container.end()) {
    // 找到了指定元素
} else {
    // 未找到指定元素
}

在这个示例中，container 是你要查找的容器，value 是要查找的特定值。通过调用 std::find() 函数，我们可以在容器中查找指定的元素，并根据返回的迭代器进行进一步处理。

binary_search()

std::binary_search() 函数用于在已排序的容器中进行二分查找。它返回一个布尔值，表示指定的元素是否在容器中。

#include <algorithm>

bool found = std::binary_search(container.begin(), container.end(), value);

在这个示例中，container 是已排序的容器，我们使用 std::binary_search() 函数来检查 value 是否存在于容器中。如果存在，found 将设置为 true；否则，found 将设置为 false。

请注意，对于 std::binary_search() 函数的有效工作，容器必须先进行排序。

reverse()

std::reverse() 函数用于颠倒容器中元素的顺序。

#include <algorithm>

std::reverse(container.begin(), container.end());

在这个示例中，container 是你要反转顺序的容器，通过调用 std::reverse() 函数，我们可以将容器中的元素按相反的顺序重新排列。

count()

std::count() 函数用于计算容器中指定元素的出现次数。

#include <algorithm>

int count = std::count(container.begin(), container.end(), value);

在这个示例中，container 是你要计算的容器，value 是要计数的元素。通过调用 std::count() 函数，我们可以统计容器中特定元素出现的次数，并将结果存储在变量 count 中。

accumulate()

std::accumulate() 函数用于计算容器中元素的总和。

#include <numeric>

T sum = std::accumulate(container.begin(), container.end(), initial_value);

在这个示例中，container 是你要计算总和的容器，initial_value 是初始值。通过调用 std::accumulate() 函数，我们可以对容器中的元素进行求和，并将结果存储在变量 sum 中。

请注意，initial_value 可选，它表示在计算总和之前的初始值。如果没有提供初始值，std::accumulate() 将使用容器中的第一个元素作为初始值。

math

pow() 幂次方

sqrt() 平方根

abs() 绝对值

sin()、cos() 和 tan() 三角函数

log() 和 exp() 自然对数为底的对数和指数函数

ceil() 和 floor() 向上取整和向下取整

round() 四舍五入取整