tlist.h

Code

/*
    tlist.h
    CIS 250
    David Klick
    2010-03-15

    Templated linked list specification
*/

#ifndef __TLIST_H__
#define __TLIST_H__
#include <iostream>
#include <string>
#include <assert.h>
using std::cout;
using std::endl;
using std::string;
using std::ostream;

template<typename T>
class tlist {
public:
    class node {
    public:
        T* data;
        node* next;
    };
private:
    node* head;
    int count;
public:
    tlist();
    ~tlist();
    int length() const;
    void print() const;
    T* front() const;
    T* back() const;
    bool isEmpty() const;
    void add(T* val);
    bool remove(T* val);
};

template<typename T>
tlist<T>::tlist() {
    count = 0;
    head = NULL;
}

template<typename T>
tlist<T>::~tlist() {
    while (head != NULL) {
        node* hold = head->next;
        delete head;
        head = hold;
        count--;
    }
}

template<typename T>
int tlist<T>::length() const {
    return count;
}

template<typename T>
void tlist<T>::print() const {
    node* pos = head;
    while (pos != NULL) {
        pos->data->print();
        cout << " ";
        pos = pos->next;
    }
    cout << endl;
}

template<typename T>
T* tlist<T>::front() const {
    if (head == NULL) throw string("Error: Accessing empty list");
    return head->data;
}

template<typename T>
T* tlist<T>::back() const {
    if (head == NULL) throw string("Error: Accessing empty list");
    node* pos = head;
    while (pos->next != NULL) pos = pos->next;
    return pos->data;
}

template<typename T>
bool tlist<T>::isEmpty() const {
    return head == NULL;
}

template<typename T>
void tlist<T>::add(T* obj) {
    node* elephant = new node;
    assert (elephant != NULL);
    elephant->data = obj;
    elephant->next = NULL;
    if (head == NULL) {
        head = elephant;
    } else {
        node* pos = head;
        while (pos->next != NULL) pos = pos->next;
        pos->next = elephant;
    }
    count++;
}

template<typename T>
bool tlist<T>::remove(T* obj) {
    if (head == NULL) return false;
    if (head->data->equals(obj)) {
        node *temp = head;
        head = head->next;
        delete temp;
        count--;
        return true;
    }
    node* prev = head;
    node* curr = prev->next;
    while (curr != NULL) {
        if (curr->data->equals(obj)) {
            prev->next = curr->next;
            delete curr;
            count--;
            return true;
        } else {
            prev = curr;
            curr = curr->next;
        }
    }
    return false;
}

#endif