Develop a template of linked list class and its methods

// File name: LinkedList.h

#include <iostream>
using namespace std;

// Use of templates.
template <class T>
class LinkedList
{
private:
struct ListNode
{
T value;
ListNode * next;
ListNode(T value1, ListNode * next1 = NULL)
{
value = value1;
next = next1;
}
};

ListNode * head;

// List head pointer

public:
LinkedList() { head = NULL; }

//Constructor

~LinkedList();

// Destructor

void add(T value);

void remove(T value);
void displayList();
};

// Adds a new element to the end of the list. *

template <class T>
void LinkedList<T>::add(T value)
{
if (head == NULL)
head = new ListNode(value);
else
{
// The list is not empty.
// Use nodePtr to traverse the list
ListNode * nodePtr = head;
while (nodePtr->next != NULL)
nodePtr = nodePtr->next;

// nodePtr->next is NULL so nodePtr points to the last node.

// Create a new node and put it after the last node.
nodePtr->next = new ListNode(value);
}
}

// Removes a number from a list. The function *

// does not assume that the list is sorted.

template <class T>

void LinkedList<T>::remove(T value)
{
ListNode * nodePtr;
ListNode *previousNodePtr;

// If the list is empty, do nothing.

if (!head) return;

// Determine if the first node is the one to delete.

if (head->value == value)
{
nodePtr = head;
head = head->next;
delete nodePtr;
}
else
{
// Initialize nodePtr to the head of the list.
nodePtr = head;

// Skip nodes whose value member is not num.

while (nodePtr != NULL && nodePtr->value != value)
{

previousNodePtr = nodePtr;
nodePtr = nodePtr->next;
}
// Link the previous node to the node after
// nodePtr, then delete nodePtr.
if (nodePtr)
{
previousNodePtr->next = nodePtr->next;
delete nodePtr;
}
}
}

// displayList outputs a sequence of all values *

// currently stored in the list.

template <class T>

void LinkedList<T>::displayList()
{
ListNode * nodePtr = head; // Start at head of list
while (nodePtr)
{
// Print the value in the current node
cout << nodePtr->value << endl;
// Move on to the next node
nodePtr = nodePtr->next;
}

// Destructor deallocates the memory used by the list. *

template <class T>
LinkedList<T>::~LinkedList()
{
ListNode * nodePtr = head; // Start at head of list
while (nodePtr != NULL)
{
// garbage keeps track of node to be deleted
ListNode * garbage = nodePtr;
// Move on to the next node, if any
nodePtr = nodePtr->next;
// Delete the "garbage" node
delete garbage;
}
}

// File name: driver.cpp

#include <string>
using namespace std;

#include "LinkedList.h"

int main()
{

LinkedList<string> list;
string name;

cout << "Add 3 names to the Linked List:\n";

for (int i = 0; i < 3; i++)
{
cout << "Name #" << i + 1 << ": ";
getline(cin, name);
list.add(name);
}

cout << "\nHere are the names in the Linked List:\n";

list.displayList();

cout << "\nEnter a name to delete: ";

getline(cin, name);
list.remove(name);

cout << "\nNames that remain in the Linked List:\n";

list.displayList();

cout << endl;

return 0;
}