Write a program that simulates a playlist of songs. This will be implemented by a singly-linked list. The user will manage the playlist from a menu of options shown below. The user should then select...

Playlist.cpp
Playlist.cpp
// Playlist.cpp
// DO NOT INCLUDE ANYTHING OTHER THAN THESE LIBRARIES/CLASSES
#include 
#include "Playlist.h"
using namespace std;
//Default and only constructor -- call private function init
Playlist::Playlist()
{
  head = nullptr;
  nodeCount = 0;
}
//Destructor -- call private function eraseList with head
Playlist::~Playlist()
{
  eraseList(head);
}
// Accessor method to get the number of nodes.
int Playlist::getNodeCount()
{
  return nodeCount;
}
//Add a SongNode to the front of the list
void Playlist::insertFront(SongNode* songNode)
{
  if(head == nullptr)
    head = songNode;
  else 
  {
    songNode->setNext(head);
    head = songNode;
  }
  ++nodeCount;
}
//Remove an SongNode from the list; if the value doesn't exist in the list return false;
//   otherwise search for the SongNode, adjust pointers, and return true.
bool Playlist::remove(string id)
{
  if(!contains(id))
    return false;

  SongNode* prev = nullptr;
  SongNode* curr = head;
  if(id == head -> getUniqueID())
  {
    head = head->getNext();
    free(curr);
  }
  else
  {
    while(curr != nullptr)
    {
      if(id == curr -> getUniqueID())
      {
        prev -> setNext(curr -> getNext());
        free(curr);
        return true;
      }
      prev = curr;
      curr = curr -> getNext();
    }
  }
  return true;
}
//This function is the most complicated
// songPosition and newPosition values have been validated in main
//      before this function is called
void Playlist::changeSongPosition(int songPosition, int newPosition)
{
    // STEP 1: Find songNode that is at songPosition
  SongNode* a = head;
  SongNode* prev = nullptr;
  for(int i = 0; i < songPosition - 1; ++i)
  {
    prev = a;
    a = a -> getNext();
  }
    // STEP 2: Remove songNode at songPosition from list. Keep reference to that songNode.
  if(songPosition == 1)
    head = head -> getNext();
  else 
    prev -> setNext(a -> getNext());
    // At this point songNode is no longer in the list
    // STEP 3: Insert song at newPosition
  if(newPosition == 1)
  {
    a -> setNext(head);
    head = a;
  }
  else
  {
    SongNode* temp = head;
    for(int i = 0; i < newPosition - 2; ++i)
      temp = temp -> getNext();
    insertAfter(temp, a);
  }
}
// insertAfter ... inserts newNode after prevNode
void Playlist::insertAfter(SongNode* prevNode, SongNode* newNode)
{
  SongNode* n = prevNode->getNext();
  if(n == nullptr)
    prevNode -> setNext(newNode);
  else
  {
    newNode -> setNext(n);
    prevNode -> setNext(newNode);
  }
}
// calculate total time in seconds in playlist
int Playlist::getTotalTime()
{
  int total = 0;
  SongNode* curr = head;
  while(curr != nullptr)
  {
    total += curr -> getSongLength();
    curr = curr->getNext();
  }
  return total;
}
// Print out all nodes in the list
void Playlist::printPlaylist()
{
  printTableHeadings();
  SongNode* curr = head;
  int position = 1;
  while(curr != nullptr)
  {
    printTableRow(curr, position);
    curr = curr->getNext();
    ++position;
  }
}
// Print out all nodes in the list with the artist's name
void Playlist::printByArtist(string artist)
{
  printTableHeadings();
  SongNode* curr = head;
  int position = 1;
  while(curr != nullptr)
  {
    if(artist == curr->getArtistName())
      printTableRow(curr, position);
    curr = curr->getNext();
    ++position;
  }
}
// Search to see if list contains the uniqueID
bool Playlist::contains(const string& id)
{
  SongNode* curr = head;
  while(curr != nullptr)
  {
    if(id == curr->getUniqueID())
      return true;
    curr = curr->getNext();
  }
  return false;
}
// Clear the list -- remove all nodes and initialize the playlist again
void Playlist::clearList()
{
  eraseList(head);
  init();
}
// Set up linked list starting values
void Playlist::init()
{
  nodeCount = 0;
  head = nullptr;
}
// Delete all allocated objects
void Playlist::eraseList(SongNode* head)
{
  if(head == nullptr)
    return;
  eraseList(head->getNext());
  ...