注意问题中是我还不懂的问题
string 容器
介绍string类(容器)
string是c++风格的字符串,本质上是一个类。
*string和char 的区别
- char* 是一个指针
- string是一个类,类内部封装了char* 管理这个字符串,是一个char*类型的容器
string类内部封装了很多成员方法
如: find copy delete replace insert 等方法
string 构造函数
#include<iostream>
#include<cstring>
using namespace std;
//有参构造 拷贝构造 默认构造(无参构造)
/*
string(); 创建一个空字符串
string(const char* s); 使用字符串 s 初始化
string(const string& str); 使用一个string对象初始化另一个string对象
string(int n,char c); 使用n个字符c初始化
*/
void test()
{
string s1;//默认构造 空字符串 这里没有进行初始化
const char *str="helo world0"; //使用字符串str初始化
string s2(str);
string s3(s2); //拷贝构造
string s4=(10,'a'); // 10个a
}
注意问题
问题
- string(const char* s);
- string(const string& str);
- string中单引号和双引号的区别
这两个函数要看懂,明白const char string& 的意思*
string 赋值操作
#include<iostream>
#include<cstring>
using namespace std;
/*
string& operator=(const char*s); // char *类型字符串,赋值给当前字符串
string& operator=(const string &s); //把字符串s赋给当前字符串
string& operator=(char s); //字符赋给当前的字符串
string& assign(const char *s); //把字符串s赋给当前的字符串
string& assign(conat char *s,int n); //把字符串s的前n个字符赋给当前的字符串
string& assign(const string &s); //把字符串s赋给当前的字符串
string& assign(int n,char c); //用n个字符c赋给当前的字符串
*/
void test()
{
string str1;
str1="hello world";
cout<<"str1="<<str1<<endl; //char *类型字符串,赋值给当前字符串
string str2;
str2=str1;
cout<<"str2="<<str1<<endl; //把字符串s赋给当前字符串
string str3;
str3='a';
cout<<"str3="<<str1<<endl; //字符赋给当前的字符串
string str4;
str4.assign("hello c++");
cout<<"str4="<<str4<<endl; //把字符串s赋给当前的字符串
string str5;
str5.assign("hello c++",5); //把字符串的前5个字符赋给当前的字符串
cout<<"str5="<<str5<<endl;
string str6;
str6.assign(str5);
cout<<"str6="<<str6<<endl; //把字符串s赋给当前的字符串
string str7;
str7.assign(10,'w');
cout<<"str6="<<str6<<endl; //用n个字符c赋给当前的字符串
}
int main()
{
test();
return 0;
}
注意问题
注意:
- operator 运算符号,操作
- assign 分配
知道这俩个单词的中文,要更好理解
问题
- 已经有operator,为什么还需要assign.
string 字符串连接
#include<iostream>
#include<cstring>
using namespace std;
/*
string& operator+=(const char* str); //重载+=操作符
string& operator+=(const char c); //重载+=操作符
string& operator+=(const string& str); //重载+=操作符
string& append(const char *s); //把字符串s连接到当前字符串结尾
string& append(const char *s,int n); //把字符串s的前n个字符连接到当前字符串结尾
string& append(const string &s); //同operator+=(const string& str)
string& append(const string &s,int pos,int n); //字符串s中从pos开始的n个字符连接到字符串结尾
*/
void test()
{
string str1="我";
str1+="爱玩游戏";
cout<<"str1="<str1<<endl; //加一个字符串 char *
str1+=":";
cout<<"str1="<<str1<<endl;//加一个字符
string str2="LOL"; //加一个字符串 string
str1+=str2;
cout<<"str1="<<str1<<endl;
string str3="I";
str3.append("LOVE");
cout<<"str3="<<str3<<endl; //把字符串s连接到当前字符串结尾
str3.append("GAME abcde",4); //把字符串s的前4个字符连接到当前字符串结尾
cout<<"str3="<<str3<<endl;
str3.append(str2);
cout<<"str3="<<str3<<endl; //同operator+=(const string& str)
str3.append(str2,0,3);
cout<<"str3="<<str3<<endl; //字符串s中从pos开始的n个字符连接到字符串结尾
}
int main()
{
test();
return 0;
}
注意问题
注意:
- operator+= 加号相当于追加
- append 附加 附上
问题:暂时没有
string 字符串查找和替换
#include<iostream>
#include<string>
using namespace std;
/*
int find(const string& str,int pos=0)const; //查找str第一次出现位置,从pos开始查找(默认情况下为0)
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=npos)const; //查找str最后一次位置,从pos开始查找
int rfind(const char* s,int pos=npos)const; //查找s第一次出现位置,从pos开始查找
int rfind(const char* s,int pos,int n)const; //从pos查找s的前n个字符最后一次位置
int rfind(const char* s,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
*/
// 查找
void test()
{
string str1="abcdefg";
int pos=str1.find("de");
cout<<"pos="<<pos<<endl; //字符串下标从0开始
}
//替换
void test1(){
string str1="abcdef";
str1.replace(1,3,"1111");
cout<<"str1="<<str1<<endl;
}
int main()
{
test();
test1();
return 0;
}
注意问题
注意:
- rfind和find的区别,rfind从右往左查找,find从左往右查找 find是找到第一个为止,rfind是找到字符的最后一个停止
- string str1=“abcdef”; str1.replace(1,3,“1111”)); 注意这两句代码是把abc替换为1111,四个字符换三个字符
string 字符串比较
代码如下:
#include<iostream>
#include<cstring>
using namespace std;
/*
//字符串比较
int compare(const string &s)const;
int compare(const char *s)const;
*/
void test()
{
string str1="hello";
string str2="hello";
if(str1.compare(str2)==0)//依次比较 ASCII码 怎么比较中文 一般用来比较两个字符串之间是否相等
{
cout<<"str1等于str2"<<endl;
}
else if(str1.compare(str2)>0)
{
cout<<"str1大于str2"<<endl;
}
else(str1.compare(str2)<0)
{
cout<<"str1小于str2"<<endl;
}
}
int main()
{
test();
return 0;
}
注意问题:
注意:注意是大于0,还是小于0,还是等于0。
string字符串存取
代码如下:
#include<iostream>
#include<cstring>
using namespace std;
/*
字符串存取
char& operator[](int n);<<
char& at(int n);
*/
void test()
{
string str="hello world";
for(int i=0;i<str.size();i++)
{
cout<<str[i]<<" "; //通过[]访问单个字符
}
cout<<endl;
for(int i=0;i<str.size();i++)
{
cout<<str.at(i)<<" "; //通过at方式访问单个字符
}
str[0]='x'; //通过[]修改单个字符
cout<<"str="<<str<<endl;
str.at(i)='x';//通过at方式访问单个字符
cout<<"str="<<str<<endl;
}
int main()
{
test();
return 0;
}
string字符串插入和删除
代码如下:
#include<iostream>
#include<cstring>
using namespace std;
/*
string& insert(int pos,const char* s) //插入字符串
string& insert(int pos,const string& str) //插入字符串
string& insert(int pos,int n,char c) //在指定位置插入n个字符串c
string& erase(int pos,int n=npos) //删除pos开始的n个字符
*/
void test()
{
string str="hello";
str.insert(1,"111"); //插入字符 注意hello 中的h是第0个位置
cout<<"str="<<str<<endl;
str.erase(1,3);
cout<<"str="<<str<<endl;
}
int main()
{
test();
return 0;
}
vector容器
概括
注意
- vector与普通数组的区别:数组是静态空间,而vector可以动态扩展
- 动态扩展:并不是在原空间之后续接新空间,而是找更大的内存空间,然后将原数据拷贝新空间,释放原空间
- vector容器的迭代器是支持随机访问的迭代器
问题
v.rend(),v.begin(), v.rbegin(),v.end() 迭代器的区别
v.begin()指向第一个元素,v.end()指向最后一个元素的下一个
vector构造函数
代码如下:
#include<iostream>
#include<vector>
using namespace std;
/*
vector<T> v; //采用模板实现类实现,默认构造函数
vector(v.begin(),v.end()); // 将v[begin(),end())区间中的元素拷贝给本身
vector(n,elem); //构造函数将n个elem拷贝给本身
vector(const vector &vec); //拷贝构造函数
*/
void printVector(vector<int> &v){
for(vector<int>::iterator it=v.begin();it!=v.end();it++){
cout<<*it<<" ";
}
cout<<endl;
}
//vector容器构造
void test(){
vector<int> v1; //默认构造 无参构造
for(int i=0;i<10;i++){
v1.push_back(i);
}
printVector(v1);
//通过区间方式进行构造
vector<int> v2(v1.begin(),v1.end());
printVector(v2);
//n个elem方式构造
vector<int> v3(10,100);
printVector(v3);
//拷贝构造
vector<int> v4(v3);
printVector(v4);
}
int main()
{
test();
return 0;
}
vector 赋值操作
#include<iostream>
#include<vector>
using namespace std;
/*
vector& operator=(const vector &vec); //重载等号操作符
assign(beg,end); //将[beg,end)中的数据拷贝赋值给本身
assign(n,elem); //将n个elem拷贝赋值给本身
*/
void printVector(vector<int> &v){
for(vector<int>::interator it=v.begin();it!=v.end();it++){
cout<<*it<<" ";
}
cout<<endl;
}
//vector赋值
void test(){
vector<int> v1;
for(int i=0;i<10;i++){
v1.push_back(i);
}
printVector(v1);
//赋值
vector<int> v2;
v2=v1;
printVector(v2);
//assign 区间赋值
vector<int> v3;
v3.assign(v1.begin(),v1.end());
printVector(v3);
//n个elem方式赋值
vector<int> v4;
v4.assign(10,100);
printVector(v4);
}
int main()
{
test();
system("pause");
return 0;
}
对vector容量和大小的操作
代码如下:
#include<iostream>
#include<vector>
using namespace std;
/*
empty(); //判断容器是否为空、
capacity(); //容器的容量
size(); //返回容器内元素的个数
resize(int num); //重新指定容器的长度为num,若容器变长,则以默认值填充新位置,
//若容器变短,则末尾超出容器长度的元素被删除
resize(int num,elem) //重新指定容器的长度为num,若容器变长,则以elem填充新位置,
//若容器变短,则末尾超出容器长度的元素被删除
*/
void printVector(vector<int> &v){
for(vector<int>::iterator it=v.begin();it!=v.end();it++){
cout<<*it<<" ";
}
cout<<endl;
}
void test()
{
vector<int> v1;
for(int i=0;i<10;i++){
v1.push_back(i);
}
printVector(v1);
if(v1.empty()) //为真,代表容器为空
{
cout<<"v1为空"<<endl;
}
else{
cout<<"v1不为空"<<endl;
cout<<"v1的容量为:"<<v1.capacity()<<endl;
cout<<"v1的大小为:"<<v1.size() <<endl;
}
//重新指定大小
v1.resize(15); //如果重新指定的比之前长,以默认值 0填充新的位置
printVector(v1);
v1.resize(15,100); //利用重载版本,指定需要填充的值
printVector(v1);
v1.resize(5); //超出的长度删除了
printVector(v1);
}
int main()
{
test();
return 0;
}
vector容器的插入和删除
代码如下:
#include<iostream>
#include<vector>
using namespace std;
/*
push_back(ele); //尾部插入元素ele
pop_back(); //删除最后一个元素
insert(const_iterator pos,ele); //迭代器指向位置pos插入元素ele
insert(const_iterator pos,int count,ele); //迭代器指向位置pos插入count个元素ele
erase(const_iterator pos); //删除迭代器指向的元素
erase(const_iterator start,const_iterator end); //删除迭代器从start到end之间的元素
clear(); //删除所有元素
*/
void printVector(vector<int> &v){
}
void test(){
vector<int> v1;
//尾插
v1.push_back(10);
v1.push_back(20);
v1.push_back(30);
v1.push_back(40);
v1.push_back(50);
//遍历
printVector(v1);
//尾删
v1.pop_back();
printVector(v1);
//插入
v1.insert(v1.begin(),100); //在某个特定位置插入
printVector(v1);
v1.insert(v1.begin(),2,1000); //起始位置,个数,数字
printVector(v1);
//删除
v1.erase(v1.begin()); //删除一个特定位置
printVector(v1);
//清空
v1.erase(v1.begin(),v1.end()); //起始位置和结束位置
printVector(v1);
}
int main()
{
test();
return 0;
}
vector容器的数据存取
代码如下:
#include<iostream>
#include<vector>
using namespace std;
/*
at(int dex); //返回索引idx所指的数据
operator[int idx]; //返回索引idx所指的数据
front(); //返回容器中的第一个数据元素
back(); //返回容器中的最后一个元素
*/
void test(){
vector<int> v1;
for(int i=0;i<10;i++){
v1.push_back(i);
}
//利用[]方式访问元素
for(int i=0;i<v1.size();i++){
cout<<v1[i]<<" ";
}
cout<<endl;
//利用at方式访问元素
for(int i=0;i<v1.size();i++){
cout<<v1.at(i)<<" ";
}
cout<<endl;
//获取最后一个元素和第一个元素
cout<<"v1的第一个元素为:"<<v1.front()<<endl;
cout<<"v1的最后一个元素为:"<<v1.back()<<endl;
}
int main()
{
test();
return 0;
}
vector 容器的互换
代码如下:
#include<iostream>
#include<vector>
using namespace std;
//两个容器之间的互换
/*
swap(vec); //容器之间的互换
*/
void printVector(vector<int> &v){
for(vector<int>::iterator it=v.begin();it!=v.end();it++){
cout<<*it<<" ";
}
cout<<endl;
}
void test(){
vector<int> v1;
for(int i=0;i<10;i++){
v1.push_back(i);
}
printVector(v1);
vector<int> v2;
for(int i=10;i>0;i--){
v2.push_back(i);
}
printVector(v2);
//v1和v2交换
cout<<"交换后:"<<endl;
v1.swap(v2);
printVector(v1);
printVector(v2);
}
//实际用途
//巧用swap可以收缩内存空间
void test1(){
vector<int> v;
for(int i=0;i<10000;i++){
v.push_back(i);
}
cout<<"v的容量为:"<<v.capacity() <<endl;
cout<<"v的大小为:"<<v.size() <<endl; //size会比容量capacity小
v.resize(3); //重新指定大小
cout<<"v的容量为:"<<v.capacity() <<endl;
cout<<"v的大小为:"<<v.size() <<endl; //size变为3,capacity不变
// 巧用swap收缩内存
vector<int>(v).swap(v); //vector<int>(v) 匿名对象size和capacity都为3
//匿名对象 执行完代码后 系统会回收空间 利用v现在的空间来匿名初始化对象
cout<<"v的容量为:"<<v.capacity() <<endl;
cout<<"v的大小为:"<<v.size() <<endl; //容量capacity和size都变成了3
}
int main()
{
test();
test1();
return 0;
}
//swap可以使两个容器互换,可以达到实用的收缩内存的效果
注意问题
问题:
- 匿名对象 vector(v).swap(v);
vector预留空间
代码如下:
#include<iostream>
#include<vector>
using namespace std;
/*
reserve(int len); //容器预留len个元素长度,跟resize不同预留位置不初始化,元素不可访问
*/
void test(){
vector<int> v;
//防止num次数过大,可以利用reserve预留空间
v.reserve(100000);
int num=0;
int *p=NULL;
for(int i=0;i<100000;i++){
v.push_back(i);
if(p!=&v[0]){
p=&v[0]; //每次开辟空间后,原来的指向首地址的指针失效(vector动态扩展是重新换一个空间),必须重新让其指向首地址
num++; //计算电脑开辟空间的次数,如果使用reserve,那么次数就只有一次
}
}
}
int main(){
test();
return 0;
}
//减少vector在动态扩展容量时的扩展次数
注意问题
注意
- reserve(int len)是减少vector在动态扩展容量是的扩展次数
deque容器
介绍deque容器
基本概念:
- 双端数组,可以对头端进行插入删除操作
deque和vector的区别:
- vector对于头部的插入删除效率低,数据量越大,效率越低
- deque相对而言,对于头部的插入删除速度比vector快
- vector访问元素时的速度会比deque快,这和两者内部实现有关
deque的内部原理(决定了deque的速度慢,初学不适宜了解过深,慢慢往后学)
中控器
注意问题
问题: vector的速度为什么比deque快
注意
- push_front(),pop_front() 头部插入和删除
- push_back(),pop_back() 尾部插入和删除
- begin(),front() 指向第一个元素,back()指向最后一个元素,end()指向最后一个元素的下一个元素
deque构造函数
代码如下:
#include<iostream>
#include<deque>
using namespace std;
//deque 构造函数
/*
deque<T> deqT; //默认构造形式
deque(beg,end); //构造函数将[beg,end)中的元素拷贝给本身
deque(n,elem); //构造函数将n个elem拷贝给本身
deque(const deque &deq); //拷贝构造函数
*/
void printDeque(const deque<int> &d){
for(deque<int>::const_iterator it=d.begin();it!=d.end();it++){
cout<<*it<<" "; //用了const迭代器之后,容器中的数据就不可以修改了,只能读
}
cout<<endl;
}
void test()
{
deque<int> d1;
for(int i=0;i<10;i++){
d1.push_back(i);
}
printDeque(d1);
deque<int> d2(d1.begin(),d1.end()); //区间元素拷贝
printDeque(d2);
deque<int> d3(10,100); //n个elem拷贝
printDeque(d3);
deque<int> d4(d3); //拷贝构造
printDeque(d4);
}
int main()
{
test();
return 0;
}
注意问题
注意:
- deque deqT; //默认构造形式
- deque(beg,end); //构造函数将[beg,end)中的元素拷贝给本身
- deque(n,elem); //构造函数将n个elem拷贝给本身
- deque(const deque &deq); //拷贝构造函数
deque 赋值操作
代码如下:
#include<iostream>
#include<deque>
using namespace std;
//deque赋值操作
/*
deque& operator=(const deque &deq) //重载等号操作符
assign(beg,end); //将[beg,end)区间中的数据拷贝赋值给本身
assign(n,elem); //将n个elem拷贝赋值给本身
*/
void printDeque(const deque<int> &d){
for(deque<int>::const_iterator it=d.begin();it!=d.end();it++){
cout<<*it<<" ";
}
cout<<endl;
}
void test()
{
deque<int> d1;
for(int i=0;i<10;i++){
d1.push_back(i);
}
printDeque(d1);
deque<int> d2;
d2=d1; //重载等号操作符
printDeque(d2);
deque<int> d3;
d3.assign(d1.begin(),d1.end()); //区间赋值
printDeque(d3);
deque<int> d4;
d4.assign(10,100); //将n个elem拷贝赋值给本身
printDeque(d4);
}
int main()
{
test();
return 0;
}
注意问题
注意
- deque& operator=(const deque &deq) //重载等号操作符
- assign(beg,end); //将[beg,end)区间中的数据拷贝赋值给本身
- assign(n,elem); //将n个elem拷贝赋值给本身
deque 容量大小的操作
代码如下:
#include<iostream>
#include<deque>
using namespace std;
//deque容量大小的操作
//没有容量的概念
/*
deque.empty(); //判断容器是否为空
deque.size(); //返回容器中元素的个数
deque.resize(num); //重新指定容器的长度为num,若容器变长,则以默认值填充新位置,
//若容器变短,则末尾超出容器长度的元素被删除
deque.resize(num,elem); //重新指定容器的长度为num,若容器变长,则以elem填充新位置,
//若容器变短,则末尾超出容器长度的元素被删除
*/
void printDeque(const deque<int> &d){
for(deque<int>::const_iterator it=d.begin();it!=d.end();it++){
cout<<*it<<" ";
}
cout<<endl;
}
void test(){
deque<int> d1;
for(int i=0;i<10;i++){
d1.push_back(i);
}
printDeque(d1);
if(d1.empty()){
cout<<"d1为空"<<endl;
}
else{
cout<<"d1不为空"<<endl;
cout<<"d1的大小为:"<<d1.size()<<endl;
}
//重新指定大小
d1.resize(15,1);
printDeque(d1);
d1.resize(15); //超出的部分用0代替
printDeque(d1);
}
int main()
{
test();
return 0;
}
//deque没有容量的概念
//判断是否
注意问题
注意:
- deque.empty(); //判断容器是否为空
- deque.size(); //返回容器中元素的个数
- deque.resize(num); //重新指定容器的长度为num,若容器变长,则以默认值填充新位置, //若容器变短,则末尾超出容器长度的元素被删除
- deque.resize(num,elem); //重新指定容器的长度为num,若容器变长,则以elem填充新位置,
//若容器变短,则末尾超出容器长度的元素被删除
deque的插入和删除
代码
#include<iostream>
#include<deque>
using namespace std;
//deque插入和删除
/*
//两端插入操作
push_back(elem); //在容器尾部添加一个数据
push_front(elem); //在容器头部插入一个数据
pop_back(); //删除容器内的最后一个数据
pop_front(); //删除容器内的第一个数据
//指定位置操作
insert(pos,elem); //在pos位置
insert(pos,n,elem);
insert(pos,beg,end);
clear();
erase(beg,end);
erase(pos);
*/
void printDeque(const deque<int> &d){
for(deque<int>::const_iterator it=d.begin();it!=d.end();it++){
cout<<*it<<" "; //用了const迭代器之后,容器中的数据就不可以修改了,只能读
}
cout<<endl;
}
void test()
{
deque<int> d1;
//尾插
d1.push_back(10);
d1.push_back(20);
//头插
d1.push_back(100);
d1.push_back(200);
printDeque(d1);
d1.pop_back(); //尾删
d1.pop_front(); //头删
d1.insert(d1.begin(),1000); //在开始插入1000;
d1.insert(d1.begin(),2,1000); //在一个位置插入两个1000
}
int main()
{
test();
return 0;
}
deque 数据存取
代码如下:
#include<iostream>
#include<deque>
using namespace std;
//deque容器数据存取
/*
at(int idx) //返回索引idx所指的数据
operator[int idx]; //返回索引idx所指的数据
front(); //返回容器中第一个数据元素
back(); //返回容器中最后一个数据元素
*/
void test(){
deque<int> d;
d.push_back(10);
d.push_back(20);
d.push_back(30);
d.push_front(100);
d.push_front(200);
d.push_front(300);
//通过[]方式访问元素
for(int i=0;i<d.size();i++){
cout<<d[i]<<" ";
}
cout<<endl;
//通过at方式访问元素
for(int i=0;i<d.size();i++){
cout<<d.at(i)<<" ";
}
cout<<endl;
cout<<"front"<<d.front()<<endl; //返回容器中第一个数据元素
cout<<"back"<<d.back()<<endl; //返回容器中最后一个数据元素
}
int main()
{
test();
return 0;
}
注意问题
注意:
- 使用迭代器来访问数据元素时,begin(),和·end()都需要当作指针来用即*v.begin()和(星号)(v.end()-1)来访问头尾元素
- 使用at和【】方式来访问数据元素
deque 排序(重点 vector中没有)
- 利用算法对deque容器进行排序
算法
- sort(iterator beg,iterator end) //对beg和end区间内元素进行排序
代码如下:
#include<iostream>
#include<deque>
#include<algorithm>
using namespace std;
void printDeque(const deque<int> &d){
for(deque<int>::const_iterator it=d.begin();it!=d.end();it++){
cout<<*it<<" ";
}
cout<<endl;
}
//deque容器排序
void test(){
deque<int> d1;
d1.push_back(10);
d1.push_back(20);
d1.push_back(30);
d1.push_front(100);
d1.push_front(200);
d1.push_front(300);
printDeque(d1);
//默认排序规则 从小到大
//对于支持随机访问的迭代器的容器,都可以利用sort算法对其进行排序
//vector容器也可以利用sort进行排序
sort(d1.begin(),d1.end());
cout<<"排序后:"<<endl;
printDeque(d1);
}
int main(){
test();
return 0;
}
注意问题
注意:
- 对于支持随机访问的迭代器的容器,都可以利用sort算法对其进行排序
- vector容器也可以利用sort进行排序
stack 容器
概念:
- stack是一种后进先出的数据结构,只有一个出口
注意: - 没有遍历行为
stack容器的常用接口
构造函数
- stack stk; //stack模板类实现,默认构造函数
- stack(const stack &stk); //拷贝构造函数
赋值操作
- stack& operator=(const stack &stk); //重载等号操作符
数据存取
- push(elem);
- pop(); //从栈顶移除第一个元素
- top(); //返回栈顶元素
大小操作
- empty(); //判断堆栈是否为空
- size(); //返回栈的大小
代码如下:
#include<iostream>
#include<stack>
using namespace std;
void test(){
stack<int> s;
s.push(10);
s.push(20);
s.push(30);
s.push(40);
while(!s.empty()){
//查看栈顶元素
cout<<s.top()<<endl;
s.pop(); //出栈
}
//栈的大小
cout<<s.size()<<endl; //全出栈后,栈的大小为0
}
int main(){
test();
return 0;
}
queue容器
概念:
- queue是一种先进先出的数据结构,它有两个出口
注意 - 不允许有遍历行为
queue 常用接口
构造函数
- queue que; //采用模板类实现,默认构造函数
- queue(const queue &que); //拷贝构造函数
赋值操作
- queue& operator=(const queue &que); //重载等号操作符
数据存取
- push(elem); //往队尾移除第一个元素
- pop(); //从对头移除第一个元素
- back(); //返回最后一个元素
- front(); //返回第一个元素
大小操作
- empty(); //判断堆栈是否为空
- size(); //返回栈的大小
代码如下:
#include<iosstream>
#include<queue>
#include<string>
using namespace std;
//队列的常用接口
class Person{
public:
Person(string name,int age);
{
this->Name=name;
this->Age=age;
}
string Name;
int Age;
};
void test(){
queue<int> q;
Person p1("Jack",30);
Person p2("Alun",30)
Person p3("Alice",30);
Person p4("Alu",30);
q.push(p1);
q.push(p2);
q.push(p3);
q.push(p4);
while(!q.empty()){
cout<<"对头元素"<<q.front().Name<<" "<<q.front().Age<<endl;
cout<<"对尾元素"<<q.back().Name<<" "<<q.back().Age<<endl;
q.pop();
}
cout<<"队列大小:"<<q.size() <<endl;
}
int main(){
test();
return 0;
}
list容器
概念:数据结构中的链表,物理存储单元非连续的存储结构
注意:
- stl中的链表是一个双向循环链表
- 遍历速度没有数组快
- 占用空间比数组大,虽然链表灵活,但空间和时间额外消耗大
- 链表的存储空间不是连续的内存空间,因此list中的迭代器只支持前移和后移,属于双向迭代器
- 插入和删除操作都不会造成原有list迭代器失效,这在vector是不成立的,vector的动态扩展是另外开辟空间
基本操作基本跟上面那些容器没有什么区别
set/multiset容器
概念:
-
所有元素在插入时自动排序
本质: -
set/multiset属于关联式容器,底层结构是二叉树
set和multiset的区别: -
set中不允许有重复的元素,不可以插入重复数据
-
set插入数据的同时会返回插入结果,表示插入是否成功
-
multiset允许容器中有重复的元素,不会检测数据,因此可以插入重复数据
set常用接口
构造函数
- set st; //默认构造函数
- set(const set &st); //拷贝构造函数
赋值操作
- set& operatort=(const set &st); //重载等号操作符
大小和交换
- size(); //返回容器中元素的数目
- empty(); //判断容器是否为空
- swap(st); //交换两个集合容器
插入和删除
- insert(elem); //在容器中插入元素
- clear(); //清除所有元素
- erase(pos); //清除pos迭代器所指的元素,返回下一个元素的迭代器
- erase(beg,end); //删除区间【beg,end)的所有元素,返回下一个元素的迭代器
- erase(elem); //删除容器中值为elem的元素
查找和统计
- find(key); //查找key是否存在,如果存在,返回该健的元素的迭代器;若不存在,返回set.end();
- count(key); //统计key的元素的个数
set容器内部指定排序规则
set容器自定义数据类型排序规则
pair对组
概念
- 成对出现的数据,利用对组可以返回两个数据
pair对组的创建
对组的创建
- pair<type,type> p (value1,value2);
- pair<type,type> p=make_pair(value1,value2);
代码如下:
#include<iostream>
#include<vector>
using namespace std;
void test()
{
//第一种方式
pair<string,int> p("Tom",20);
cout<<"姓名"<<p.first<<"年龄"<<p.second<<endl; //第一个数据和第二个数据
//第二种方式
pair<string,int> p2=make_pair("Jerry",30);
cout<<"姓名"<<p2.first<<"年龄"<<p2.second<<endl;
}
int main()
{
test();
return 0;
}