루나's research

#include <iostream>

template <typename T>

class Queue

{

protected:

struct Node

{

T data;

Node *prev; // has been enqueued

Node *next; // will be enqueued

};

typedef Node* NodePtr;

private:

NodePtr front_;

NodePtr back_;

int size_ = -1;

public:

Queue();

virtual ~Queue();

void enqueue(const T&);

void dequeue();

T& front();

T& back();

const T front() const;

const T back() const;

int isSize() const;

bool isEmpty() const;

public:

friend std::ostream& operator << (std::ostream& os, const Queue& q)

{

NodePtr node = q.front_;

while (node != NULL) {

os << node->data << " ";

node = node->next;

}

return os;

}

};

template <typename T>

Queue<T>::Queue()

: front_(NULL), back_(NULL), size_(0)

{}

template <typename T>

Queue<T>::~Queue()

{

while (size_ > 0) {

dequeue();

}

}

template <typename T>

void Queue<T>::enqueue(const T& data)

{

NodePtr new_node = new Node;

new_node->data = data;

new_node->prev = back_;

new_node->next = NULL;

if (isEmpty() == true) {

front_ = new_node;

}

else {

back_->next = new_node;

}

back_ = new_node;

size_++;

}

template <typename T>

void Queue<T>::dequeue()

{

NodePtr node = front_;

front_ = front_->next;

if (front_ == NULL) {

back_ = NULL;

}

else {

front_->prev = NULL;

}

size_--;

delete node;

}

template <typename T>

T& Queue<T>::front()

{

return front_->data;

}

template <typename T>

const T Queue<T>::front() const

{

return front_->data;

}

template <typename T>

T& Queue<T>::back()

{

return back_->data;

}

template <typename T>

const T Queue<T>::back() const

{

return back_->data;

}

template <typename T>

int Queue<T>::isSize() const

{

return size_;

}

template <typename T>

bool Queue<T>::isEmpty() const

{

return (size_ == 0);

}

void main()

{

Queue<int> q;

int a;

std::cout << "--- start ---" << std::endl;

q.enqueue(1);

std::cout << q << std::endl;

q.enqueue(2);

std::cout << q << std::endl;

q.enqueue(3);

std::cout << q << std::endl;

q.dequeue();

q.dequeue();

std::cout << q << std::endl;

std::cout << q.front() << std::endl;

q.enqueue(100);

std::cout << q.back() << std::endl;

std::cout << (a = q.front()) << std::endl;

std::cout << "--- end ---" << std::endl;

}