目录

1.array容器

 vector 和 array镶嵌使用

4.链表容器（list）是一个库封装好的一个双向链表

5.priority_queue: 优先队列

6.map和multimap

7.set和multiset

---

1.array容器

包含头文件#include<array>才能使用

简单来说他就是一个数组 知识c++中把他封装成一个类 这样可以直接使用

使用方法是array<类型,长度> 

我们自己实现一个myarray带大家了解一下过程

#include<iostream>
#include<array>
using namespace std;
template<class _Ty,size_t size>
class myarray
{
public:
	
	myarray()
	{
		//由给定的长度类型构造出来
		memory = new _Ty[size];
	}
	//这里要返回引用 表示[]表示调用类中的数据
	_Ty& operator[](int index)
	{
		return memory[index];
	}
	_Ty front()
	{
		return memory[0];
	}
	_Ty back()
	{
		return memory[size - 1];
	}
	_Ty at(int index)
	{
		return memory[index];
	}
public:
	//迭代器可以理解为就是一个指针 
	class iterator
	{
	public:
		iterator(_Ty* pmove = nullptr) :pmove(pmove) {};
		//重载迭代器地址赋值=
		void operator=(iterator object)
		{
			this->pmove = object.pmove;
		}
		bool operator!=(iterator object)
		{
			return this->pmove != object.pmove;
		}
		iterator operator++(int)//里面有int为前置
		{
			pmove++;
			return (*this);
		}
		_Ty operator*()
		{
			return *pmove;
		}
	protected:
		_Ty* pmove;

	};
public:
	//使用这个函数时表示指向数组首地址
	iterator begin()
	{
		return iterator(memory + 0);//调用构造函数去赋值
	}
	iterator end()
	{
		return iterator(memory + size);//调用构造函数去赋值
	}

protected:
	_Ty* memory;
};
int main()
{
	
	myarray<int, 3>k;
	//因为我们这里简单实现没有在构造函数里面写初始化参数列表
	for (int i = 0; i < 3; i++)
	{
		//相当于调用重载函数[]
		k[i] = i;
	}
	myarray<int, 3>::iterator iter;
	for ( iter= k.begin(); iter != k.end(); iter++)
	{
		cout << *iter;//*调用*的重载函数
	}

	return 0;
}

2.vector容器

理解就是想当于一个长度可以变换的数组

包含头文件#include<vector>才可以使用

使用方法:

vector<类型>或者vector<类型>变量名（长度）//后置可以当一个以为数组去简单赋值

vector<int> testv;
	for (int i = 0; i < 5; i++)
	{
		testv.push_back(i);
	}
	vector<int>testv2(5);
	for (int i = 0; i < 5; i++)
	{
		testv2[i] = i;
	}

    所以一般在使用动态数组，有个习惯
    带长度创建的vector 一般都是用下标法使用
    不带长度的vector，采用成员函数的方式操作

 遍历vector容器和数组是一样的因为容器里面都包含了iterator(迭代器) 可以去实现遍历

 vector 和 array镶嵌使用

    No.1 array与array嵌套
    No.2 vecotr与vecotr嵌套
    No.3 array与vector互相嵌套

array和array

array<array<int, 3>, 2> test;
	//就相当一个二行每行有三个元素的数组
	//理解把array<int,3>看成一个类型
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			test[i][j] = i;
		}
	}
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << test[i][j] << "  ";
		}
		cout << endl;
	}

array和vector

array<vector<int>, 3>test;
	//相当于有一个三个vector<int>数组
	for (int i = 0; i < 3; i++)
	{
		test[i].push_back(5);
		test[i].push_back(6);
	}
	test[1].push_back(1);
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < test[i].size(); j++)
		{
			cout << test[i][j]<<"  ";
		}
		cout << endl;
	}

vector和vector

vector<vector<int>>test(3);
	//有长度的表示有3个vector<int>
	//就等效于二维数组有三行但是每行的列数是可以变化的
	for (int i = 0; i < test.size(); i++)
	{
		test[i].push_back(5);
		test[i].push_back(6);
	}
	test[2].push_back(5);
	for (int i = 0; i < test.size(); i++)
	{
		for (int j = 0; j < test[i].size(); j++)
		{
			cout << test[i][j] << "  ";
		}
		cout << endl;
	}
	cout << endl;

4.链表容器（list）是一个库封装好的一个双向链表

里面包含的一些常使用函数

       push_back()
        pop_back();
        push_front();
        pop_front();
        size();
        empty();
        erase+find
        insert+
        sort();

void printflist(list<_Ty> data)
{
	for (auto v : data)
	{
		cout << v << endl;
	}
}
int main()
{
	list<string> testlist;
	testlist.push_back("fsdj");//相当于尾插
	testlist.push_back("erowe");
	testlist.push_front("erewe");//头插
	testlist.push_back("a");
	testlist.sort();//默认是小到大的//这里就是字母排序
	cout << "less<string>()排序准则" << endl;
	printflist(testlist);
	//大到小的排序准则
	cout << "greater<string>()排序准则" << endl;
	testlist.sort(greater<string>());
	printflist(testlist);

	return 0;
}

链表存储自定义类型：

主要了解排序准则

1.靠类中重载的方式调用括号来调用函数接口

2.直接写函数来调用接口

#include<iostream>
#include<vector>
#include<array>
#include<list>
#include<string>
using namespace std;
template<class _Ty>
void printflist(list<_Ty> data)
{
	for (auto v : data)
	{
		cout << v;
	}
}


class MM
{
public:
	MM(string name, int year) :name(name), year(year) {};
	//重载输出就可以打印对象成员
	friend ostream& operator<<(ostream& out, MM& object)
	{
		out << object.name << "  " << object.year << endl;
		return out;
	}
	//获取对象的年龄
	int& getyear()
	{
		return this->year;
	}
	string& getname()
	{
		return this->name;
	}
protected:
	string name;
	int year;
};
//重写排序准则仿函数
class compareyear
{
	//重载括号
public://要共有类 不然不能用（）代表函数来提供接口
	bool operator()(MM object1, MM object2)
	{
		return object1.getyear() > object2.getyear();//年龄大到小的准则
	}
};
//
bool comparesname(MM object1, MM object2)
{
	return object1.getname() < object2.getname();
}
int main()
{

	list<MM>test1;
	test1.push_back(MM("张三", 18));
	test1.push_back(MM("李四", 28));
	test1.push_back(MM("王五", 78));
	cout << "按年龄大到小的排序准则" << endl;
	test1.sort(compareyear());
	//解释这个compareyear（）这里括号就相当于调用了里面类中的函数
	//提供一个接口
	printflist(test1);
	test1.sort(comparesname);//提供一个函数 提供一个接口
	cout << "按姓名小到大的排序准则" << endl;
	printflist(test1);//按姓名排序
	return 0;
}

5.priority_queue: 优先队列

按照特定数据特定的标准排序的队列

 接下来用vector写一个容器中的优先队列带大家了解一下基础操作

//

#include<iostream>
#include<vector>
#include<array>
#include<list>
#include<string>
#include<algorithm>
using namespace std;
template<class _Ty,class _contain=vector<_Ty>,class _pr=less<_Ty>>
//分别为类型 容器 排序准则
class priority_queue
{
public:
	priority_queue() = default;//默认的构造函数
	void push(_Ty data)
	{
		mem.push_back(data);
		sort(mem.begin(), mem.end(), _pr());//容器排序
	}
	void pop()
	{
		mem.erase(mem.begin());//出队列
	}
	const _Ty& top()
	{
		return mem.begin();
	}
	bool empty()const
	{
		return mem.empty();
	}
	int size()const
	{
		return mem.size();
	}
protected:
	_contain mem;//就是容器
};


int main()
{
	priority_queue<int> test1;
	for (int i = 10; i >= 0; i--)
	{
		test1.push(i);
	}
	cout << test1.size() << endl;
	test1.pop();
	cout << test1.size();
}

6.map和multimap

    No.1 map是  映射，就是一种对应关系(数组：下表与值对应)
        1.1 排序性 (按照键的排序)
        1.2 唯一性 (按照键的唯一性)  相同键的时候，不做插入
        1.3 存储的数据是一个数对类型: pair<Type1,type2>;
            first:键  second:值

map<类型，类型,排序准则(默认缺省为小到大)>

排序准则是按键值来的

#include<iostream>
#include<string>
#include<algorithm>
#include<map>
using namespace std;
int main()
{


	map<int, string> test;
	//下标插入
	test[1] = "sdfj";
	test[-1] = "oiwer";
	//用pair类构造
	test.insert(pair<int, string>(6, "sfewr"));
	//insert插入 用make_pair构造
	test.insert(make_pair(5, "sfd"));
	
	for (map<int, string>::iterator iter = test.begin(); iter != test.end(); iter++)
	{
		cout << iter->first << "  " << iter->second << endl;
		//分别为打印键和打印值
	}
	//存在默认的排序函数 
	return 0;
}

用map去操作自定义类型主要:是重写排序函数 

排序准则下的比较要加const修饰安全起见防止被修改里面的值

#include<iostream>
#include<map>
using namespace std;
class Boy
{
public:
	friend ostream& operator<< (ostream& out, Boy one)
	{
		out << one.getAge() << "  " << one.getName();
		return out;
	}
	Boy() = default;
	Boy(string name, int age) :name(name), age(age) {}
	string getName()const
	{
		return name;
	}
	int getAge()const
//作为排序准则比较要加const
因为map内部是一个const对象
	{
		return age;
	}
protected:
	string name;
	int age;
};
class MM
{
public:
	MM() = default;
	MM(string name, int age) :name(name), age(age) {}
	friend ostream& operator<< (ostream & out, MM one)
	{
		out << one.getAge() << "  " << one.getName();
		return out;
	}
	string getName() 
	{
		return name;
	}
	int getAge()
	{
		return age;
	}
protected:
	string name;
	int age;
};
class LessByAge
{
public://重写的排序准则要加const
	bool operator()(const Boy& one, const Boy& two)const
	{
		return one.getAge() < two.getAge();
	}
};
int main()
{

	map<Boy, MM, LessByAge> bm;
	bm[Boy("张三", 28)] = MM("小芳", 28);
	bm[Boy("李四", 18)] = MM("小美", 28);
	bm[Boy("王五", 38)] = MM("小丽", 18);
	bm.insert(make_pair(Boy("李六",19) ,MM("燕子", 19)));
	bm.insert(pair<Boy, MM>({ Boy("老七",15),MM( "颗粒", 17 )}));
	for (auto v : bm)  //v pair<Boy,MM>
	{
		cout << v.first << "配对" << v.second << endl;
		
	}
	return 0;
}

注意；

以什么为排序准那么这个排序准则中的数字就不能相同

如：这里中Boy类型不能用相同年龄的有就会取第一个后面一个不取

multimap

 //多重映射: 只具有排序性
//键是允许重复，所以不存在下标法访问

    multimap<int,string> test;
	//因为multimap可以存在相同的键值所有这样是错的
	test[1] = "kk";

插入的方法：

    test.insert(make_pair(5, "ksdf"));
	test.insert(pair<int, string>(5, "fsd"));
	for (map<int, string>::iterator iter = test.begin(); iter != test.end(); iter++)
	{
		cout << iter->first << "  " << iter->second << endl;
	}

7.set和multiset

    No.1 set:集合  用来存储数据
        1.1 有序性，默认从小到大
        1.2 唯一性，不重复

    set<int> test = { 8,5,6,2,2,4 };
	for (set<int>::iterator iter = test.begin(); iter != test.end(); iter++)
	{
		cout << *iter << "  ";
	}
输出后是一个2 4 5 6 8

    set<int,greater<int>> test = { 8,5,6,2,2,4 };
	for (set<int>::iterator iter = test.begin(); iter != test.end(); iter++)
	{
		cout << *iter << "  ";
	}
输出结果是8 6 5 4 2
这里的排序准则直接写个对象greater<int>
是因为在调用set里面排序的时候会自动去调用对象里面的函数

multiset

只具有排序的功能可以出现相同的数字

multiset<int> test = { 1,1,2,2,3,5 };
	for (set<int>::iterator iter = test.begin(); iter != test.end(); iter++)
	{
		cout << *iter << "  ";
	}
输出就是1 1 2 2  3 5

	multiset<int,greater<int>> test = { 1,1,2,2,3,5 };
	for (set<int>::iterator iter = test.begin(); iter != test.end(); iter++)
	{
		cout << *iter << "  ";
	}
输出就是5 3 2 2 1 1