C++基础学习笔记09——STL

STL

C++面向对象和泛型编程的思想，目的就是复用性的提升
STL（Standard Template Library，标准模板库）
STL从广义上分为：容器（container）算法（algorithm）迭代器（iterator）
容器和算法之间通过迭代器进行无缝连接
STL六大组件：
容器：各种数据结构
算法：各种常见的算法
迭代器：扮演了容器和算法之间的胶合剂
仿函数：行为类似函数，可作为算法的某种策略
适配器：一种用来修饰容器或者仿函数或者迭代器接口的东西
空间适配器：负责空间的配置与管理

1. STL初识

容器：vector
算法：for_each
迭代器：vector::iterator

vector<int> v;
for(int i=0;i<10;i++){
v.push_back(i);	//插入数据
}
for(vector<int>::iterator it=v.begin();it!=v.end();it++){	//遍历容器
cout<<*it<<endl;
}

vector嵌套：

vector< vector<int> > v;
vector<int> v1;
vector<int> v2;
vector<int> v3;
for(int i=0;i<4;i++){
v1.push_back(i);
v2.push_back(i+1);
v3.push_back(i+2);
}
v.push_back(v1);
v.push_back(v2);
v.push_back(v3);
for(vector< vector<int> >::iterator it=v.begin();it!=v.end();it++){
for(vector<int>::iterator vit=(*it).begin;vit!=(*it).end;vit++){
cout<<*vit<<endl;
}
}

相当于二维数组

2. string容器

2.1 构造
string(); //创建一个空字符串，例如：string str；
string(const char* s); //使用字符串s初始化
string(const string& str); //使用一个string对象初始化另一个string对象
string(int n,char c); //使用n个字符c初始化；

string s1;	//创建空字符串
const char* s2="hello world";
string s3(s2);	//调用拷贝构造函数
string s4(10,'a');	//10个字符a赋值给s4

2.2 赋值

string s1="hello world";	//字符s1赋值
string s2=s1;	//字符s1赋值给s2
string s3='a';	//字符值赋给当前字符串
string s4;
s4.assign("hello world");	//字符串s赋值给当前字符
string s5;
s5.assign("hello world",5);	//把字符串前5个字符赋值给当前字符串
string s6;
s6.assign(s5);		//把字符串s赋值给当前字符串
string s7;
s7.assign(5,'x');	//用n个字符c赋值给当前字符串

2.3 拼接

string s1="我";
s1+="爱玩";
string s2="游戏";
s1+=s2;
string s3="I";
s3.append(" love ");	//把字符串s接到当前字符串结尾
s3.append("game ab",4);	//把字符串s前n个字符连接到当前字符串结尾
s3.append(s2);		//将字符串s连接到当前字符串结尾
s3.append(s2,4,3);	//将字符串s中从pos开始的n个字符连接到当前字符串结尾，s.append(字符串，起始位置，字符数)

2.4 查找与替换

string s1="abcdefgde";
int pos=s1.find("de");	//查找起始位置
s1.replace(1,3,"aaaaa");
//s.replace(起始位置，替换数目，替换字符串)

总结：
find查找是从左往右，rfind从右往左
find找到字符串后返回查找的第一个字符位置，找不到返回-1
replace在替换时，要指定从哪个位置起，多少个字符，替换成什么

2.5 插入和删除

string s1="hello";
s1.insert(1,"he");	//在指定位置插入字符串
s1.insert(4,5,'c');	//在指定位置插入指定数目字符
s1.erase(5);	//从指定位置开始删除字符串
s1.erase(3,2);	//从指定位置删除指定数目字符

总结：
插入：
s.insert(指定位置，字符串(字符))；
s.insert(指定位置，指定数目，指定字符)；
删除：
s.erase(指定位置，指定数目(可省略))；

2.6 子串获取

string s1="abcdef";
string s2=s1.substr(2,3);	//从字符串s指定位置开始截取指定数目字符

3. vector容器

3.1 基本概念
功能：与数组相似，单端数组
与数组区别：vector可以动态扩展

3.2 构造

vector<int> v1;
for(int i=0;i<10;i++){
v1.push_back(i);
}
vector<int> v2(v1.begin(),v1.end());	//将区间begin()到end()的值赋给v2
vector<int> v3(10,100);	//将指定数目的值赋值给v3
vector<int> v4(v3);	//拷贝构造

3.3 赋值

vector<int> v2;
v2=v1;
vector<int> v3;
v3.assign(v1.begin(),v1.end());	//将begin()到end()的值赋值给v3
vector<int> v4;
v4.assign(10,100);

3.4 容量和大小

v1.empty();	//判断容器是否为空
v1.capacity() ;	//容器的容量
v1.size();	//返回容器中元素个数
v1.resize(6);	//重新指定容器的长度，若容器变长，则用默认值填充新位置
//若容器变短，则末尾超出容器长度的元素被删除
v1.resize(6,8); //重新指定容器的长度，若容器变长，则用指定值填充新位置
//若容器变短，则末尾超出容器长度的元素被删除

3.5 插入和删除

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

3.6 数据存取

v1.at(int idx);	//返回索引idx所指的数据
cout<<v1[idx];	//返回索引idx所指的数据
v1.front();		//返回容器中第一个数据元素
v1.back();		//返回容器中最后一个数据元素

4. deque容器

功能：双端数组，可以对头端进行插入删除操作
deque与vector区别：
vector对于头部的插入删除操作效率低，数据量越大，效率越低
deque相对而言，对头部的插入删除速度比vector快
vector访问元素的速度会比deque快

4.1 构造

deque<int> d1;
for(int i=0;i<10;i++){
d1.push_back(i);
}
deque<int> d2(d1.begin(),d1.end());	//将区间begin()到end()的值赋给d2
deque<int> d3(10,100);	//将指定数目的值赋值给d3
deque<int> d4(v3);	//拷贝构造

4.2 赋值

deque<int> d2;
d2=d1;
deque<int> d3;
d3.assign(d1.begin(),d1.end());	//将begin()到end()的值赋值给d3
deque<int> d4;
d4.assign(10,100);

4.3 deque容量和大小

d1.empty();	//判断容器是否为空
d1.capacity() ;	//容器的容量
d1.size();	//返回容器中元素个数
d1.resize(6);	//重新指定容器的长度，若容器变长，则用默认值填充新位置
//若容器变短，则末尾超出容器长度的元素被删除
d1.resize(6,8); //重新指定容器的长度，若容器变长，则用指定值填充新位置
//若容器变短，则末尾超出容器长度的元素被删除

4.4 插入和删除

deque<int> d;
d.push_back(elem);		//在容器尾部添加一个数据
d.push_front(elem);		//在容器头部插入一个数据
d.pop_back();			//删除容器最后一个数据
d.pop_front();			//删除容器第一个数据
d.insert(pos,elem);		//在pos位置插入一个elem元素的拷贝，返回新数据的位置
d.insert(pos,n,elem);	//在pos位置插入n个elem数据，无返回值
d.insert(pos,beg,end);	//在pos位置插入[beg，end)区间的数据，无返回值
d.clear();				//清空所有数据
d.erase(beg,end);		//删除[beg，end)区间的数据，返回下一个数据的位置
d.erase(pos);			//删除pos位置的数据，返回下一个数据的位置

4.5 数据存取

d1.at(int idx);	//返回索引idx所指的数据
cout<<d1[idx];	//返回索引idx所指的数据
d1.front();		//返回容器中第一个数据元素
d1.back();		//返回容器中最后一个数据元素

5. stack容器

概念：stack是一种先进后厨的数据结构

stack<int> s;	//构造栈
s.push(elem);	//向栈顶添加元素
s.pop();		//从栈顶移除第一个元素
s.top();		//返回栈顶元素
s.empty();		//判断栈是否为空
s.size(); 		//返回栈的大小

6. queue容器

概念：queue是一种先进先出的数据结构

queue<int> q;	//构造队列
q.push(elem);	//向队尾添加元素
q.pop();		//从对头移除第一个元素
q.back();		//返回最后一个元素
q.front();		//返回第一个元素
q.empty();		//判断队列是否为空
q.size();		//返回队列大小

7. list容器

功能：将数据进行链式存储
STL中的链表是一个双向循环链表
由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器
list的有点：
采用动态存储分配，不会造成内存浪费和溢出
链表执行插入和删除操作十分方便，修改指针即可，不需要大量移动元素
list的缺点：
链表灵活，但是空间和时间额外耗费较大

7.1 构造

list<int> l1;
for(int i=0;i<10;i++){
l1.push_back(i);
}
list<int> l2(l1.begin(),l1.end());	//将区间begin()到end()的值赋给l2
list<int> l3(10,100);	//将指定数目的值赋值给l3
list<int> l4(l3);	//拷贝构造

7.2 赋值

list<int> l2;
l2=l1;
list<int> l3;
l3.assign(l1.begin(),l1.end());	//将begin()到end()的值赋值给l3
list<int> l4;
l4.assign(10,100);

7.3 大小

l1.empty();	//判断容器是否为空
l1.size();	//返回容器中元素个数
l1.resize(6);	//重新指定容器的长度，若容器变长，则用默认值填充新位置
//若容器变短，则末尾超出容器长度的元素被删除
l1.resize(6,8); //重新指定容器的长度，若容器变长，则用指定值填充新位置
//若容器变短，则末尾超出容器长度的元素被删除

7.3 插入和删除

list<int> l;
l.push_back(elem);		//在容器尾部添加一个数据
l.push_front(elem);		//在容器头部插入一个数据
l.pop_back();			//删除容器最后一个数据
l.pop_front();			//删除容器第一个数据
l.insert(pos,elem);		//在pos位置插入一个elem元素的拷贝，返回新数据的位置
l.insert(pos,n,elem);	//在pos位置插入n个elem数据，无返回值
l.insert(pos,beg,end);	//在pos位置插入[beg，end)区间的数据，无返回值
l.clear();				//清空所有数据
l.erase(beg,end);		//删除[beg，end)区间的数据，返回下一个数据的位置
l.erase(pos);			//删除pos位置的数据，返回下一个数据的位置
l.remove(elem);			//删除容器中所有与elem值匹配的元素

7.4 数据存取

l.front();	//返回第一个元素
l.back();	//返回最后一个元素

7.5 反转与排序

l.reverse();	//反转链表
l.sort();		//链表排序

8. set/multiset 容器

set基本概念：所有元素都会在插入时自动排序
set与multiset区别：
set不允许容器中有重复的元素
multiset允许容器中有重复的元素

8.1 构造和赋值

set<int> s;
s.insert(elem);		//插入数据elem

8.2 大小和交换

s.empty();	//判断容器是否为空
s.size();	//返回容器中元素个数
s.swap(s1);	//交换两个容器的元素

8.3 插入和删除

s.insert(elem);			//在容器中插入元素
s.clear();				//清空所有数据
s.erase(beg,end);		//删除[beg，end)区间的数据，返回下一个数据的位置
s.erase(pos);			//删除pos迭代器所指位置的数据，返回下一个数据的位置
s.erase(elem);			//删除容器中elem值的元素

8.4 查找和统计

s.find(key);		//查找key元素是否存在，返回该元素的迭代器
s.count(key);		//统计key元素的个数

9. pair容器

功能描述：成对出现的数据，利用pair可以返回两个数据
创建方式：
pair<type,type> p(value1,value2);
pair<type,type> p=make_pair(value1,value2);

pair<string,int> p1("Tom",18);
pair<string,int> p2=make_pair("Jerry",18);
cout<<p1.first<<" "<<p1.second<<endl;
cout<<p2.first<<" "<<p2.second<<endl;	//访问两个数据

10. map容器

简介：
map容器中所有元素都是pair
pair中第一个元素为key（键值），第二个元素为value（实值）
所有元素都会根据元素的键值自动排序
优点：
可以根据key值快速找到value
map和multimap区别：
map不允许容器中有重复的key值元素
multimap中允许荣有重复的key值元素

10.1 构造

map<int,int> m;
m.insert(pair<int,int>(1,10));
m.insert(pair<int,int>(2,20));
m.insert(pair<int,int>(3,30));
m.insert(pair<int,int>(4,40));
for(map<int,int>::iterator it=m.begin();it!=m.end();it++){
cout<<(*it).first<<" "<<(*it).second<<endl;		//访问map容器中的元素
}

10.2 大小和交换

m.empty();	//判断容器是否为空
m.size();	//返回容器中元素个数
m.swap(s1);	//交换两个容器的元素

10.3 插入和删除

m.insert(elem);		//在容器中插入元素
m.clear();			//清除所有元素
m.erase(pos);		//删除pos迭代器所指的元素，返回下一个元素的迭代器
m.erase(beg,end);	//删除区间[beg，end)的所有元素，返回下一个元素的迭代器
m.erase(key); 		//删除容器中值为key的元素

四种插入方式：

m.insert(pair<int,int>(1,10));
m.insert(make_pair(2,20));
m.insert(map<int,int>::value_type(3,30));
m[4]=40;

10.4 查找和统计

m.find(key);		//查找key元素是否存在，返回该元素的迭代器
m.count(key);		//统计key元素的个数

• 点赞
• 收藏
• 分享
• 文章举报

今日伊始 发布了25 篇原创文章 · 获赞 0 · 访问量 152 私信 关注