Конструктор класса по умолчанию

 
template <typename T>//Объявление шаблона класса PriorityQueue, принимающего один параметр - typename T
class PriorityQueue {
public:
    // Конструкторы
    PriorityQueue() = default;//
    PriorityQueue(const std::vector<T>& elements) : heap(elements) {
        std::make_heap(heap.begin(), heap.end());
    }

#include <iostream>
#include <string>
 
struct A{
   A() = default;
   int a = 5;
   std::string str= "five";
};
 
int main(){
   A a;
   std::cout << a.a << ' ' << a.str << std::endl;
}

PriorityQueue() = default;

PriorityQueue() {}

#include <iostream>
#include <vector>
#include <stdexcept>
#include <algorithm>
#include <iterator>
 
// Класс очереди с приоритетом на основе кучи
template <typename T>//Объявление шаблона класса PriorityQueue, принимающего один параметр - typename T
class PriorityQueue {
public:
    // Конструкторы
    PriorityQueue() = default;//
    PriorityQueue( std::vector<T> elements) : heap(elements) {
        std::make_heap(heap.begin(), heap.end());//инициализация конструктора вектора heap значением elements, 
                                                 //преобразование вектора heap в кучу.
                                                 //Передача параметра по ссылке без создания временной копии elements.
                                                 
                                                 //Cсылка - константная, так как нет необходимости изменять 
                                                 //значение параметра во время действия конструктора. (*)
    }
 
    // Деструктор
    ~PriorityQueue() = default;
 
    // Метод добавления элемента
    void push(const T& element) {//(*)
        heap.push_back(element);
        std::push_heap(heap.begin(), heap.end());
    }
 
    // Метод удаления максимального элемента
    void pop() {
        if (empty()) {
            throw std::underflow_error("PriorityQueue is empty");
        }
        std::pop_heap(heap.begin(), heap.end());//замена первого(максимального) элемента кучи на последний.
                                                //Восстановление свойств кучи
        heap.pop_back();//удаление последнего элемента кучи
    }
 
    // Метод получения максимального элемента
    T top() const {                                                 //Метод константный, так как не должен изменять объект класса.
                                                                    //Он лишь возвращает первый(как раз максимальный, ввиду свойств
        if (empty()) {                                              //кучи) элемент за О(1)
            throw std::underflow_error("PriorityQueue is empty");
        }
        return heap.front();
    }
 
    // Метод получения размера очереди
    size_t size() const {
        return heap.size();
    }
 
    // Метод проверки, пуста ли очередь
    bool empty() const {
        return heap.empty();
    }
 
    // Оператор присваивания
    PriorityQueue& operator=(const PriorityQueue& other) {
        if (this != &other) {
            heap = other.heap;
        }
        return *this;
    }
 
    // Оператор сравнения ==
    bool operator==(const PriorityQueue& other) const {
        return heap == other.heap;
    }
 
    // Оператор сравнения !=
    bool operator!=(const PriorityQueue& other) const {
        return !(*this == other);
    }
 
    // Оператор сравнения <
    bool operator<(const PriorityQueue& other) const {
        return heap < other.heap;
    }
 
    // Оператор сравнения <=
    bool operator<=(const PriorityQueue& other) const {
        return heap <= other.heap;
    }
 
    // Оператор сравнения >
    bool operator>(const PriorityQueue& other) const {
        return heap > other.heap;
    }
 
    // Оператор сравнения >=
    bool operator>=(const PriorityQueue& other) const {
        return heap >= other.heap;
    }
 
    // Итератор произвольного доступа
    class Iterator {
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type = T;
        using difference_type = std::ptrdiff_t;
        using pointer = T*;
        using reference = T&;
 
        Iterator(pointer ptr) : ptr(ptr) {}
 
        reference operator*() const { return *ptr; }
        pointer operator->() { return ptr; }
 
        Iterator& operator++() {
            ++ptr;
            return *this;
        }
 
        Iterator operator++(int) {
            Iterator tmp = *this;
            ++ptr;
            return tmp;
        }
 
        Iterator& operator--() {
            --ptr;
            return *this;
        }
 
        Iterator operator--(int) {
            Iterator tmp = *this;
            --ptr;
            return tmp;
        }
 
        Iterator operator+(difference_type offset) const {
            return Iterator(ptr + offset);
        }
 
        Iterator operator-(difference_type offset) const {
            return Iterator(ptr - offset);
        }
 
        difference_type operator-(const Iterator& other) const {
            return ptr - other.ptr;
        }
 
        Iterator& operator+=(difference_type offset) {
            ptr += offset;
            return *this;
        }
 
        Iterator& operator-=(difference_type offset) {
            ptr -= offset;
            return *this;
        }
 
        reference operator[](difference_type offset) const {
            return *(ptr + offset);
        }
 
        bool operator==(const Iterator& other) const {
            return ptr == other.ptr;
        }
 
        bool operator!=(const Iterator& other) const {
            return !(*this == other);
        }
 
        bool operator<(const Iterator& other) const {
            return ptr < other.ptr;
        }
 
        bool operator<=(const Iterator& other) const {
            return ptr <= other.ptr;
        }
 
        bool operator>(const Iterator& other) const {
            return ptr > other.ptr;
        }
 
        bool operator>=(const Iterator& other) const {
            return ptr >= other.ptr;
        }
 
    private:
        pointer ptr;
    };
 
    Iterator begin() {
        return Iterator(heap.data());
    }
 
    Iterator end() {
        return Iterator(heap.data() + heap.size());
    }
 
    // Оператор вывода
    friend std::ostream& operator<<(std::ostream& os, const PriorityQueue& pq) {
        for (const auto& element : pq.heap) {
            os << element << " ";
        }
        return os;
    }
 
private:
    std::vector<T> heap;
};
 
 
int main() {
    PriorityQueue<int> pq1;
    pq1.push(3);
    pq1.push(1);
    pq1.push(4);
 
    PriorityQueue<int> pq2;
    pq2.push(1);
    pq2.push(5);
    pq2.push(9);
    std::cout << pq1.top() << std::endl;
    std::cout << "PriorityQueue 1: " << pq1 << std::endl;
    std::cout << "PriorityQueue 2: " << pq2 << std::endl;
 
    std::cout << "pq1 == pq2: " << (pq1 == pq2) << std::endl;
    std::cout << "pq1 != pq2: " << (pq1 != pq2) << std::endl;
    std::cout << "pq1 < pq2: " << (pq1 < pq2) << std::endl;
    std::cout << "pq1 <= pq2: " << (pq1 <= pq2) << std::endl;
    std::cout << "pq1 > pq2: " << (pq1 > pq2) << std::endl;
    std::cout << "pq1 >= pq2: " << (pq1 >= pq2) << std::endl;
 
    return 0;
}

std::vector<T> heap;