So, I've been messing around with this project for the past week and still not sure exactly where i need to insert the pure virtual functions. I'm also somewhat fuzzy on the use of pointers as they reside inside the template class. supporting files are below.

this is in C++ and i couldnt post all the .h files as the "question was too long".

LinkedListType, unorderedLinkedList, and orderedLinkedList are given to you in Chapter 17. linkedListIterator is given to you as well. The files are supplied here.Overload the insertFirst and insertLast pure virtual functions such that they accept a vector of possible values as parameters. All values in the vector are to be inserted.Overload the deleteNode pure virtual function such that it accepts a vector of possible values. All values in the vector should be deleted.Modify deleteNode such that an exception is thrown when called on an empty list and when the item to delete is not in the list.Finally create a 2 lists using the STL list container. Add some values to them and sort them. Merge the two lists together into one list.

LinkedListType ***************************************************

linkedList.h

#ifndef H_LinkedListType #define H_LinkedListType #include #include using namespace std;

template struct nodeType { Type info; nodeType *link; };

template class linkedListIterator { public: linkedListIterator();

linkedListIterator(nodeType *ptr);

Type operator*();

linkedListIterator operator++();

bool operator==(const linkedListIterator& right) const;

bool operator!=(const linkedListIterator& right) const;

private: nodeType *current; //pointer to point to the current };

template linkedListIterator::linkedListIterator() { current = nullptr; }

template linkedListIterator:: linkedListIterator(nodeType *ptr) { current = ptr; }

template Type linkedListIterator::operator*() { return current->info; }

template linkedListIterator linkedListIterator:: operator++() { current = current->link;

return *this; }

template bool linkedListIterator::operator== (const linkedListIterator& right) const { return (current == right.current); }

template bool linkedListIterator::operator!= (const linkedListIterator& right) const { return (current != right.current); } //***************** class linkedListType ****************

template class linkedListType { public: const linkedListType& operator= (const linkedListType&); //Overload the assignment operator.

void initializeList();

bool isEmptyList() const;

void print() const;

int length() const;

void destroyList();

Type front() const;

Type back() const;

virtual bool search(const Type& searchItem) const = 0;

virtual void insertFirst(const Type& newItem) = 0;

virtual void insertLast(const Type& newItem) = 0;

virtual void deleteNode(const Type& deleteItem) = 0;

linkedListIterator begin();

linkedListIterator end();

linkedListType(); //Default constructor

linkedListType(const linkedListType& otherList); //copy constructor

~linkedListType(); //Destructor

protected: int count; nodeType *first; //pointer to the first node of the list nodeType *last; //pointer to the last node of the list

private: void copyList(const linkedListType& otherList); }; template bool linkedListType::isEmptyList() const { return (first == nullptr); }

template linkedListType::linkedListType() //default constructor { first = nullptr; last = nullptr; count = 0; }

template void linkedListType::destroyList() { nodeType *temp; //pointer to deallocate the memory while (first != nullptr) //while there are nodes in { temp = first; //set temp to the current node first = first->link; //advance first to the next node delete temp; //deallocate the memory occupied by temp } last = nullptr; //initialize last to nullptr; first has count = 0; }

template void linkedListType::initializeList() { destroyList(); //if the list has any nodes, delete them }

template void linkedListType::print() const { nodeType *current; //pointer to traverse the list

current = first; //set current so that it points to //the first node while (current != nullptr) //while more data to print { cout << current->info << " "; current = current->link; } }//end print

template int linkedListType::length() const { return count; } //end length

template Type linkedListType::front() const { assert(first != nullptr);

return first->info; //return the info of the first node }//end front

template Type linkedListType::back() const { assert(last != nullptr);

return last->info; //return the info of the last node }//end back

template linkedListIterator linkedListType::begin() { linkedListIterator temp(first);

return temp; }

template linkedListIterator linkedListType::end() { linkedListIterator temp(nullptr);

return temp; }

template void linkedListType::copyList (const linkedListType& otherList) { nodeType *newNode; //pointer to create a node nodeType *current; //pointer to traverse the list

if (first != nullptr) //if the list is nonempty, make it empty destroyList();

if (otherList.first == nullptr) //otherList is empty { first = nullptr; last = nullptr; count = 0; } else { current = otherList.first; //current points to the //list to be copied count = otherList.count;

//copy the first node first = new nodeType; //create the node

first->info = current->info; //copy the info first->link = nullptr; //set the link field of //the node to nullptr last = first; //make last point to the //first node current = current->link; //make current point to //the next node

//copy the remaining list while (current != nullptr) { newNode = new nodeType; //create a node newNode->info = current->info; //copy the info newNode->link = nullptr; //set the link of //newNode to nullptr last->link = newNode; //attach newNode after last last = newNode; //make last point to //the actual last node current = current->link; //make current point //to the next node }//end while }//end else }//end copyList

template linkedListType::~linkedListType() //destructor { destroyList(); }//end destructor

template linkedListType::linkedListType (const linkedListType& otherList) { first = nullptr; copyList(otherList); }//end copy constructor

//overload the assignment operator template const linkedListType& linkedListType::operator= (const linkedListType& otherList) { if (this != &otherList) //avoid self-copy { copyList(otherList); }//end else

return *this; }

#endif