C++基本容器操作（2021年暑假稿子 待更新）

最新推荐文章于 2022-08-14 13:39:53 发布
最新推荐文章于 2022-08-14 13:39:53 发布
阅读量897 收藏 4
点赞数 1
分类专栏： C++知识点 文章标签： c++ visual studio cocos2d
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52818172/article/details/120510238
版权

C++容器

注意问题中是我还不懂的问题

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;
}

map容器

期鹤飞天地
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++容器基本操作整理
m19166的博客
04-07 178
赋值操作种类与Vector相同。
c++容器操作
dzy521的博客
03-11 907
本文将介绍c++中所有容器共同的部分 1.类型别名： （1）.iterator表示此容器的迭代器类型 （2）.const_iterator可以读元素但是不能修改元素的迭代器类型 （3）.size_type无符号整数类型，足够储存这种容器类型最大可能的容器大小 （4）.difference_type带符号整型数，足够保存两个迭代器之间的距离 （5）.value_type元素类型 （6）.reference元素的左值类型，与value_type&含义相同 （7）.const_refere
C++容器用法整理
wings0728的博客
12-10 184
文章目录Vector声明定义举例操作增定义举例删定义举例 Vector 声明 定义 std::vector<变量类型> 变量名 //不定长 std::vector<变量类型> 变量名(数量) //定义一定数量长度的vector std::vector<变量类型> 变量名(数量, 初始值) //定义一定数量长度，并且每个都为初始值的vector std::vect...
C++中的容器与运用
weixin_43319685的博客
03-22 276
C++中的容器 在C++ STL中，定义了很多标准容器，容器主要是根据不同的数据结构进行搭建。主要的数据结构有： 数组类结构：vector、deque、array，内存是连续的，可以根据索引进行查找 链表类结构：list，由双向链表实现 树类结构：map、set、multimap、multiset，由红黑树实现 还有根据标准的容器结构：stack、queue、priority-queue 按照类...
c++常见容器操作
文洲的专栏
05-29 1365
总结下常见c++容器操作。   1.Vector、 list和 deque Vector是数组，List 是双端链表，deque时双向队列。分别引入vector/list/deque库。 vector、deque支持随机访问和迭代器偏移，list、deque支持双向访问，list只能自加自减。 增 push_back、insert push_front 【vector不可用】 re...
2021年c++题库选择题.docx
12-15
C++编程语言知识点总结 从给定的文件信息中，我们可以总结出以下C++编程语言相关知识点： 1. 标记符：在C++语言中，标记符是指变量、函数、数组、指针等名称。合法的标记符不能以数字开头，且不能是C++语言的...
C++STL中<vector>容器基本操作
01-26
帮助新学习STL的童鞋们了解容器
C++中 map的基本操作
01-20
map是一类关联式容器。它的特点是增加和删除节点对迭代器的影响很小，除了那个操作节点，对其他的节点都没有什么影响。对于迭代器来说，可以修改实值，而不能修改key。 2、map的功能 自动建立Key － value的对应。...
2024年C++ vector容器详解-面试常考.zip
最新发布
03-13
vector容器【2024年C++ vector容器详解-面试常考简介】 内容概要： 这篇博客为C++初学者提供了一个全面的vector容器理解指南，以通俗易懂的语言介绍了vector的基本操作、特性、注意事项以及面试中可能遇到的问题和...
C++顺序容器，容器适配器，关联容器的操作
10-18
包括顺序容器vector，string，list，forward，deque ，array；容器适配器stack，queue，priority_queue以及关联容器map，set，multimap，unordered_multimap等的增删查改操作。
C++ STL中容器的使用全面总结
热门推荐
算法改变人生
04-19 6万+
一、容器的定义        在数据存储上，有一种对象类型，它可以持有其它对象或指向其它对像的指针，这种对象类型就叫做容器。很简单，容器就是保存其它对象的对象，当然这是一个朴素的理解，这种“对象”还包含了一系列处理“其它对象”的方法。 二、容器的种类   1、顺序容器：是一种各元素之间有顺序关系的线性表，是一种线性结构的可序群集。顺序性容器中的每个元素均有固定的位置，除非用删除或插入的操
C++中的容器类详解
qingyue_bao的专栏
07-09 4371
原文出处：http://www.cublog.cn/u3/94667/showart_2302116.htmlC++中的容器类包括“顺序存储结构”和“关联存储结构”，前者包括vector，list，deque等；后者包括set，map，multiset，multimap等。若需要
C++ 容器的使用
weixinhum
05-04 1490
    在 C++ 编程中使用容器能更加方便的实现数据结构设计。下面将介绍几种常用容器的使用：vector容器（类似于数组而又有链表的一些属性，相对来说比数组要方便插入和弹出的操作）#include &lt;vector&gt;//包含头文件 using namespace std;vector&lt;myrect&gt; mybluerect;//定义一个类型为 myrect 的名字为 myb...
C++所有容器的详细使用介绍
qq_33177268的博客
08-14 1699
可以有控制台输入：https://www.onlinegdb.com/ 可以很强：https://godbolt.org/用 new 创建动态数组的替代品 在此头文件内，类型 vector 是一个定义于 namespace std 内的 template： 模板类 vector 类似于 string 类，也是一种动态数组。可以在运行阶段设置 vector 对象的长度，可在末尾附加新数据，还可以在中间插入新数据。 vector 构造 vector 非更易型操作 操作 描述 c.empty()
C++ 容器详解
weixin_53272394的博客
10-17 3201
首先说一下六大组件： 算法,容器,迭代器,仿函数(函数对象),分配器,适配器 简述： 线性容器: vector(向量): 好比C语言中数组 顺序表 seqtable (a)内存连续 支持[]运算符 下标访问 (b)动态内存管理 自动扩容 (c)通过分配器来管理动态内存 预分配内存空间 减少动态内存管理的额外开销 (d)可以随机位置做插入和删除，但只有在接近末尾进行插入和删除时才是高效的 预分配内存和初始化 vector v3(10); //10个int元素，初始值为0 vec
C++ STL基本容器的使用
conanswp的专栏
04-09 6万+
C++中有两种类型的容器：顺序容器和关联容器。顺序容器主要有vector、list、deque等。其中vector表示一段连续的内存，基于数组实现，list表示非连续的内存，基于链表实现，deque与vector类似，但是对首元素提供插入和删除的双向支持。关联容器主要有map和set。map是key-value形式，set是单值。map和set只能存放唯一的key，multimap和multiset可以存放多个相同的key。 容器类自动申请和释放内存，因此无需new和delete操作。
C++容器概述和序列式容器基本操作
程序人生
02-02 3077
容器是一些特定类型对象的集合，容器类分为序列式容器和关联容器两种。容器基本操作 容器类的一些基本操作如下图：定义和初始化    每个容器都定义了一个默认构造函数。除array之外，其他容器的默认构造函数都会创建一个指定类型的空容器，且都可以接受指定容器大小和元素初始值的参数。将一个容器初始化为另一个容器的拷贝    将一个新容器创建为另一个容器的拷贝的方法有两种：可以直接拷贝整个容器，或者拷贝由一...
C++常见容器类使用详解
Fighting_初心的博客
04-13 2480
    C++中有两种类型的容器：顺序容器和关联容器。    顺序容器主要有vector、list、deque。其中vector表示一段连续的内存，基于数组实现；list表示非连续的内存，基于链表实现；deque与vector类似，但是对首元素提供插入和删除的双向支持。    关联容器主要有map和set。map是key-value形式，set是单值。map和set只能存放唯一的key，multi...
c++ vector容器 最全教程
weixin_41874599的博客
06-08 717
#include <iostream> #include <vector> using namespace std; //vector 容器 vector容器是单口容器 //vector 容器提供正向，与反向的迭代器，如v.begin v.end 对应反向v.rbegin v.rend 也提供v.insert()在指定位置插入元素 //vector 在尾部进行操作 v.p...
c++ set容器基本操作
06-07
set容器的基本操作包括： 1. 插入元素：使用insert()函数向set容器中插入元素。插入元素的时间复杂度为O(log n)。 ```c++ #include #include int main() { std::set<int> s; s.insert(3); s.insert(1); s....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值