Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::priority_queue(3)	      C++ Standard Libary	std::priority_queue(3)

NAME
       std::priority_queue - std::priority_queue

Synopsis
	  Defined in header <queue>
	  template<

	  class	T,
	  class	Container = std::vector<T>,
	  class	Compare	= std::less<typename Container::value_type>

	  > class priority_queue;

	  A  priority queue is a container adaptor that	provides constant time
       lookup of the
	  largest (by default) element,	at the expense of  logarithmic	inser-
       tion and
	  extraction.

	  A user-provided Compare can be supplied to change the	ordering, e.g.
       using
	  std::greater<T>  would  cause	 the smallest element to appear	as the
       top().

	  Working with a priority_queue	is similar to managing a heap in  some
       random access
	  container, with the benefit of not being able	to accidentally	inval-
       idate the heap.

Template parameters
		      The type of the stored elements.
	  T	    - The behavior is undefined	if T is	not the	same type as
		      Container::value_type.
		      (since C++17)
		      The type of the underlying container to use to store the
       elements. The
		      container	 must satisfy the requirements of SequenceCon-
       tainer, and its
		      iterators	must satisfy the requirements of  LegacyRando-
       mAccessIterator.
		      Additionally,  it	 must  provide the following functions
       with the	usual
		      semantics:
	  Container -
			* front()
			* push_back()
			* pop_back()

		      The standard containers std::vector and std::deque  sat-
       isfy these
		      requirements.
		      A	Compare	type providing a strict	weak ordering.

		      Note  that the Compare parameter is defined such that it
       returns true if
	  Compare   - its first	argument comes before its second argument in a
       weak ordering.
		      But because the priority queue outputs largest  elements
       first, the
		      elements	that  "come  before" are actually output last.
       That is,	the front
		      of the queue contains the	"last"	element	 according  to
       the weak	ordering
		      imposed by Compare.

Member types
	  Member type	  Definition
	  container_type  Container
	  value_compare	  Compare
	  value_type	  Container::value_type
	  size_type	  Container::size_type
	  reference	  Container::reference
	  const_reference Container::const_reference

Member functions
	  constructor	constructs the priority_queue
			(public	member function)
	  destructor	destructs the priority_queue
			(public	member function)
	  operator=	assigns	values to the container	adaptor
			(public	member function)

Element	access
	  top		accesses the top element
			(public	member function)

Capacity
	  empty		checks whether the underlying container	is empty
			(public	member function)
	  size		returns	the number of elements
			(public	member function)

Modifiers
	  push		inserts	element	and sorts the underlying container
			(public	member function)
	  emplace	 constructs  element in-place and sorts	the underlying
       container
	  (C++11)	(public	member function)
	  pop		removes	the top	element
			(public	member function)
	  swap		swaps the contents
	  (C++11)	(public	member function)

Member objects
	  Container c	the underlying container
			(protected member object)
	  Compare comp	the comparison function	object
			(protected member object)

Non-member functions
	  std::swap(std::priority_queue) specializes the std::swap algorithm
	  (C++11)			 (function template)

Helper classes
	  std::uses_allocator<std::priority_queue>	 specializes	   the
       std::uses_allocator type
	  (C++11)				   trait
						   (class template specializa-
       tion)

	 Deduction guides (since C++17)

Example
       // Run this code

	#include <functional>
	#include <queue>
	#include <vector>
	#include <iostream>

	template<typename T>
	void print_queue(T q) {	// NB: pass by value so	the print uses a copy
	    while(!q.empty()) {
		std::cout << q.top() <<	' ';
		q.pop();
	    }
	    std::cout << '\n';
	}

	int main() {
	    std::priority_queue<int> q;

	    const auto data = {1,8,5,6,3,4,0,9,7,2};

	    for(int n :	data)
		q.push(n);

	    print_queue(q);

	    std::priority_queue<int, std::vector<int>, std::greater<int>>
		q2(data.begin(), data.end());

	    print_queue(q2);

	    // Using lambda to compare elements.
	    auto  cmp =	[](int left, int right)	{ return (left ^ 1) < (right ^
       1); };
	    std::priority_queue<int, std::vector<int>, decltype(cmp)> q3(cmp);

	    for(int n :	data)
		q3.push(n);

	    print_queue(q3);
	}

Output:
	9 8 7 6	5 4 3 2	1 0
	0 1 2 3	4 5 6 7	8 9
	8 9 6 7	4 5 2 3	0 1

	 Defect	reports

	  The following	behavior-changing defect reports were applied retroac-
       tively to
	  previously published C++ standards.

	     DR	     Applied	to		   Behavior    as    published
       Correct behavior
	  LWG  2684  C++98	 priority_queue	 takes a comparator but	lacked
       added
			      member typedef for it

http://cppreference.com		  2022.07.31		std::priority_queue(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::priority_queue&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help