list.h

 
#pragma once
 
namespace rune {
 
  template <class T>
  struct listItem
  {
 
    T storedItem;
    listItem* nextItem;
 
    listItem()
    {
      nextItem = nullptr;
    }
 
  };
 
  template <class T>
  class List
  {
 
  private:
    listItem<T>* listHead;
    listItem<T>* currentlyAccessedItem;
 
    int listSize;
 
  public:
 
    List()
      : listHead(nullptr), listSize(0), currentlyAccessedItem(nullptr)
    {
    }
 
    ~List()
    {
      clear();
    }
 
    T* getList()
    { 
      currentlyAccessedItem = listHead;
      return &(listHead->storedItem);
    }
 
    T* getNext()
    {
 
      if (currentlyAccessedItem == nullptr)
      {
        return nullptr;
      }
 
      currentlyAccessedItem = currentlyAccessedItem->nextItem;
 
      return &(currentlyAccessedItem->storedItem);
 
    }
 
    int size()
    {
      return listSize;
    }
 
    void add(T const& newData)
    {
 
      listSize++;
      listItem<T>* newItem = new listItem<T>;
      newItem->storedItem = newData;
 
      listItem<T>* currentItem = listHead;
 
      if (listHead == nullptr)
      {
 
        listHead = newItem;
 
      }
      else
      {
 
        while (currentItem->nextItem != nullptr)
        {
 
          currentItem = currentItem->nextItem;
 
        }
 
        currentItem->nextItem = newItem;
 
      }
 
    }
 
    void remove(int index)
    {
 
      listSize--;
      listItem<T>* currentItem = listHead;
 
      //Access the element just before the element to be deleted.
      for (int i = 0; i < index - 1; i++)
      {
 
        currentItem = currentItem->nextItem;
 
      }
 
      //If the list is now empty, reset. Otherwise, delete the specified element.
      if (index == 0)
      {
        listItem<T>* temp = listHead;
        listHead = listHead->nextItem;
        delete temp;
      }
      else
      {
        listItem<T>* temp = currentItem->nextItem->nextItem;
 
        delete currentItem->nextItem;
        currentItem->nextItem = temp;
      }
 
    }
 
    void clear()
    {
 
      while (listSize != 0)
      {
 
        //Go through and delete each element of the list
        remove(0);
 
      }
 
    }
 
    void insert(T const& newData, int index)
    {
 
      listSize++;
      listItem<T>* currentItem = listHead;
 
      listItem<T>* newItem = new listItem<T>;
      newItem->storedItem = newData;
 
      //Access the element just before the space to be inserted.
      for (int i = 0; i < index - 1; i++)
      {
 
        currentItem = currentItem->nextItem;
 
      }
 
      listItem<T>* temp = currentItem->nextItem;
 
      currentItem->nextItem = newItem;
      newItem->nextItem = temp;
 
    }
 
    T& operator[](int index)
    {
 
      listItem<T>* currentItem = listHead;
 
      for (int i = 0; i < index; i++)
      {
 
        currentItem = currentItem->nextItem;
 
      }
 
      return (currentItem->storedItem);
 
    }
 
  };
 
}//namespace rune