C++ STL容器

String容器

/*
	string 构造函数
	string(); //创建一个空的字符串
	string(const string& str); //使用一个string对象初始化另一个string对象
	string(cosnt char *s); //使用字符串s初始化
	string(int n,char c); //使用n个字符c初始化
	
*/

/*
	string 赋值操作
	string& operator=(const char* s); //char*类型字符串赋值给当前字符串
	string& operator=(const string &s); //把字符串s赋给当前字符串
	string& operator=(char c); //字符赋值给当前字符串
	string& assign(const char* s); //把字符串s赋给当前字符串
	string& assign(const char*s. int n); //把字符串s的前n个字符赋给当前字符串
	string& assign(const string &s); //把字符串s赋给当前字符串
	string& assign(int n, char c); //用n个字符c赋给当前字符串
	string& assign(const string &s, int start, int n); //将s从start开始n个字符赋给字符串
*/

/*
	string  存取字符操作
	char& operator[](int n); //通过[]方式取字符
	char& at(int n); //通过at方式取字符
*/

/*
	string 拼接操作
	string& operator+=(const string &str); //重载+=操作符
	string&	operator+=(const char *str); //重载+=操作符
	string&	operator+=(cosnt char c); //重载+=操作符
	string& append(const char *s); //把字符串s连接到当前字符串结尾
	string&	append(const char *s,int n); //把字符串s的前n个字符连接到当前字符串结尾
	string&	append(const string &s); //同operator+=()
	string&	append(const string &s, int pos, int n); //把字符串s中从pos开始的n个字符连接到当前字符串结尾
	string&	append(int n, char c); //在当前字符串结尾添加n个字符
*/

/*
	string 查找和替换
	int find(const string &str, int pos = 0) const; //查找str第一次出现的位置
	int find(const char *s, int pos = 0) const; //查找s第一次出现的位置，从pos开始
	int find(const char *s, int pos, int n) const; //从pos位置查找s的前n个字符串第一次位置
	int find(const char c, int pos = 0) const; //查找字符c第一次出现的位置
	int rfind(const string &str, int pos = 0) const;
	int rfind(const char *s, int pos = 0) const;
	int rfind(const char *s, int pos, int n) const;
	int rfind(const char c, int pos = 0) const;
	string& replace(int pos, int n, const string& str); //替换从pos开始的n个字符为字符串str
	string& replace(int pos, int n,const char *s); //替换从pos开始的n个字符为字符串s
*/

/*
	string 比较操作
	int compare(const string &s) cosnt; //与字符串s比较
	int compare(const char *s) const; //与字符串s比较

	compare函数在>的时候返回1，<是返回-1，==返回0,
	比较区分大小写，比较时参考字典顺序，越排在前面的越小
	大写的A比小写的a小
*/

/*
	string 子串操作
	string& substr(int pos = 0,int n = pos) const; //返回从pos开始的n个字符组成的字符串
*/

/*
	string 插入和删除操作
	string& insert(int pos, const char *s); 插入字符串
	string& insert(int pos, cosnt string &s); 插入字符串
	string& insert(int pos, int n, char c); 在指定位置插入n个字符
	string& erase(int pos, int n = pos); 删除从pos开始的n个字符
*/

vector容器

/*
	vector构造函数
	vector<T> v; //采用模板类实现类实现，默认构造函数
	vector(v.begin(), v.end()); //将v.begin(), v.end()区间中的元素拷贝给自身
	vector(n, elem); //构造函数将n个elem拷贝给自身
	vector(const vector &v); //拷贝构造函数
*/

/*
	vector 常用赋值操作
	assign(begin, end); //将v.begin(), v.end()区间中的元素拷贝给自身
	assign(n, elem); //将n个elem拷贝给自身
	vector& operator=(const vector &v); //重载等号运算符
	swap(v); //将v与本身的元素互还
*/

/*
	vector 大小操作
	size();  //返回容器中元素的个数
	empty(); //判断容器是否为空
	resize(int num); //重新指定容器的大小，若容器变长，则以默认值填充新位置；若位置变短，则末尾超出容器部分将会被删除
	resize(int num,  elem); //重新指定容器的大小，若容器变长，则以elem填充新位置；若位置变短，则末尾超出容器部分将会被删除
	capacity(); //容器的容量
	reserve(int len); //容器预留len个元素长度，预留位置不初始化，元素不可访问
*/

/*
	vector 数据存取操作
	at(int idx); //返回idx所指的数据，如果idx越界，就抛出out_of_range异常
	operator[]; //返回idx所指的数据，越界时直接报错
	front(); //返回容器中的第一个元素
	back(); //返回容器中的最后一个元素
*/

/*
	vector 插入和删除操作
	insert(const_iterator pos, int count, elem); //迭代器指向位置pos插入count个元素elem
	push_back(elem); //尾部插入元素elem
	pop_back(); //删除最后一个元素
	erase(const_iterator start, const_iterator end); //删除迭代器从start到end之间的元素
	erase(const_iterator pos); //删除迭代器指向的元素
	clear(); //删除容器中所有的元素
*/

deque容器

/*
	deque构造函数
	deque<T> deqT; //默认构造形式
	deque(beg,end); //构造函数将(beg,end)区间中的元素拷贝给自身
	deque(n,elem); //构造函数将n个elem拷贝给自身
	deque(const deque &deq); //拷贝构造函数
*/

/*
	deque赋值操作
	assign(beg,end); //将(beg,end)区间中的数据拷贝给自身
	assign(n,elem); //将n个elem拷贝给自身
	deque& operator=(const deque &deq); //重载等号运算符
	swap(deq); //将deq与本身的元素互换
*/

/*
	deque大小操作
	size(); //返回容器中元素的个数
	empty(); //判断容器是否为空
	resize(num); //重新指定容器的大小，若容器变长，则以默认值填充新位置；若位置变短，则末尾超出容器部分将会被删除
	resize(num, elem); //重新指定容器的大小，若容器变长，则以elem填充新位置；若位置变短，则末尾超出容器部分将会被删除
*/

/*
	deque双端插入和删除操作
	puch_back(elem); //在容器尾部添加一个数据
	puch_front(elem); //在容器头部插入一个数据
	pop_back(); //删除容器中的最后一个数据
	pop_front(); //删除容器中的第一个数据
*/

/*
	deque数据存取
	at(idx); //返回idx所指的数据，如果idx越界，抛出out_of_range
	operator[]; //返回索引idx所指的数据，如果idx越界，不抛出异常，直接报错
	front(); //返回第一个数据
	back(); //返回最后一个数据
*/

/*
	deque插入数据
	insert(pos, elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置
	insert(pos, n, elem0; //在pos位置插入n个elem数据，无返回值
	insert(pos, beg, end); //在pos位置插入(beg,end)区间的数据，无返回值
*/

/*
	deque删除操作
	clear(); //移除容器中的所有数据
	erase(beg,end); //删除(beg,end)区间的数据，返回下一个数据的位置
	erase(pos); //删除pos位置的数据，返回下一个数据的为位置
*/

list容器

//list是双向循环链表
/*
	list构造函数
	list<T> lstT; //list采用模板类实现，对象的默认构造形式
	list(beg,end); //构造函数将(beg,end)区间中的元素拷贝给自身
	list(n,elm); //构造函数将n个elm拷贝给自身
	list(const list &lst); //拷贝构造函数
*/

/*
	list数据元素插入和删除操作
	push_back(elem); //在容器尾部插入一个元素
	push_front(elem); //在容器开头插入一个元素
	pop_back(); //删除容器中最后一个元素
	pop_front(); //在容器开头移除一个元素
	insert(pos,elem); //在pos位置插入elem的拷贝，返回新数据的位置
	insert(pos, n, elem); //在pos位置插入n个elem数据，无返回值
	insert(pos, beg, end); //在pos位置插入(beg, end)区间的数据，无返回值
	clear(); //移除容器中的所有元素
	erase(beg,end); //删除(beg,end)区间的数据，返回下一个数据的位置
	erase(pos); //删除pos位置的数据，返回下一个数据的位置
	remove(elem); //删除容器中的所有与elem值匹配的元素
*/

/*
	list大小操作
	size(); //返回容器中元素的个数
	empty(); //判断容器是否为空
	resize(num); //重新指定容器的长度为num，如果容器变长，则用默认值填充新位置，如果容器变短，则末尾超出容器长度的值被删除 
	resize(num, elem); //重新指定容器的长度为num，如果容器变长，则用elem填充新位置，如果容器变短，则末尾超出容器长度的值被删除 
*/

/*
	list赋值操作
	assgin(beg,end); //将(beg, end)区间的数据拷贝赋值给本身
	assgin(n,elem);  //将n个elem拷贝赋值给本身
	list& operator=(const list &lst); //重载等号运算符
	swap(list); //将list与本身的元素互还
*/

/*
	list数据存取
	front(); //返回第一个元素
	back(); //返回最后一个元素
*/

/*
	list反转排序
	reverse(); //反转链表
	sort(); //list排序
*/

stack容器

/*
	stack构造函数
	stack<T> stkT; //stack采用模板类实现，stack对象的默认构造方式
	stack(const stack &stk);  //拷贝构造函数
*/

/*
	stack赋值操作
	stack& operator=(const stack &stk); //重载等号运算符
*/

/*
	stack数据存取操作
	push(elem); //向栈顶添加元素
	pop(); //从栈顶移除一个元素
	top(); //返回栈顶元素
*/

/*
	stack大小操作
	empty(); //判断栈顶是否为空
	size(); //返回堆栈大小
*/

queue容器

/*
	queue构造函数
	queue<T> queT; //queue采用模板类实现，queue对象的默认构造方式
	queue(const queue &que); //拷贝构造函数
*/

/*
	queue存取，删除和插入
	push(elem); //往队尾添加元素
	pop(); //从队头移除一个元素
	back(); //返回队尾元素
	front(); //返回队头元素
*/

/*
	queue赋值操作
	queue& operator=(const queue &que); //重载等号运算符
*/

/*
	queue大小操作
	empty(); //判断队列是否为空
	size();  //返回队列的大小
*/

set容器

/*
	set构造函数
	set<T> st; //set默认构造函数
	mulitset<T> mst; //multiset默认构造函数
	set(const set &st); //拷贝构造函数
*/

/*
	set赋值操作
	set& operator=(const set &st); //重载等号运算符
	swap(st); //交换两个集合容器
*/

/*
	set大小操作
	size(); //返回容器中元素个数
	empty(); //判断容器是否为空
*/

/*
	set插入和删除操作 
	insest(elem); //在容器中插入元素
	clear(); //清除所有元素
	erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器
	erase(beg, end); //删除区间(beg,end)的所有元素，返回下一个元素的迭代器
	erase(elem); //删除容器中值为elem的元素
*/

/*
	set查找操作
	find(key); //查找键key是否存在，返回该键的元素迭代器，若不存在，返回set.end();
	count(key); //查找键key的元素个数
	lower_bound(keyElem); //返回第一个key>=keyElem元素的迭代器
	upper_bound(keyElem); //返回第一个key>keyElem元素的迭代器
	equal_range(keyElem); //返回容器中key与keyElem相等的上下限的两个迭代器
*/

map容器

/*
	map构造函数
	map<T1, T2> mapTT; //默认构造函数
	map(const map &mp); //拷贝构造函数
*/

/*
	map赋值操作
	map& operator=(const map &mp); //重载等号运算符
	swap(mp); //交换两个map容器
*/

/*
	map大小操作
	size(); //返回容器中元素的数目
	empty(); //判断容器是否为空
*/

/*
	map插入数据元素操作
	map.insert(...); //往容器中插入元素，返回pair<iterator, bool>
*/

/*
	map删除操作
	clear(); //删除所有元素
	erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器
	erase(beg,end); //删除区间(beg, end)的所有元素，返回下一个元素的迭代器
	erase(keyElm); //删除容器中key为keyElm的对组
*/

/*
	map查找操作
	find(key); //查找键key是否存在，若存在，返回该键的元素的迭代器，若不存在，返回map.end()
	count(keyElm); //返回容器中key为keyElm的对组，对map来说，要么是1，要么是0.对mulitmap来说，值可能大于1
	lower_bound(keyElm); //返回第一个key>=keyElm元素的迭代器
	upper_bound(keyElm); //返回第一个key>=keyElm元素的迭代器
	equal_range(ketElm): //返回容器中key与keyElm相等的上下限的两个迭代器
*/