1. 技术文章
  2. C++容器篇

C++容器篇

由 若如初见. 提交于 2020-01-24 01:52:32

C++容器篇

一：vector向量（动态数组）

使用容器的步骤：
1.包含相关头文件
2.实例化一个对象

#include<iostream>
#include<string>
#include<vector>//包含相关头文件
using namespace std;
int main()
{	 
	//实例化对象分为有参和无参两种：
	//1.无参
	vector<string> strVector;
	//2.有参
	vector<int> intVector(3);     //动态数组的长度
	return 0;
}

1.有参实例化对象时，参数规定了向量的大小即动态数组的长度，这时进行插入时可以采用数组的方式进行插入。但是，需要注意的是当超过传入的容量后，只能通过成员函数的方式进行插入。
2.无参实例化对象时，只能通过成员函数的方式进行插入。

基本方法：

（一）：插入操作：push_back();(尾部插入)
（二）：删除操作：pop_back();(尾部删除)

万金油参数：

（一）size();//当前容器数据个数
（二）empty();//当前容器是否为空

#include<iostream>
#include<string>
#include<vector>//包含相关头文件
using namespace std;
int main()
{	 
	//实例化对象分为有参和无参两种：
	//1.无参
	vector<string> strVector;
	//只能通过成员函数去操作
	strVector.push_back("tust");
	//2.有参
	vector<int> intVector(3);     //动态数组的长度
	//通过数组的方式插入：
	intVector[0] = 1;
	intVector[1] = 2;
	intVector[2] = 3;
	//intVector[3] = 3;  //超过容量只能够通过成员函数的方式进行插入
	intVector.push_back(4);
	for (size_t i = 0; i < intVector.size(); i++)//size_t => unsigned int 
	{
		cout << intVector[i] << "\t";
	}
	cout << endl;
	return 0;
}

操作自定义类型：

（一）：创建数据类型为类的向量：
下面有一个MM类，我们创建一个数据类型为MM的vector。

//自定义类型：
class MM
{
public:
	MM(string name, int age) :name(name), age(age) {}
	void print()
	{
		cout << name << " " << age << endl;
	}
protected:
	int age;
	string name;
};

	//操作：
	//3.操作自定义类型
	vector<MM> mmVector;//创建数据类型为类的向量
	mmVector.push_back(MM("xixi", 18));
	mmVector.push_back(MM("haha", 19));
	mmVector.push_back(MM("enen", 20));
	for (int i = 0; i < mmVector.size(); i++)
	{
		mmVector[i].print();
	}

（二）：向量作为类的成员函数：

//向量作为类的成员函数
class object
{
public:
	object(vector<int> data) :data(data) {}
	void print()
	{
		for (int i = 0; i < data.size(); i++)
		{
			cout << data[i] << "\t";
		}
	}
protected:
	vector<int> data;
};

//实现：
	object myObject(intVector); 
	myObject.print();
	cout << endl;

(三)：向量作为函数参数：

//向量作为函数参数：
void print(vector<string> strVector)
{
	for (int i = 0; i < strVector.size(); i++)
	{
		cout << strVector[i] << endl;
	}
}

//实现：
	strVector.push_back("artificial");
	print(strVector);//将向量实例化的对象strVector传给函数print

(四)：vector再嵌套模板：

//vector再嵌套模板：
template<typename T>
class dataInfo
{
public:
	dataInfo(vector<T> data) :data(data) {}
	void print()
	{
		for (int i = 0; i < data.size(); i++)
		{
			cout << data[i] << "\t";
		}
	}
protected:
	vector<T> data; 
};

//实现：
	strVector.push_back("intelligence");
	dataInfo<string> mydataInfo(strVector);
	mydataInfo.print();

示例程序：

#include<iostream>
#include<string>
#include<vector>
using namespace std;
/*
	vector:向量（动态数组）
		基本操作：
		插入：
			 push_back();//尾部插入
			 //注意：没有push_front();
		删除：
			 pop_back();//尾部删除
		万金油参数：
			size();//当前容器数据的个数
			empty();//当前容器是否为空
	使用容器的步骤：
		1.包含相关文件头文件
		2.实例化一个对象
*/
class MM
{
public:
	MM(string name, int age) :name(name), age(age) {}
	void print()
	{
		cout << name << " " << age << endl;
	}
protected:
	int age;
	string name;
};

class object
{
public:
	object(vector<int> data) :data(data) {}
	void print()
	{
		for (int i = 0; i < data.size(); i++)
		{
			cout << data[i] << "\t";
		}
	}
protected:
	vector<int> data;
};

void print(vector<string> strVector)
{
	for (int i = 0; i < strVector.size(); i++)
	{
		cout << strVector[i] << endl;
	}
}

template<typename T>
class dataInfo
{
public:
	dataInfo(vector<T> data) :data(data) {}
	void print()
	{
		for (int i = 0; i < data.size(); i++)
		{
			cout << data[i] << "\t";
		}
	}
protected:
	vector<T> data; 
};
int main()
{
	 
	//1.无参
	vector<string> strVector;
	//只能通过成员函数去操作
	strVector.push_back("tust");


	//2.有参
	vector<int> intVector(3);     //动态数组的长度
	intVector[0] = 1;
	intVector[1] = 2;
	intVector[2] = 3;
	//intVector[3] = 3;  //超过容量只能够通过成员函数的方式进行插入
	intVector.push_back(4);
	for (size_t i = 0; i < intVector.size(); i++)
	{
		cout << intVector[i] << "\t";
	}
	cout << endl;
	intVector.pop_back();
	for (int i = 0; i < intVector.size(); i++)
	{
		cout << intVector[i] << "\t";
	}
	cout << endl;

	//3.操作自定义类型
	vector<MM> mmVector;
	mmVector.push_back(MM("xixi", 18));
	mmVector.push_back(MM("haha", 19));
	mmVector.push_back(MM("enen", 20));
	for (int i = 0; i < mmVector.size(); i++)
	{
		mmVector[i].print();
	}

	object myObject(intVector);
	myObject.print();
	cout << endl;

	strVector.push_back("artificial");
	print(strVector);

	//4.STL再嵌套模板
	strVector.push_back("intelligence");
	dataInfo<string> mydataInfo(strVector);
	mydataInfo.print();
	return 0;
}

运行结果：
在这里插入图片描述

二：list容器（双向链表）

list容器是一个双向链表

基本方法：

（一）：插入
1：push_back(); 头插
2：push_front(); 尾插
（二）：删除
1：pop_back(); 尾删
2：pop_front(); 头删
（三）：获取头结点元素：front(); 获取尾结点元素：back();
(四)：万金油函数
1：size(); list中元素个数
2：empty(); 判断list是否为空
1.删除打印：

#include<list>//包含list头文件
#include<iostream>
#include<string>
using namespace std;
int main()
{
	list<string> strList;//实例化list对象
	strList.push_back("artificial");//尾插
	strList.push_back("intelligence!");//尾插
	strList.push_front("tust");//头插
	//删除的方式去打印：（一经打印，链表的数据就丢失了。通常不采用这种方法去做）
	while (!strList.empty())
	{
		//从头往尾部进行打印
		cout << strList.front() << " ";
		strList.pop_front();
		//从尾往头部进行打印
		//cout << strList.back() << " ";
		//strList.pop_back();
	}
	system("pause");
	return 0;
}

2.迭代器打印：

#include<list>//包含list头文件
#include<iostream>
#include<string>
using namespace std;
int main()
{
	list<string> strList;//实例化list对象
	strList.push_back("artificial");//尾插
	strList.push_back("intelligence!");//尾插
	strList.push_front("tust");//头插
	//内置迭代  正向：begin()  end()     反向：rbegin()   rend()
	//const属性： cbegin() cend()
	list<string>::iterator iter;
	for (iter = strList.begin(); iter != strList.end(); iter++)
	{
		cout << *iter << " ";
	}
	system("pause");
	return 0;
}

3.list的应用小例：
用list来实现学生管理系统中的链表功能，其实现将变得更加简单。

//数据设计：
struct student
{
	string name;
	int age;
	student(string name, int age) :name(name), age(age) {}
};
class studentSystem
{
public:
	studentSystem() {}
	void input(student data)
	{
		studentData.push_back(data);
	}
	void print()
	{
		cout << "姓名" << "\t" << "年龄" << endl;
		list<student>::iterator iter;//利用迭代器进行打印
		for (iter = studentData.begin(); iter != studentData.end(); iter++)
		{
			cout << iter->name << "\t" << iter->age << endl;
		}
	}
protected:
	list<student> studentData;
};

//实现：
	studentSystem myStudent;
	myStudent.input(student("xixi", 18));
	myStudent.input(student("haha", 19));
	myStudent.input(student("enen", 20));
	myStudent.print();

示例程序：

#include<list>//包含list头文件
#include<iostream>
#include<string>
using namespace std;
/*
	基本方法：
		插入：
			push_back();//尾插
			push_front();//头插
			指定位置插入： find+insert进行操作
		删除：
			pop_back();//尾删除
			pop_front();//头删除
		获取头结点元素：front();
		获取尾结点元素：back();
		万金油函数：
			size();
			empty();
*/
struct student
{
	string name;
	int age;
	student(string name, int age) :name(name), age(age) {}
};
class studentSystem
{
public:
	studentSystem() {}
	void input(student data)
	{
		studentData.push_back(data);
	}
	void print()
	{
		cout << "姓名" << "\t" << "年龄" << endl;
		list<student>::iterator iter;
		for (iter = studentData.begin(); iter != studentData.end(); iter++)
		{
			cout << iter->name << "\t" << iter->age << endl;
		}
	}
protected:
	list<student> studentData;
};
int main()
{
	list<string> strList;//实例化list对象
	strList.push_back("artificial");
	strList.push_back("intelligence!");
	strList.push_front("tust");
	//内置迭代  正向：begin()  end()     反向：rbegin()   rend()
	//const属性： cbegin() cend()
	list<string>::iterator iter;
	for (iter = strList.begin(); iter != strList.end(); iter++)
	{
		cout << *iter << " ";
	}
	cout << endl;
	//删除的方式去打印：（一经打印，链表的数据就丢失了。通常不采用这种方法去做）
	while (!strList.empty())
	{
		//从头往尾部进行打印
		cout << strList.front() << " ";
		strList.pop_front();
		//从尾往头部进行打印
		//cout << strList.back() << " ";
		//strList.pop_back();
	}
	cout << endl;

	studentSystem myStudent;
	myStudent.input(student("xixi", 18));
	myStudent.input(student("haha", 19));
	myStudent.input(student("enen", 20));
	myStudent.print();
	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

三 : stack和queue

stack(栈):
基本操作：
push(element); 入栈
pop(); 出栈
top(); 获取栈顶元素
万金油函数：
size(); 当前栈中元素个数
empty(); 判断栈是否为空
示例程序：

#include<stack>
#include<iostream>
#include<string>
using namespace std;
int main()
{
	stack<string> myStack;
	myStack.push("我");
	myStack.push("爱");
	myStack.push("你");
	while (!myStack.empty())
	{
		cout << myStack.top() << " ";
		myStack.pop();
	}
	return 0;
}

运行结果：
在这里插入图片描述
queue（队列）：
基本操作：
push(element); 入队
pop(); 出队
front(); 获取队首元素
万金油函数：
size(); 当前队中元素个数
empty(); 队是否为空

程序示例：

#include<queue>
#include<iostream>
#include<string>
using namespace std;
int main()
{ 
	queue<string> myQueue;
	myQueue.push("我");
	myQueue.push("爱");
	myQueue.push("你");
	while (!myQueue.empty())
	{
		cout << myQueue.front() << " ";
		myQueue.pop();
	}
	return 0;
}

进制转换中栈的应用（短除法过程）：

#include<stack>
#include<iostream>
#include<string>
using namespace std;
int main()
{ 
	stack<int> D2B;//decimal（十进制） Binary（二进制） Octal（八进制） Hex（十六进制）
	int num = 200015;
	while (num)
	{
		D2B.push(num % 2);
		num /= 2;
	}
	cout << "十进制的200015的二进制数是:";
	while (!D2B.empty())
	{
		cout << D2B.top();
		D2B.pop();
	}
	return 0;
}

结果：
在这里插入图片描述

四：set集合和multiset多重集合

set的特点：

  • 自动排序，默认为从小到大
  • 不会出现重复的，一旦重复不做插入

（一）：基本数据类型

set集合会将插入的数据按着从小到大的顺序进行排序，如果遇到重复的数据则不进行插入

#include<set>
#include<iostream>
#include<string>
using namespace std;
int main()
{
	//1.基本数据类型	
	set<int> intSet;
	intSet.insert(1);
	intSet.insert(2);
	intSet.insert(6);
	intSet.insert(3);
	intSet.insert(2);
	set<int>::iterator iter;
	for (iter = intSet.begin(); iter != intSet.end(); iter++)
	{
		cout << *iter << "\t";
	}
	cout << endl;
	return 0;
}

运行结果：
在这里插入图片描述
（二）：自定义类型

注意：在用set集合操作自定义类型时，需要建立比较准则。（运算符重载小于号）

#include<set>
#include<iostream>
#include<string>
using namespace std;
//数据设计：
struct student
{
	string name;
	int age;
	float score;
	student(string name, int age, float score) :name(name), age(age), score(score) {}
};
//运算符重载建立比较准则：
bool operator<(student object1, student object2)//重载后运算符 < 用name进行比较	
{
	return object1.name < object2.name;
}
int main()
{
	//2.自定义类型
	set<student> myStudent;
	myStudent.insert(student("xixi", 18, 90.8f));
	myStudent.insert(student("enen", 19, 78.0f));
	myStudent.insert(student("haha", 20, 67.7f));

	set<student>::iterator pMove;
	cout << "姓名" << "\t" << "年龄" << "分数" << endl;
	for (pMove = myStudent.begin(); pMove != myStudent.end(); pMove++)
	{
		cout << pMove->name << "\t" << pMove->age << "\t" << pMove->score << endl;
	}
	return 0;
}

运行结果：
在这里插入图片描述
（三）：multiset多重集合

multiset在set的基础上允许重复数据的存在。

#include<set>
#include<iostream>
#include<string>
using namespace std;
int main()
{	
	//3.多重集合 multiset
	multiset<int> mulInt;
	mulInt.insert(1);
	mulInt.insert(2);
	mulInt.insert(3);
	mulInt.insert(2);
	mulInt.insert(1);
	multiset<int>::iterator mulIter;
	for (mulIter = mulInt.begin(); mulIter != mulInt.end(); mulIter++)
	{
		cout << *mulIter << "\t";
	}
	system("pause");
	return 0;
}

运行结果：
在这里插入图片描述

五：map映射

map映射
自带排序（从小到大），不重复（键唯一）
注意：出现重复时,保留最后一个。

数对类型：表示键和值的对应关系
template<typename A, typename B>
struct myPair
{
A first; //键
B second; //值
};

1.基本数据类型

#include<map>
#include<iostream>
#include<string>
using namespace std;
int main()
{
	//1.基本数据类型 
	//数对类型：pair
	map<int, string> myMap;
	//1.1 下标法插入   最直接,用的最多   （下标法仅适用于键为int类型的数据）
	myMap[520] = "LoveYou";
	myMap[18] = "YouLoveMe";
	myMap[18] = "aha";			//注意：出现重复时，保留最后一个
	//1.2 insert + pair数对
	myMap.insert(pair<int, string>(1, "tust"));
	//1.3 调用make_pair函数构建数据
	myMap.insert(make_pair<int, string>(2, "tiajin"));//=> myMap.insert(make_pair<int, string>(2, string("tiajin")));
	//迭代器进行打印：
	map<int, string>::iterator iter;
	for(iter=myMap.begin();iter!=myMap.end();iter++)
	{
		cout << iter->first << "." << iter->second << endl;
	}
	//通过键去访问值（类似于数组访问的形式）
	cout << myMap[18] << endl;
	system("pause");
	return 0;
}

运行结果：
在这里插入图片描述

2.自定义数据类型

#include<map>
#include<iostream>
#include<string>
using namespace std;
//数据设计：
struct student
{
	string name;
	int age;
};
int main()
{
	//2.自定义数据类型
	map<int, student> stu;
	for(int i=0;i<3;i++)
	{
		student tempData;
		cin >> tempData.name >> tempData.age;
		stu[i] = tempData;
	}
	system("pause");
	return 0;
}

3.multimap多重映射

多重映射：任何关系都允许，只带一个排序功能
注意：不能通过下标进行访问。

#include<map>
#include<iostream>
#include<string>
using namespace std;
int main()
{
	//多重映射：
	//不能通过下标(数组的方式)访问
	//也不能通过下标（数组的方式）插入
	multimap<int, char> mulMap;
	mulMap.insert(pair<int, char>(89, 'B'));
	mulMap.insert(pair<int, char>(70, 'C'));
	mulMap.insert(pair<int, char>(70, 'C'));
	mulMap.insert(pair<int, char>(60, 'C'));
	mulMap.insert(pair<int, char>(90, 'A'));
	//迭代器打印
	multimap<int, char>::iterator mulIter;
	for (mulIter = mulMap.begin(); mulIter != mulMap.end(); mulIter++)
	{
		cout << mulIter->first << ":" << mulIter->second << endl;
	}
	system("pause");
	return 0;
}
标签
实例化
对象数组
vector
string
容器
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!