queue_dsa.hpp

#pragma once
#include <memory>
#include <iostream>
 
template<class T>
class MyQueue {
private:
    template<class NType>
    class Node {
    public:
        NType data{}; 
        std::shared_ptr<Node<NType>> next = nullptr; 
        Node() = default;
    };
private:
    std::shared_ptr<Node<T>> theFirst; 
    std::shared_ptr<Node<T>> theRear; 
public:
    MyQueue() = default;
 
    MyQueue(const MyQueue<T>&) = delete;
 
    MyQueue(MyQueue<T>&& other) = default;
 
    MyQueue& operator=(const MyQueue<T>&) = delete;
 
    MyQueue& operator=(MyQueue<T>&& other) = default;
public:
    virtual MyQueue<T>& push_back(const T& value) {
        std::shared_ptr<Node<T>> newNode = std::make_shared<Node<T>>();
        newNode->data = value;
        newNode->next = nullptr;
 
        if (!theFirst) {
            theFirst = theRear = newNode;
            return *this;
        }
        else {
            theRear->next = newNode;
            theRear = newNode;
            return *this;
        }
 
        return *this;
    }
 
    virtual T front_element() {
        return theFirst->data;
    }
 
    virtual T last_element() {
        Node<T>* temp = theFirst.get();
        while (temp->next != nullptr) {
            temp = temp->next.get();
        }
 
        return temp->data;
    }
 
    virtual T popFront() {
        if (theFirst == nullptr) throw std::runtime_error("cannot dequeue empty queue");
        T data = theFirst->data;
        theFirst = theFirst->next;
        if (theFirst == nullptr) theRear = nullptr;
 
        return data;
    }
 
    virtual bool isEmpty() {
        if (theFirst) return false;
        else return true;
 
        return false;
    }
 
    virtual size_t size() {
        Node<T>* temp = theFirst.get();
        size_t counter = 0;
        while (temp) {
            temp = temp->next.get();
            counter++;
        }
 
        return counter;
    }
};
 
void UsingQueue();
 
void UsingQueue2();
 
template<class T>
void UsingQueue3(MyQueue<T>& deez) {
    while (!deez.isEmpty()) {
        std::cout << "The first in the queue right now is " << deez.front_element() << std::endl;
        deez.popFront();
        std::cout << "The first has been popped!" << std::endl;
    }
}