2738 Queue with Template(eden)

Description

Please modify class Queue’s declaration and definition so as to finish the test from main.cpp…

Attention: please use template you have learned in the class to finish this assignment and DON NOT add and modify any memeber function and member variable.

Warning: DON NOT USE Queue in STL.

The Queue’s declaration with element type “int” is below:

class Queue {
  public:
    Queue();

    Queue(const Queue & another);
    ~Queue();
    bool empty();
    int size();
    int front() const;
    int back() const;
    void push(int element);
    void pop();
    void swap(Queue & queue);

  private:
    struct Node {
      int element;
      Node* next;
      Node(int ele, Node* n = NULL) {
        element = ele;
        next = n;
      }
    };
    Node* front_node;
    Node* back_node;
    int node_num;
};

Hint

如果你对类中的成员函数有疑问，函数的具体作用，请参见：www.cplusplus.com里面的queue

Author: 黎洋

Provided Codes

main.cpp

#include <iostream>
#include "Queue.h"
#include <string>
#include <sstream>

using namespace std;

class Job {
    public:
        explicit Job(int pri = 0) {
            id = number++;
            priority = pri;
        }
        string toString() {
            stringstream ss;
            ss << "[" << id << ":" << priority << "]";
            return ss.str();
        }
    private:
        static int number;
        int id;
        int priority;
};

int Job::number = 0;

template<class T>
void print(Queue<T> queue) {
    while (!queue.empty()) {
        cout << queue.front() << " ";
        queue.pop();
    }
    cout << endl;
}

int main() {
    // test case 1: integer..
    Queue<int> que;
    int m, n;
    cin >> m >> n;
    for (int i = 0; i < m; i++) que.push(i + 0.01);
    for (int i = 0; i < n; i++) que.pop();
    if (!que.empty()) {
        cout << que.front() << endl;
        cout << que.back() << endl;
    }
    cout << "The size is: " << que.size() << endl;
    if (que.empty()) cout << "The queue is empty!" << endl;
    else cout << "The queue is NOT empty!" << endl;

    // test case 2: double..
    Queue<double> que1;
    cin >> m >> n;
    for (int i = 0; i < m; i++) que1.push(i + 0.01);
    for (int i = 0; i < n; i++) que1.pop();
    if (!que1.empty()) {
        cout << que1.front() << endl;
        cout << que1.back() << endl;
    }
    cout << "The size is: " << que1.size() << endl;
    if (que1.empty()) cout << "The queue is empty!" << endl;
    else cout << "The queue is NOT empty!" << endl;

    // test case 3: user defined class..
    Queue<Job> que2;
    cin >> m >> n;
    for (int i = 0; i < m; i++) que2.push(Job(i));
    for (int i = 0; i < n; i++) que2.pop();

    if (!que2.empty()) {
        cout << que2.front().toString() << endl;
        cout << que2.back().toString() << endl;
    }
    cout << "The size is: " << que2.size() << endl;
    if (que2.empty()) cout << "The queue is empty!" << endl;
    else cout << "The queue is NOT empty!" << endl;

    // test case 4: swap function..
    Queue<int> que3, que4;
    for (int i = 0; i < m; i++) que3.push(i);
    for (int i = 0; i < n; i++) que4.push(m - i);
    cout << "Before Swap...." << endl;
    print(que3);
    print(que4);

    que3.swap(que4);
    cout << "After Swap...." << endl;
    cout << endl;
    print(que3);
    print(que4);
}

Submission

Queue.h

#ifndef QUEUE_H
#define QUEUE_H
#include <cstdlib>
template <typename T>
class Queue {
 public:
    Queue();
    Queue(const Queue & another);
    ~Queue();
    bool empty();
    int size();
    T front() const;
    T back() const;
    void push(T element);
    void pop();
    void swap(Queue & queue);
 private:
    struct Node {
      T element;
      Node* next;
      Node(T ele, Node* n = NULL) {
        element = ele;
        next = n;
      }
    };
    Node* front_node;
    Node* back_node;
    int node_num;
};

template <typename T>
Queue<T>::Queue(){
    front_node=NULL;
    back_node=NULL;
    node_num=0;
}
template <typename T>
Queue<T>::Queue(const Queue & another){
    front_node=NULL;
    back_node=NULL;
    node_num=0;
    Node *tem=another.front_node;
    while(tem!=NULL){
        push(tem->element);
        tem=tem->next;
    }
}
template <typename T>
Queue<T>::~Queue(){
    while(front_node!=NULL)
        pop();
}
template <typename T>
bool Queue<T>::empty(){
    if(node_num==0)
        return true;
    return false;
}
template <typename T>
int Queue<T>::size(){
    return node_num;
}
template <typename T>
T Queue<T>::front() const{
    return front_node->element;
}
template <typename T>
T Queue<T>::back() const{
    return back_node->element;
}
template <typename T>
void Queue<T>::push(T element){
    if(back_node!=NULL)
        back_node=back_node->next=new Node(element);
    else
        front_node=back_node=new Node(element);
    ++node_num;
}
template <typename T>
void Queue<T>::pop(){
    if(front_node!=NULL){
        Node *tem=front_node;
        front_node=front_node->next;
        delete tem;
        if(front_node==NULL)
            back_node=NULL;
        --node_num;
    }
}
template <typename T>
void Queue<T>::swap(Queue & queue){
    Node *a=front_node;
    Node *b=back_node;
    int c=node_num;
    front_node=queue.front_node;
    back_node=queue.back_node;
    node_num=queue.node_num;
    queue.front_node=a;
    queue.back_node=b;
    queue.node_num=c;
}

#endif