Question

// I understand what I have to do on a fundamental level however I am having trouble just grasping how to implement them into the program. Explanation greatly appreciated!

The files section has a gutted List class for you. Just write all the methods. Easy peasy. Just remember that if your code never calls a template method, the compiler deletes it entirely. Make sure you test everything.

List's big three: Destructor, Copy, Assignment. Vanilla constructor is right - don't change it. PushFront: Add a new node as the new first piece of data.

Do NOT add anything before Head.

PopFront: Remove the first piece of data if there is one.

Front: Return the first piece of data.

PushBack: Add a new node as the new first piece of data. Do NOT add anything before Head.

PopBack: Remove the first piece of data if there is one.

Back: Return the first piece of data.

Size: How many things.

Clear: Remove all data, leave head and tail.

At: Return data at that position. 0 is first data

List.h

#pragma once

template <typename T>

class List

{

struct ListNode

{

ListNode()

{

mPrev = nullptr;

mNext = nullptr;

}

T mData;

ListNode* mPrev;

ListNode* mNext;

};

ListNode* mHead;

ListNode* mTail;

T mUndefined;

public:

List()

{

// Getting Head and Tail correct is not part of the Big 3. It is hella

mega required no matter what.

//mHead = nullptr;

//mTail = nullptr;// bleh. Full of crash.

mHead = new ListNode;

mTail = new ListNode;

mHead->mNext = mTail;

mHead->mPrev = nullptr;

mTail->mPrev = mHead;// This RULES. We always know we have 2 nodes, so

we never have to check for null.

mTail->mNext = nullptr;

}

List(const List& tOther)

{

}

List& operator = (const List& tRHS)

{

}

~List()

{

}

void PushFront(const T& tWhat)

{

}

void PopFront()

{

}

T& Front()

{

return mUndefined;

}

void PushBack(const T& tWhat)

{

}

void PopBack()

{

}

T& Back()

{

return mUndefined;

}

int Size() const

{

return 0;

}

void Clear()

{

}

T& At(int tWhere) const

{

}

};

/ ListStart.cpp : This file contains the 'main' function. Program execution begins

and ends there.

//

#include <iostream>

#include "List.h"

using namespace std;

int main()

{

List<int> tSomeInts;

tSomeInts.PushBack(14);// 14

tSomeInts.PushBack(1);// 14 1

tSomeInts.PushBack(54);// 14 1 54

tSomeInts.PushBack(25);// 14 1 54 25

List<int> tIntCopy = tSomeInts;// 14 1 54 25

tSomeInts.PopBack();// 14 1 54

cout << "This better say 4: " << tIntCopy.Size() << endl;

cout << "This better say 3: " << tSomeInts.Size() << endl;

cout << "This better say 14: " << tSomeInts.Front() << endl;

cout << "This better say 54: " << tSomeInts.Back() << endl;

return 0;

}

Answer 1

List.h

==========================

#pragma once
template <typename T>
class List
{
   struct ListNode
   {
       ListNode()
       {
           mPrev = nullptr;
           mNext = nullptr;
       }
       T mData;
       ListNode* mPrev;
       ListNode* mNext;
   };
   ListNode* mHead;
   ListNode* mTail;
   T mUndefined; // why need this?
public:
   List()
   {
       // Getting Head and Tail correct is not part of the Big 3. It is hellamega required no matter what.
       //mHead = nullptr;
       //mTail = nullptr;// bleh. Full of crash.
       mHead = new ListNode;
       mTail = new ListNode;
       mHead->mNext = mTail;
       mHead->mPrev = nullptr;
       mTail->mPrev = mHead;// This RULES. We always know we have 2 nodes, so we never have to check for null.
       mTail->mNext = nullptr;
   }

   List(const List& tOther)
   {
       // use assignment operator for copy constructor
       *this = tOther;
   }

   List& operator = (const List& tRHS)
   {
       // initialize front and back
       mHead = new ListNode;
       mTail = new ListNode;
       mHead->mNext = mTail;
       mHead->mPrev = nullptr;
       mTail->mPrev = mHead;
       mTail->mNext = nullptr;
       // create iterator for RHS
       ListNode* itr = tRHS.mHead->mNext;
       // loop through RHS list and copy each node
       while (itr != tRHS.mTail) {
           // create a new node before tail
           ListNode* node = new ListNode;
           // copy data to new node
           node->mData = itr->mData;
           // link the node on left
           mTail->mPrev->mNext = node;
           node->mPrev = mTail->mPrev;
           // link the node on right
           node->mNext = mTail;
           mTail->mPrev = node;
           itr = itr->mNext;
       }
       // return the list
       return *this;
   }

   ~List()
   {
       ListNode* temp = mHead; // create iterator
       // remove each node from list
       while (mHead != mTail) {
           // move to next node and delete current node
           mHead = mHead->mNext;
           delete temp;
           temp = mHead;
       }
       // delete last node
       delete temp;
   }

   void PushFront(const T& tWhat)
   {
       // create new node
       ListNode* node = new ListNode;
       // get data
       node->mData = tWhat;
       // link the node on right
       mHead->mNext->mPrev = node;
       node->mNext = mHead->mNext;
       // link the node on left
       node->mPrev = mHead;
       mHead->mNext = node;
   }

   void PopFront()
   {
       // remove first node if it exist
       if (mHead != mTail) {
           ListNode* temp = mHead->mNext;
           // remove nodes link
           mHead->mNext->mNext->mPrev = mHead;
           mHead->mNext = mHead->mNext->mNext;
           delete temp;
       }
   }

   T& Front()
   {
       return mHead->mNext->mData;
   }

   void PushBack(const T& tWhat)
   {
       // create new node
       ListNode* node = new ListNode;
       // get data
       node->mData = tWhat;
       // link the node on left
       node->mPrev = mTail->mPrev;
       mTail->mPrev->mNext = node;
       // link the node on right
       node->mNext = mTail;
       mTail->mPrev = node;
   }

   void PopBack()
   {
       // remove first node if it exist
       if (mHead != mTail) {
           ListNode* temp = mTail->mPrev;
           // remove nodes link
           mTail->mPrev->mPrev->mNext = mTail;
           mTail->mPrev = mTail->mPrev->mPrev;
           delete temp;
       }
   }

   T& Back()
   {
       return mTail->mPrev->mData;
   }

   int Size() const
   {
       // create varaible to count nodes
       int count = 0;
       ListNode* itr = mHead->mNext; // create iterator
       // loop through list to count nodes
       while (itr != mTail) {
           count++;
           itr = itr->mNext;
       }
       return count;
   }

   void Clear()
   {
       ListNode* temp = mHead->mNext; // create iterator
       // remove each node from list
       while (temp != mTail) {
           // move to next node and delete current node
           mHead = mHead->mNext;
           delete temp;
           temp = mHead->mNext;
       }
       // delete last node
   }

   T& At(int tWhere) const
   {
       ListNode* itr = mHead->mNext; // create iterator
       // move to given index using for loop
       for (int i = 0; i < tWhere; i++) {
           itr = itr->mNext;
       }
       // return the element
       return itr->mData;
   }

};

=============================

ListStart.cpp

=============================

#include <iostream>
#include "List.h"
using namespace std;

int main()
{
   List<int> tSomeInts;
   tSomeInts.PushBack(14);// 14
   tSomeInts.PushBack(1);// 14 1
   tSomeInts.PushBack(54);// 14 1 54
   tSomeInts.PushBack(25);// 14 1 54 25
   tSomeInts.PushFront(18);//18 14 54 25
   cout << "This better say 18: " << tSomeInts.Front() << endl;
   tSomeInts.PopFront();// 14 1 54 25
   List<int> tIntCopy = tSomeInts;// 14 1 54 25
   tSomeInts.PopBack();// 14 1 54
   cout << "This better say 4: " << tIntCopy.Size() << endl;
   cout << "This better say 3: " << tSomeInts.Size() << endl;
   cout << "This better say 14: " << tSomeInts.Front() << endl;
   cout << "This better say 54: " << tSomeInts.Back() << endl;

   return 0;
}

let me know if you have any problem or doubt. thank you.