最近在网上自学C++ 看到容器这块觉着有点散 就自己打了一遍方便之后查询
string
构造函数
- string() 创建空字符串
- string(const char* s) 使用c语言字符串初始
- string(const string& s) 拷贝构造 传入一个字符串
- string(int n，char c) 使用n个字符c初始话字符串
赋值操作
- string& operator= (const char* S) char*类型字符串 赋值给string
- string& operator= (const string& S) 字符串S 赋值给string
- string& operator= (const char c) 字符c 赋值给string
- string&.assign(const char* S)
- string&.assign(const string& S)
- string&.assign(const string& S,int n) S的前n个字符赋值给当前字符串
- string&.assign(int n,char c) 使用n个字符c初始话字符串
拼接
- string& operator+= (const char* S)
- string& operator+= (const char* S，int n) S的前n个字符拼接于给当前字符串
- string& operator+= (const string& S)
- string&.append (const char* S)
- string&.append (const char* S，int n) S的前n个字符拼接于给当前字符串
- string&.append (const string& S)
- string&.append (const string& S，int pos，int n) S中从第pos个开始的n个字符拼接于给当前字符串
查找
- int string&.fing(string s,int n) 从当前字符串第n个位置开始查找s 返回s第一出现的索引 没有返回-1 n的默认值为0
- int string&.rfing(string s,int n) 同上 只是重右往左找
- int string&.fing(string s,int pos,int n) 在当前字符串中从pos的位置开始查找s的前n个字符
替换
- string&.replace(int pos,int n,string s) 从当前字符串的第pos个位置开始的n个字符替换为s
比较
- int string&.conmpare(const string &s) 当前字符与s比较字符串 比较每个字符的ascll码 相等返回0 小于返回-1 大于返回1
字符存取
- string[int index] 读取与写入 string&.at(int index)
插入和删除
- string&.insert(int pos,const char* s) 在位置pos插入s
- string&.insert(int pos,int n.char s) 在位置pos插入n个字符c
- string&.erase(int pos, int n) 从位置pos起 删除n个字符
截取字符串
- string string&.substr(int pos,int n) 从当前字符串的pos位置截取n个字符
vector
可动态扩展 单端数组 从尾部插入删除元素方便 支持迭代器的跳跃随机访问（vector<T>::iterator+n）
构造函数
- vector<T> v
- vector(v.begin(),v.end()) 填入另一个vctor的迭代器区间
- vector(n，elem) n个elem
- vector(const vector &vec) 拷贝构造 填入另一个vector容器
赋值操作
- vector& operator= (const vector &vec) vec*类型 赋值给vector
- vector&.assign(v.begin(),v.end())
- vector&.assign(n，elem)
容量和大小
- vector&.empty() 判断容器是否为空
- vector&.capacity() 容器容量
- vector&.size() 容器中元素个数
- vector&.resize(int num) 重新指定容器长度为num 变长用默认值填充新位置 变短删除超出长度元素
- vector&.resize(int num,elem )重新指定容器长度为num 变长用elem值填充新位置 变短删除超出长度元素
插入和删除
- vector&.push_back(elem) 尾部插入元素elem
- vector&.pop_back() 删除最后一个元素
- vector&.insert(const_iterator pos,elem) 指定迭代器位置pos 插入元素elem
- vector&.insert(const_iterator pos,int n，elem) 指定迭代器位置pos 插入n个元素elem
- vector&.erase(const_iterator pos) 删除迭代器指向的元素
- vector&.erase(const_iterator strat，const_iterator end) 删除迭代器区间的元素
- vector&.clear() 清空容器
数据存取
- vector&.at(int index) 返回索引值index所指的元素
- vector&[int index] operator[],返回索引值index所指的元素
- vector&.front() 返回容器中第一个元素
- vector&.back() 返回容器中最后一个元素
容器数据互换
- vector&.swap(vector& v) 当前容器元素与 容器v元素互换
预留空间
- reserve(int len) 容器预留len个元素长度 没有数据 不可访问 当数据量过大时 避免系统多次重新开辟内存空间
deque
双端数组 头、尾部插入删除元素方便 支持迭代器的跳跃随机访问（deque<T>::iterator+n）
构造函数
- deque<T> deq
- deque(deq.begin(),deq.end()) 填入另一个deque的迭代器区间
- deque(n，elem) n个elem
- deque(const deque &deq) 拷贝构造 填入另一个deque容器
赋值操作
- deque& operator= (const deque &deq) deq*类型 赋值给deque
- deque&.assign(deq.begin(),deq.end())
- deque&.assign(n，elem)
容量和大小
- deque&.empty() 判断容器是否为空
- deque&.size() 容器中元素个数
- deque&.resize(int num) 重新指定容器长度为num 变长用默认值填充新位置 变短删除超出长度元素
- deque&.resize(int num,elem )重新指定容器长度为num 变长用elem值填充新位置 变短删除超出长度元素
插入和删除
- deque&.push_back(elem) 尾部插入元素elem
- deque&.pop_back() 删除最后一个元素
- deque&.push_front(elem) 头部插入元素elem
- deque&.push_front() 删除第一个一个元素
- deque&.insert(const_iterator pos,elem) 指定迭代器位置pos 插入元素elem
- deque&.insert(const_iterator pos,int n，elem) 指定迭代器位置pos 插入n个元素elem
- deque&.insert(const_iterator pos,const_iterator strat，const_iterator end) 指定迭代器位置pos 插入迭代器区间
- deque&.erase(const_iterator pos) 删除迭代器指向的元素
- deque&.erase(const_iterator strat，const_iterator end) 删除迭代器区间的元素
- deque&.clear() 清空容器
数据存取
- deque&.at(int index) 返回索引值index所指的元素
- deque&[int index] operator[],返回索引值index所指的元素
- deque&.front() 返回容器中第一个元素
- deque&.back() 返回容器中最后一个元素
排序
- sort(const_iterator strat，const_iterator end) 给区间内的元素排序 全局函数 需添加标准算法头文件 #include <algorithm>支持随机访问的容器都可以用该算法
stack
栈 后进先出
构造函数
- stack<T> stk
- stack(const stack &stk) 拷贝构造 填入另一个stack容器
赋值操作
- stack& operator= (const stack &stk) stk 赋值给stack
容量和大小
- stack&.empty() 判断容器是否为空
- stack&.size() 容器中元素个数
数据存取
- stack&.push(elem) 向栈顶添加元素elem
- stack&.pop() 从栈顶移除第一个元素
- stack&.back() 返回栈顶元素
queue
先进先出 一端新增 一端删除 不允许遍历 队头出 队尾入
构造函数
- queue<T> que
- queue(const queue &que) 拷贝构造 填入另一个queue容器
赋值操作
- queue& operator= (const queue &que) que 赋值给queue
容量和大小
- queue&.empty() 判断容器是否为空
- queue&.size() 容器中元素个数
数据存取
- queue&.push(elem) 向队尾添加元素elem 入队
- queue&.pop() 从队头移除第一个元素 出队
- queue&.front() 返回队头元素
- queue&.back() 返回队尾元素
list
非连续存储结构体由多个节点组成 每个节点有两个部分--数据域(存放数据)和指针域(指向下一节点的数据域) 方便任意位置快速插入 删除 修改
构造函数
- list<T> l
- list(l.begin(),l.end()) 填入另一个list的迭代器区间
- list(n，elem) n个elem
- list(const list &l) 拷贝构造 填入另一个list容器
赋值和交换
- list& operator= (const list &l) l* 赋值给list
- list&.assign(l.begin(),l.end())
- list&.assign(n，elem)
- list&.swap(lst) 将lst与本身的元素互换
容量和大小
- list&.empty() 判断容器是否为空
- list&.size() 容器中元素个数
- list&.resize(int num) 重新指定容器长度为num 变长用默认值填充新位置 变短删除超出长度元素
- list&.resize(int num,elem )重新指定容器长度为num 变长用elem值填充新位置 变短删除超出长度元素
插入和删除
- list&.push_back(elem) 尾部插入元素elem
- list&.pop_back() 删除最后一个元素
- list&.push_front(elem) 头部插入元素elem
- list&.push_front() 删除第一个一个元素
- list&.insert(const_iterator pos,elem) 指定迭代器位置pos 插入元素elem 返回新数据位置
- list&.insert(const_iterator pos,int n，elem) 指定迭代器位置pos 插入n个元素elem 无返回值
- list&.insert(const_iterator pos,const_iterator strat，const_iterator end) 指定迭代器位置pos 插入迭代器区间 无返回值
- list&.erase(const_iterator pos) 删除迭代器指向的元素
- list&.erase(const_iterator strat，const_iterator end) 删除迭代器区间的元素
- list&.clear() 清空容器
- list&.remove(elem) 删除容器中所有elem
数据存取
- list&.front() 返回第一个
- list&.back() 返回最后一个元素
反转和排序
- list&.reverse() 反转
- list&.sort() 排序 默认从小到大
set
元素在插入时自动排序 不能插入相同元素（multiset 和set一样 但是可以重复插入数据）
构造函数
- set<T> s
- set(const set &s) 拷贝构造 填入另一个set容器
赋值
- set& operator= (const set &s) s* 赋值给set
插入和删除
- set&.insert(elem) 插入元素elem
返回一个 _PaerID (pari<iterator,bool>) pari<set<T>iterator,bool> ret = s.insert(elem) if(ret.second) 插入成功
- set&.clear()
- set&.erase(const_iterator pos) 删除迭代器指向的元素
- set&.erase(const_iterator strat，const_iterator end) 删除迭代器区间的元素
- set&.erase(elem) 删除元素
交换和大小
- set&.empty() 判断容器是否为空
- set&.size() 容器中元素个数
- set&.swap(set) 将lst与本身的元素互换
查找和统计
- set&.find(elem) 找到返回迭代器pos 没找到返回set.end()
- set&.count(elem) 统计元素elem的个数 没有返回0
*排序 在创建时可规定排序方法 在声明部分 加入一个仿函数名作为参数 set<T,Mycompare> s 重写 "()"
class Mycompare
{
public:
bool operator() (int v1,int v2)
{
return v1 > v2;
}
}
** 对组pair pair<type,type> p(type,type) -- pair<sting,int> p("name",19age)
pair<type,type> p = make_pair(type,type) --pair<sting,int> p = make_pair("name",19age)
使用p.first和p.second 访问
map和multimap
所有元素都是对组pair pari中的第一个元素key起到索引的作用 第二个元素为value 值 类似c#的字典 可快速根据key找到value 该数据结构在插入时根据 Pari的key自动排序 map不可以插入重复key值的元素 multimap可以
构造函数
- map<T1,T2> m
- map<T1,T2> m(const map &m)
插入
- map.insrt(pari<T1,T2>(key,value)) 将匿名对组pari<T1,T2>(key,value)队组插入map
赋值
- map& operator= (const map &m) m* 赋值给map
交换和大小
- map&.empty() 判断容器是否为空
- map&.size() 容器中元素个数
- map&.swap(mp) 将mp与本身的元素互换
插入和删除
- map&.insert(elem) 插入元素elem
- map&.clear()
- map&.erase(const_iterator pos) 删除迭代器指向的元素
- map&.erase(const_iterator strat，const_iterator end) 删除迭代器区间的元素
- map&.erase(ley) 删除key的元素
查找和统计
- map&.find(key) 通过key 查找value 返回迭代器 map<T1,T2>::iterator mit
- map&.count(key) 统计key的元素个数
*排序 在创建时可规定排序方法 在声明部分 加入一个仿函数名作为参数 map<T1,T2,Mycompare> s 重写 "()"
class Mycompare
{
public:
bool operator() (int v1,int v2)
{
return v1 > v2;
}
}
stl 内建函数对象：包含头文件 <functional>
算数仿函数:
- 加法： template<class T> T plus<T> 声明 plus<int>p; 应用 p(10.20);
- 减法： template<class T> T minud<T>
- 乘法： template<class T> T multiplies<T>
- 除法： template<class T> T divides<T>
- 取模： template<class T> T modulus<T>
- 取反： template<class T> T negate<T>
关系仿函数:
- 等于： template<class T> bool equal_to<T> 声明 equal_to<int> eq; eq(20,10);
- 不等于： template<class T> bool not_equal_to<T>
- 大于： template<class T> bool greater<T>
- 大于等于： template<class T> bool greater_equal<T>
- 小于： template<class T> bool less<T>
- 小于等于： template<class T> bool less_equal<T>
逻辑仿函数:
- 于： template<class T> bool logical_and<T>
- 或： template<class T> bool logical_or<T>
- 非： template<class T> bool logical_not<T>
stl 常用算法：包含头文件 <algorithm> || <functional> || <numeric>
常用遍历算法: <algorithm>
- for_each(iterator beign,iterator end, 仿函数()||普通函数() )； 第三个参数可以在遍历时对数据做一些操作
- transform(iterator beign,iterator end,iterator targetbeg，仿函数()||普通函数() )； 将一个区间搬运到以目标容器 第一 个参数为目标容器的起始迭代器 第四个参数可以在遍历时对数据做一些操作
- find(iterator beign,iterator end,value) ; 在区间内查找value值 返回迭代器 没找到返回 end
- find_if(iterator beign,iterator end,谓词||普通函数() ) ; [*谓词：返回bool类型的仿函数] 按条件查找 返回迭代器
- adjacent_fing(iterator beign,iterator end) ; 区间内查找相邻重复元素 返回重复的第一个位置的迭代器
- bool binary_search(iterator beign,iterator end,value) ; 查找数据是否存在 返回bool 必须在有序序列中使用
- int count(iterator beign,iterator end,value); 统计指定数据个数
常用排序方法：<algorithm>
- sort(iterator beign,iterator end, 仿函数()||普通函数() );第三个参数可以改变默认排序方式
- random_shuffle(iterator beign,iterator end);打乱容器顺序 需加随机种子 （srand(unsigned int)time(NULL)）
- merge(iterator beign1,iterator end1,iterator beign2,iterator end2,iterator tagerbeign) ;将两个容器的数据合并，并 放在一个新的容器中 者两个容器必须为有序
- revers(iterator beign,iterator end);反转 首位对调
常用拷贝和替换算法：<algorithm>
- copy(iterator beign,iterator end, iterator tagerbeign);区间内数据拷贝到目标容器
- replace(iterator beign,iterator end，oldvalue，newvalue) ;区间内数据的所有oldvalu替换为newvalue
- eplace(iterator beign,iterator end，仿函数()||普通函数()，newvalue) ;区间内所有符合函数条件的数据替换为newvalue
- swap(container c1,container c2）;容器c1 c2的所有数据互换 容量类型要相同
常用算数生成算法：<numeric>
- accumulate(iterator beign,iterator end, value) ;区间内数据的和 value为起始值
- fill(iterator beign,iterator end, value) ;区间内数据填充为value
常用集合算法：<algorithm>
- set_intersection(iterator beign1,iterator end1,iterator beign2,iterator end2,iterator tagerbeign);求两个容器的交集并放入新容器
- set_union(iterator beign1,iterator end1,iterator beign2,iterator end2,iterator tagerbeign) ;求两个容器的并集并放入新容器
- set_difference(iterator beign1,iterator end1,iterator beign2,iterator end2,iterator tagerbeign) ;求两个容器的差集并放入新容器 (*求第一个容器与第二个容器的差集!=求第二个容器与第一个容器的差集)
** 上诉所有涉及到要新建容器的时 不要忘记申请容器大小。
*/
263
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
