Cpp CheatSheet

/*
封装 char* 字符串指针的类，管理 char* 所分配内存，不用考虑内存释放和越界，但内部字符串不以空字符结尾*/

string s											//	生成一个空字符串
s=str,s.assign(str)			     		   			//  赋值
string s(str)										//	生成str复制品s
string s(str,idx)									//	以str始于idx的部分初始化s
string s(str,idx,len)								//	以str始于idx且不超过len长的部分初始化s
string s(cstr)										//	以cstr初始化s
string s(cstr,len)								    //	以cstr前不超过len长的部分初始化s
string s(n,ch)									    //	以n个字符ch初始化s
string s(beg,end)								    //	以由迭代器begin和end指定字符串[begin, end)初始化s

s[i],s.at(i)	             						//  访问下标对应字符元素
s.begin()											//  返回指向首元素的正向迭代器
s.end()												//  返回指向尾元素的下一个位置的正向迭代器
s.rbegin()											//  返回指向尾元素的逆向迭代器
s.rend()											//  返回指向首元素的上一个位置的逆向迭代器

+=,s.append(str),s.push_back(ch)					//	拼接s和str/ch
s.insert(idx,str)									//	在s的idx处插入str
s.erase(idx,len)									//  删除s从idx开始的len个字符
s.replace(idx,len,str)								//	将s从idx开始的len个字符替换为str
s.substr(idx,len)									//	返回s从idx开始的len个字符子串
>、<、>=、<=、==、!=、s.compare(str)  				//	按照字典序比较两个字符串

s.c_str()											//	返回一个指向C字符串的指针常量,指向字符数组以空字符结尾    
s.data()											//	返回一个指向C字符串的指针常量,不以空字符结尾
s.copy(p,len,idx)									//	将s从idx开始的len个字符复制到数组指针p，不以空字符结尾
>>													//	从stream中读取字符串
<<													//	将值写入stream
    
s.size(),s.length()            						//  返回串长
s.capacity()										//	s已分配容量
s.reserve(len)        								//  预分配缓冲空间，使存储空间可容纳len个字符
s.resize(len)										//  扩展字符串，或者截断字符串为len长
s.max_size()										//	string类型结构最多包含的字符数

s.empty()           								//  检查串空
s.clear()											//  删除容器中的所有内容
s.swap(v)           								//  将s与另一个string对象v内容进行交换

/*
顺序结构线性表,支持快速随机访问，在使用过程中动态地增长存储空间,底层数据结构为数组*/

vector<type> v      								//  生成一个type类型空序列
vector<type> v(n,m)  								//  生成一个含有n个type类型元素m的序列
vector<type> v(first,last)，v.assign(first,last)    //  以指定序列[first, last)初始化v
vector<vector<int> >res(m,vector<int>(n,0));        //   生成一个m*n的置0数组
	
v[i]                								//  访问下标对应序列元素
v.front()           								//  返回首元素
v.back()            								//  返回尾元素
v.begin()           								//  返回指向首元素的正向迭代器
v.end()             								//  返回指向尾元素下一位置的正向迭代器

v.push_back(val)      								//  向序列尾插入元素val
v.pop_back()        								//  删除尾元素
v.insert(it,val)   								    //  向迭代器it指向的元素前插入新元素val
v.insert(it,n,val)								    //  向迭代器it指向的元素前插入n个新元素val
v.insert(it,first,last)     						//  向迭代器it指向的元素前插入指定序列[first, last)

v.erase(it)											//  删除迭代器it指向元素
v.erase(first,last)								    //  删除指定序列[first, last)

>、<、>=、<=、==、!=   								//	按照字典序比较两个序列  

v.size()            								//  返回序列长
v.reserve(len)        								//  预分配缓冲空间，使存储空间可容纳len个元素
v.resize(len)										//  扩展序列，或者截断序列为len长
v.resize(len,val)    								//  扩展序列并以val值填充，或者截断序列为len长
    
v.empty()           								//  检查序列空
v.clear()											//  删除容器中的所有内容
v.swap(s)           								//  将v与另一个vector对象s进行交换

/*
底层双向链表，支持快速增删*/

list<type> a{n1,n2,n3,...}							// 以type类型元素n1,n2,n3,...初始化链表a
list<type> a(n, m)  								// 生成一个含有n个type类型元素m的序列
list<type> a(first, last)  							// 以指定序列[first, last)初始化v

a.front()           								//  返回首元素
a.back()            								//  返回尾元素
a.begin()           								//  返回指向首元素的随机存取迭代器
a.end()             								//  返回指向尾元素下一位置的随机存取迭代器

a.push_front(val)     								//  向表头插入元素val
a.push_back(val)      								//  向表尾插入元素val
a.insert(it, val)   								//  向迭代器it指向的元素前插入新元素val
a.insert(it, n, val)								//  向迭代器it指向的元素前插入n个新元素val
a.insert(it, first, last)   						//  向迭代器it指向的元素前插入指定序列[first, last)
    
a.pop_back()        								//  删除表尾元素
a.pop_front()       								//  删除表头元素
a.erase(it)         								//  删除由迭代器it所指向的元素
a.erase(first, last)								//  删除指定序列[first, last)
a.remove(x)        	 								//  删除了a中所有值为x的元素

a.size()            								//  返回序列长
a.resize(len)										//  扩展序列，或者截断序列为len长
a.resize(len,val)    								//  扩展序列并以val值填充，或者截断序列为len长
    
a.merge(b)          								//  b变为空，a中包含原a和b的元素
    
a.empty()           								//  检查序列空
a.clear()           								//  删除容器中的所有内容
a.swap(v)           								//  将a与另一个list对象进行交换

/*
底层用list或deque实现，先进后出*/

stack<type> s										//	生成一个type类型空栈	

s.push(val)  										//  入栈
s.pop()    											//  出栈
s.top()    											//  访问栈顶

s.empty()  											//  检查栈空
s.size()  											//  返回栈大小

/*
底层用list或deque实现，先进先出*/

queue<int> q										//	生成一个type类型空队列	

q.push(val)  										//  入队
q.pop()    											//  出队
q.front()  											//  访问队首元素
q.back()   											//  访问队尾元素

q.empty()  											//  检查队空
q.size()	   										//  返回队长

/*
双端队列,中控器控制多个真实数据缓冲区，支持首尾快速增删*/

deque<type> d     									//  生成一个type类型空序列
deque<type> d(n,m)  								//  生成一个含有n个type类型元素m的序列
deque<type> d(first,last)						    //  以指定序列[first, last)初始化d

d.front()           								//  返回首元素
d.back()            								//  返回尾元素
d.begin()											//  返回指向首元素的正向迭代器
d.end()												//  返回指向尾元素的下一个位置的正向迭代器
d.rbegin()											//  返回指向尾元素的逆向迭代器
d.rend()											//  返回指向首元素的上一个位置的逆向迭代器
    
d.push_front(val)     								//  向队列头插入元素val
d.push_back(val)      								//  向队列尾插入元素val
d.emplace_front()     								//  向队列头插入一个元素空间
d.emplace_back()      								//  向队列尾插入一个元素空间
    
d.push_back(val)      								//  向序列尾插入元素val
d.pop_back()        								//  删除尾元素
   
d.insert(it,val)									//在指定位置插入元素 
d.erase(it)											//在指定位置删除元素 
    
d.empty()           								//  检查序列空
d.size()            								//  返回序列长
d.clear()           								//  删除容器中的所有内容

/*
set去重,multiset可以存在相同元素,unordered_set查询更快*/

set<type> s											//	生成一个type类型空集合
multiset<type> s									//	生成一个type类型空可重集合
unordered_set<type> s(first,last)     				//	以指定序列[first, last)初始化s

s.begin()       									//  返回指向首元素的正向迭代器
s.end()         									//  返回指向尾元素的下一个位置的正向迭代器
s.rbegin()											//  返回指向尾元素的逆向迭代器
s.rend()											//  返回指向首元素的上一个位置的逆向迭代器

s.insert(val)      									//  插入元素val
s.erase(val)       									//  删除集合s中元素val
s.find(val)        									//  返回一个指向被查元素val的迭代器,无则返回s.end()

s.size()        									//  返回集合长
s.count(val)       									//  返回集合中val的个数

s.empty()      										//  检查集合空
s.clear()											//  删除容器中的所有内容
s.swap(v)											//  将s与另一个set对象v进行交换
    
s.max_size()    									//  返回set类型对象能容纳的元素的最大限值
s.get_allocator()   								//  返回集合s的分配器
s.equal_range(val) 									//  返回集合s中与给定值val相等的上下限迭代器
s.lower_bound() 									//  返回指向第一个大于或等于指定键的元素迭代器
s.upper_bound() 									//  返回指向第一个大于指定键的元素迭代器
s.key_comp()    									//  用于比较两个键的大小关系，它返回一个用于键比较的函数对象
s.value_comp()  									//  用于比较两个值的大小关系，它返回一个用于值比较的函数对象

/*
#include <utility>,pair二元组或元素对*/

pair<type1,type2> p          						//	生成一个<type1,type2>类型空二元组
p.first												//	定义/返回二元组p的第一个元素
p.second											//	定义/返回二元组p的第二个元素
make_pair(val1,val2)								//  以val1为键,val2为值初始化p
    
<、>、<=、>=、==、!=								 	//  按照字典序比较，先比较first，first相等时再比较second

/*
存储pair序列,所有元素的Key值必须是唯一的,multiset可以存在相同键值,unordered_map查询更快*/
map<type1,type2> m								//	生成一个<type1,type2>类型空字典

m[key] = value									//  修改/插入pair<key,value>，返回m[key]的value值
m.insert(make_pair(key,value)) 					//  插入pair<key,value>，insert操作会返回一个pair,当map中没有与key相匹配的键值时,其first是指向插入元素对的迭代器,其second为true;若map中已经存在与key相等的键值时,其first是指向该元素对的迭代器,second为false

int value = m[key]              				//  查找字典中键为key的value值，无则创建m[key]=0且返回0
it = m.find(key)			    				//  查找字典中键为key对应迭代器，无则返回m.end()

m.erase(key)									//  删除指定key键值相匹配的元素对,并返回被删除的元素的个数
m.erase(it)										//  删除由迭代器it所指定的元素对,并返回指向下一个元素对的迭代器
    
m.size();       								//  返回字典长
m.empty();      								//  检查字典空
m.clear();      								//  删除容器中的所有内容

const int MAXN = 32;
bitset<MAXN> bt;            //  bt 包括 MAXN 位，下标 0 ~ MAXN - 1，默认初始化为 0
bitset<MAXN> bt1(0xf);      //  0xf 表示十六进制数 f，对应二进制 1111，将 bt1 低 4 位初始化为 1
bitset<MAXN> bt2(012);      //  012 表示八进制数 12，对应二进制 1010，即将 bt2 低 4 位初始化为 1010
bitset<MAXN> bt3("1010");   //  将 bt3 低 4 位初始化为 1010
bitset<MAXN> bt4(s, pos, n);//  将 01 字符串 s 的 pos 位开始的 n 位初始化 bt4

bt.any()        //  bt 中是否存在置为 1 的二进制位？
bt.none()       //  bt 中不存在置为 1 的二进制位吗？
bt.count()      //  bt 中置为 1 的二进制位的个数
bt.size()       //  bt 中二进制位的个数
bt[pos]         //  访问 bt 中在 pos 处的二进制位
bt.test(pos)    //  bt 中在 pos 处的二进制位是否为 1
bt.set()        //  把 bt 中所有二进制位都置为 1
bt.set(pos)     //  把 bt 中在 pos 处的二进制位置为 1
bt.reset()      //  把 bt 中所有二进制位都置为 0
bt.reset(pos)   //  把 bt 中在pos处的二进制位置为0
bt.flip()       //  把 bt 中所有二进制位逐位取反
bt.flip(pos)    //  把 bt 中在 pos 处的二进制位取反
bt[pos].flip()  //  同上
bt.to_ulong()   //  用 bt 中同样的二进制位返回一个 unsigned long 值
os << bt        //  把 bt 中的位集输出到 os 流