初级C++：优先级队列、仿函数、模板进阶

仿函数

• 仿函数（functor）又称之为函数对象（function object），实际上就是 重载了()操作符 的 struct或class。
• 由于重载了（）操作符，所以使用他的时候就像在调用函数一样，于是就被称为“仿”函数啦。

class lless  //仿函数自定义类型  对象可以像函数一样去使用
	{
	public://不写默认私有      
		bool operator()(int x, int y) //对（）重载，
		{
			return x > y;
		}
	};
	void testless()
	{
		lless le;
		std::cout << le(20,30) << std::endl;
	}

使用场景

• 可以通过仿函数控制比较方式 ,例子：对日期类取最值

日期类
class Dtae
{
	friend ostream& operator<<(ostream& _cout, const Dtae& d);//友元函数
public:
	Dtae(int y = 2015, int m = 9, int d = 1);

	bool operator>( const Dtae& y)const 
	{
		return (_y > y._y ||
			(_y == y._y && _m > y._m) ||
			(_y == y._y && _m == y._m && _d > y._d));
	}
	friend class PDateLess;
private:
	int _y;
	int _m;
	int _d;
};
//日期构造
Dtae::Dtae(int y,int m,int d)
{
	_y = y;
	_m = m;
	_d = d;
}
//重载
ostream& operator<<(ostream& _cout, const Dtae& d)//友元在全局定义
{
	_cout << d._y << "-" << d._m << "-" << d._d << endl;
	return _cout;
}
//仿函数
class PDateGreater
{
public:
	bool operator()(const Dtae p1, const Dtae p2)
	{
		return p1 > p2;
	}
};

int main()
{
    mypriority::priority_queue<Dtae, std::vector<Dtae>, PDateGreater> pq;
	pq.push( Dtae(2023, 11, 24));  
	pq.push(Dtae(2021, 10, 24));
	pq.push(Dtae(2021, 12, 24));
	pq.push(Dtae(2022, 1, 24));

	std::cout << pq.top() << std::endl;
	pq.pop();
	return 0；
}

---

优先级队列：priority_queue

1. 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。
2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。
3. 优先队列被实现为容器适配器，容器适配器即 将特定容器类 封装作为 其 底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。
4. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：
   1. empty()：检测容器是否为空
   2. size()：返回容器中有效元素个数
   3. front()：返回容器中第一个元素的引用
   4. push_back()：在容器尾部插入元素
   5. pop_back()：删除容器尾部元素
5. 标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。
6. 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。

• 官方文档：

std::priority_queue

template <class T, class Container = vector<T>,
  class Compare = less<typename Container::value_type> > class priority_queue;

• typename：告诉编译器这是一个类型；推荐使用vector作为容器缺省参数

---

自定义仿函数

namespace mypriority
{
	//自己写的仿函数
	template<class T>
	class less
	{
	public:
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}
	};
	template<class T>
	class greater
	{
	public:   //不写默认私有，也可使用struct
		bool operator()(const T& x, const T& y) 
		{
			return x > y;
		}
	};
	....
}

---

成员函数

	template<class T, class Container=std::vector<T>,class Compare =greater<T>>
	class priority_queue
	{
	public:
		priority_queue(){} //编译器对自定义类型 会调用它的默认构造
		void push(const T& x);
		void pop();
		void Adjustup(size_t child);
		void Adjustdown(size_t parent);
		const T& top();
		size_t size();
		bool empty();
		
	//迭代器区间构造函数    
		template<class Intr>  //构造函数模板参数 类型 
		priority_queue(Intr first, Intr Last)
		{
			while (first!=Last)
			{
				push(*first);
				++first;
			}
		}
	private:   //缺省容器 vector  
		Container _qu;
	};

---

push_bcak

• 模板参数列表类外定义时，不写缺省参数。
• 最后一个节点和双亲结点比较。

	template<class T, class Container, class Compare>  
	void priority_queue<T, Container, Compare>::push(const T& x)
	{
			_qu.push_back(x);
			//尾插就调用向上调整算法
			Adjustup(_qu.size() - 1);
	}
	
	template<class T, class Container, class Compare>
	void priority_queue<T, Container, Compare>::Adjustup(size_t child)
	{

		Compare le;//仿函数创建一个对象
		size_t parent = (child - 1) / 2;
		while (child>0)
		{
			if (le(_qu[child],_qu[parent]))
			{
				std::swap(_qu[parent], _qu[child]);//用仿函数传参
				child = parent;
				parent = (child-1)/2;
			}
			else
			{
				break;
			}
		}
	}

pop

• 交换首位元素，删除；
• 调用向下调整算法：
  • 和左右孩子节点中最值的一个比较，交换。

template<class T, class Container, class Compare>
	void priority_queue<T, Container, Compare>::pop()
	{
		if (_qu.empty())
		{
			return;
		}
		else
		{
			std::swap(_qu[0], _qu[_qu.size() - 1]);
			_qu.pop_back();
			Adjustdown(0);
		}
	}
template<class T, class Container, class Compare>
	void priority_queue<T, Container, Compare>::Adjustdown(size_t parent)
	{
		Compare ge; //仿函数创建一个对象
		size_t child = parent * 2 + 1;
		while (child<_qu.size())
		{
			if (child + 1 < _qu.size() && ge(_qu[child+1], _qu[child])) //用仿函数传参
			{
				++child;
			}
			if (ge(_qu[child], _qu[parent]))
			{
				std::swap(_qu[child], _qu[parent]);
				parent = child;
				child = parent * 2 + 1;
			}
			else
			{
				break;
			}
		}
	}

---

判空、大小、堆顶元素

判空

	template<class T, class Container, class Compare>
	bool priority_queue<T, Container, Compare>::empty()
	{
		return _qu.empty();
	}

大小

	template<class T, class Container, class Compare>
	size_t priority_queue<T, Container, Compare>::size()
	{
		return _qu.size();
	}

堆顶元素

	template<class T, class Container, class Compare>
	const T& priority_queue<T, Container, Compare>::top()
	{
		return _qu[0];
	}

测试用例

void testpriority_queue()
	{
		//不传会使用缺省的模板参数
		priority_queue<int> pq;   
		//priority_queue<int,std::deque<int>,greater<int>> pq1;
		pq.push(19);
		pq.push(200);
		pq.push(30);
		pq.push(7000);
		pq.push(40);
		pq.push(10);

		while (!pq.empty())
		{
			std::cout << pq.top() << std::endl;
			pq.pop();
		}
		std::cout << pq.size() << std::endl;
		std::cout << pq.empty() << std::endl;
	}

---

---

模板特化

• 对模板参数类型的进一步限制：全特化，半特化\偏特化

• 函数模板特化，依然根据匹配原则，进行特殊化处理，有现成用现成的，没现成的用通用的。

---

类模板特化

• 同函数模板一样，根据匹配原则，有啥用啥。

• 一堆栗子：

template<class T1,class T2>
class Da
{
public:
	Da()
	{
		cout << "Da<T1,T2>" << endl;
	}
private:
	T1 _d1;
	T2 _d2;
};

template<>
class Da<int,char>
{
public:
	Da()
	{
		cout << "Da<int,char>" << endl;
	}
private:
	int _d;
	char _c;
};

template<class T1>
class Da<T1, char>
{
public:
	Da()
	{
		cout << "Da<T1,char>" << endl;
	}
private:
	T1 _d;
	char _c;
};


template<class T1, class T2>
class Da<T1*,T2*>
{
public:
	Da()
	{
		cout << "Da<T1*,T2*>" << endl;
	}
private:
	T1 _d1;
	T2 _d2;
};

template<class T1, class T2>
class Da<T1&, T2&>
{
public:
	Da()
	{
		cout << "Da<T1&,T2&>" << endl;
	}
private:
	T1 _d1;
	T2 _d2;
};

void testT()
{
	Da<int, int> d1;
	Da<int, char> d2;
	Da<double,char>d3
	Da<char*, int*> d4;
	Da<char&, int&> d5;
}

模板总结

• 不支持分离编译，将声明定义写在同一个文件。

优缺点：

---