char

转大小写：

char ch = 'a';
ch = (char) toupper(ch);
ch = (char) tolower(ch);

下一个字符：

'b' == ('a' + 1);

int

最大值最小值：

int MAX = INT_MAX;
int MIN = INT_MIN;

array

创建数组：

int array [4];	// 如果不初始化则值随机
int array[] = {1,2,3,4};
int array[4] = {0};	// {0, 0, 0, 0}
// 注意只有0可以这样被初始化，其他的数是不行的
int array[4] = {1};	// {1, 0, 0, 0}，只有第一个数被初始化为1，其他的还是默认值

引用：

array[3];

获取长度：

sizeof(array) / sizeof(array[0]);

排序：

#include <algorthm>
int a[] = {5, 4, 3, 2, 1};
int n = sizeof(a) / sizeof(a[0]);
// 升序
sort(a, a + n);
// 降序
bool compare(int a, int b)
{
    return a > b;	// 若改为a < b则为升序
}
sort(a, a + n, compare);

string

创建字符串：

string s = "cpp";

引用

s[0]	// s[0] = 'c'

字符串相等：

string s1 = "abc";
string s2 = "abc";
s1.compare(s2);
// 若s1小于s2返回-1
// 若相等返回0
// 若s1大于s2返回1

字符串长度：

int n = s.size();

字符串连接：

s1.append(s2);

截取字符串：

string s = "abc";
string sub = s.substr(0, 1);	// str = "a";

字符的位置：

string s = "abc";
s.find('a');	// 从前向后查找第一个出现的'a'的位置
s.rfind('a');	// 从后往前查找第一个出现的'a'的位置
s.find_first_of("abc");	// 从前往后查找第一次出现在"abc"中任意字符的位置
s.find_last_of();
s.find_first_not_of();
s.find_last_not_of();
// 如果没有查询到则返回：
string::npos

插入字符串：

string s1 = "abc";
s1.insert(1, "ddd");	// s1 = "adddbc"

字符串交换：

s1.swap(s2);

字符串替换：

string s = "a! b";
replace(s.begin(), s.end(), '!', ' ');	// str = "a  b";

删除字符串头尾的空格：

string trim(string s)
{
    if (s.empty())
    {
        return s;
    }
    s.erase(0, s.find_first_not_of(" "));
    s.erase(s.find_last_not_of(" ") + 1);
    return s;
}

字符串修改：

string s = "apple";
s[0] = 'b';

字符串删除：

string s = "apple";
s.erase(bit, num);	// bit表示开始的删除的位，num表示要删除的字符的个数

vector

定义vector：

// 一维
vector<int> vec;
vector<int> vec(3);	// 默认值为0

// 利用数组初始化
int arr[] = {1, 2, 3};
vector<int> vec(begin(arr), end(arr));

// 二维
vector<vector<int>> vec(m, vector<int>(n));	// 长为m，宽为n

排序：

sort(vec.begin(), vec.end());	// 升序
sort(vec.rbegin(), vec.end());	// 降序

取栈顶：

vec.back();

判断是否存在：

if (find(vec.begin(), vec.end(), key) != vec.end())
{
	// != 表示存在
}

删除元素：

vec.erase(vec.begin() + index);	// 删除第index个元素

判断是否为空：

vec.empty();

清空列表：

vec.clear();

反转：

vec.reverse(vec.begin(), vec.end());

二维排序：

vector<vector<int>> vec{{3, 4}, {1, 2}, {5, 6}};
// 按照第一列，升序排列
sort(vec.begin(), vec.end());

// 若不是，则需要写排序规则
bool compare(const vector<int> &a, const vector<int> &b)
{
	return a[1] < b[1];	// 按照第二列升序
}

pair

创建：

pair<int, int> p;
pair<int, int> p(p1, p2);
make_pair(p1, p2);

取值：

p1.first;	// 第一个元素
p1.second;	// 第二个元素

pair作为函数返回值：

std::pair<std::string, std::int> getPerson() {
    return std::make_pair("Kyxie", 1);
}
std::tie(p1, p2) = getPerson();

unordered_map

创建一个哈希映射：

#include <unordered_map>
unordered_map <int, int> map;

存储键值对（修改键值对）：

map.insert(pair<int, int>(key, value));
map[key] = value;	// 这种更简单

获取 key 的内容：

map[key];

查询是否存在 key：

map.count(key);	// 如果存在，返回1，不存在则返回0
if ((auto iter = map.find(key)) != map.end());	// 存在则括号内为真
// iter的数据类型为 unordered_map<int, int>::iterator

if (map[key] == 0)	// 这种最简单

遍历键值对：

for (auto i = map.begin(); i != map.end(); i++)
{
    // key: i->first
    // value: i->second
}

是否为空：

map.empty();

删除Key：

map.erase(key);

map的大小：

map.size();

unordered_set

遍历：

for (auto i = set.begin(); i != set.end(); i++) {
    cout << *i << endl;
}

queue

创建queue:

queue<int> q;

加入元素：

q.push(1);

删除队首元素：

q.pop();	// 这个没有返回值

队首元素：

q.front();

队列大小：

q.size();

是否为空：

q.empty();

互相转换

// int转string
int i;
string str = to_string(i);

// string转int
String str;
int i = stoi(str);

// char转int
char ch;
int i = ch - '0';

// int转char
int i;
char ch = i + '0';

// char[]转int
char s[] = "111";
int i = atoi(s);

// int转char[]
int i = 111;
char ch[100];
itoa(i, ch, 10);
// 第一个参数为待转化的整数
// 第二个参数为输出的字符串数组
// 第三个参数为进制，范围为2 - 36

// String转char[]
string str;
char *ch = (char *)str.data();

// char[]转String
char ch[] = "abcd";
string str(ch);

// char转String
char ch = 'a';
string str(1, ch);

// int[]转vector
int a[] = {1, 2, 3};
vector<int> vec(a, a + sizeof(a) / sizeof(int));

// vector转int[]
vector<int> vec{1, 2, 3};
int i[vec.size()];
memcpy(i, &vec[0], vec.size() * sizeof(vec[0]));