I need help implementing this C++ header file for an ordered link list. I cannot get my insert method in my OrderedLinkedList.h to work with my other files. It is really confusing because I am required to return an integer. If you could please help me that would be great. The methods cannot be changed or any of the LinkedListTest.cpp. The program implements a generic ordered linked list, creates an instance of this list that contains Member objects, and reads existing member data. The information for each Member includes an Identification Number, Last Name, First Initial, and Yearly Dues.

OrderedLinkedList.h

----------------------------------------------------------

#ifndef ORDEREDLINKEDLIST_H

#define ORDEREDLINKEDLIST_H

#include

template

struct Node

{

Type info;

Node *next;

};

template

class OrderedLinkedList

{

public:

OrderedLinkedList();

OrderedLinkedList(const OrderedLinkedList& other);

~OrderedLinkedList();

OrderedLinkedList& operator=(const OrderedLinkedList& other);

void copyList(Node* dest, Node* src);

void deleteList(Node* src);

int insert(const Type&);

Type* find(int) const;

Type* get(int) const;

int remove(int);

void clear();

int size() const;

void print() const;

private:

Node* head;

Node* tail;

unsigned int count;

};

template

OrderedLinkedList::OrderedLinkedList()

{

head = nullptr;

tail = nullptr;

count = 0;

}

template

OrderedLinkedList::OrderedLinkedList(const OrderedLinkedList& other)

{

Node* cur = other.head;

head = nullptr;

tail = nullptr;

copyList(other.head, other.tail);

}

template

void OrderedLinkedList::deleteList(Node* src) {

Node* cur = src;

Node* tmp;

while (cur) {

tmp = cur->next;

delete cur;

cur = tmp;

}

}

template

OrderedLinkedList::~OrderedLinkedList()

{

this->deleteList(head);

}

template

OrderedLinkedList& OrderedLinkedList::operator=(const OrderedLinkedList& other)

{

if (this != &other) {

Node* old = head;

head = nullptr;

tail = nullptr;

copyList(other.head, other.tail);

deleteList(old);

}

return *this;

}

template

void OrderedLinkedList::copyList(Node* dest, Node*src) {

Node* cur = src;

head = nullptr;

Node* newNode = nullptr;

Node* next = nullptr;

while (cur) {

insert(cur->info);

cur = cur->next;

}

}

template

int OrderedLinkedList::insert(const Type& item)

{

Node *cur;

Node *trailcur;

Node *newNode;

bool found;

newNode = new Node;

newNode->info = item;

newNode->next = nullptr;

if (head == nullptr)

{

head = newNode;

tail = newNode;

count++;

return count;

}

else

{

cur = head;

found = false;

while (cur != nullptr && !found) {

if (cur->info >= item)

found = true;

else {

trailcur = cur;

cur = cur->next;

}

}

if (cur == head) {

newNode->next = head;

head = newNode;

count++;

return count;

}

else {

trailcur->next = newNode;

newNode->next = cur;

if (cur == nullptr)

tail = newNode;

count++;

return count;

}

}

}

template

Type* OrderedLinkedList::get(int dest) const

{

return nullptr;

}

template

Type* OrderedLinkedList::find(int dest) const

{

return nullptr;

}

template

int OrderedLinkedList::remove(int key)

{

return 0;

}

template

void OrderedLinkedList::clear()

{

}

template

int OrderedLinkedList::size() const

{

return -1;

}

template

void OrderedLinkedList::print() const

{

}

#endif

----------------------------------------------

MemberDo.h

---------------------------------------------

#ifndef MEMBERDO

#define MEBERDO

#include "LinkedList.h"

#include

class MemberDO

{

private:

int key;

std::string lastName;

char firstInit;

double dues;

public:

MemberDO();

MemberDO(int, std::string, char, double);

int getKey() const;

void setKey(int);

std::string getLastName() const;

void setLastName(std::string);

char getFirstInitial() const;

void setFirstInitial(char);

double getDues() const;

void setDues(double);

void print() const;

static void readFromFile(const char*, OrderedLinkedList&);

};

#endif

------------------------------------------

MemberDo.cpp

--------------------------------------------------

#include "MemberDO.h" #include #include

using namespace std;

MemberDO::MemberDO() { }

MemberDO::MemberDO(int k, string ln, char fi, double d) { }

int MemberDO::getKey() const { return 0; }

void MemberDO::setKey(int k) { }

string MemberDO::getLastName() const { return ""; }

void MemberDO::setLastName(string ln) { }

char MemberDO::getFirstInitial() const { return 0; }

void MemberDO::setFirstInitial(char fi) { }

double MemberDO::getDues() const { return 0; }

void MemberDO::setDues(double d) { }

void MemberDO::print() const { }

void MemberDO::readFromFile(const char* file, OrderedLinkedList& ll) {

MemberDO data; data.key = 6789; data.lastName = "Towson"; data.firstInit = 'J'; data.dues = 65.25; ll.insert(data); data.key = 3456; data.lastName = "Johns"; data.firstInit = 'K'; data.dues = 200.00; ll.insert(data); data.key = 1123; data.lastName = "Stevens"; data.firstInit = 'M'; data.dues = 112.35; ll.insert(data); data.key = 4489; data.lastName = "Ellwood"; data.firstInit = 'B'; data.dues = 700.25; ll.insert(data); data.key = 5555; data.lastName = "Pryor"; data.firstInit = 'R'; data.dues = 99.99; ll.insert(data); }

--------------------------------------------------------------------

LinkedListTest.cpp

-----------------------------------------------------------------------

#include "LinkedList.h"

#include "MemberDO.h"

#include

#include

using namespace std;

int total = 0;

int correct = 0;

//This helps with testing, do not modify.

template

bool checkTest(string testName, elemType whatItShouldBe, elemType whatItIs) {

total++;

if (whatItShouldBe == whatItIs) {

cout << "Passed " << testName << " Output was: " << whatItIs << endl;

correct++;

return true;

}

else {

cout << "***Failed test " << testName << " ** " << endl << " Output was "<< whatItIs << endl << " Output should have been " << whatItShouldBe << endl;

return false;

}

}

bool NULLCheckTest(string testName, void * input) {

total++;

if (input == nullptr) {

correct++;

cout << "Passed " << testName << " NULL test on find method." << endl;

return true;

}

else {

cout << "***Failed " << testName << "**" << endl << " Output was not NULL." << endl;

return false;

}

}

int main()

{

//Constructor empty list

OrderedLinkedList memberList;

checkTest("Test 1", 0, memberList.size());

MemberDO data;

data.setKey(2555);

data.setLastName("Smith");

data.setFirstInitial('J');

data.setDues(15.15);

//insert - empty list

checkTest("Test 2", 2555, memberList.insert(data));

checkTest("Test 3", 2555, memberList.get(0)->getKey());

checkTest("Test 4", 15.15, memberList.find(2555)->getDues());

//insert - first

MemberDO data1(25, "Rogers", 'A', 17.50);

memberList.insert(data1);

checkTest("Test 5", string("Rogers"), memberList.get(0)->getLastName());

//insert - last

memberList.insert(MemberDO(3100, "Jackson", 'M', 250.00));

checkTest("Test 6", 3100, memberList.get(2)->getKey());

//insert - middle

memberList.insert(MemberDO(2660, "Franklin", 'F', 20.00));

checkTest("Test 7", 'F', memberList.get(2)->getFirstInitial());

//First is still fisrt

checkTest("Test 8", 17.50, memberList.get(0)->getDues());

//get out of bounds

NULLCheckTest("Test 9", memberList.get(4));

NULLCheckTest("Test 10", memberList.get(-3));

//Check size

checkTest("Test 11", 4, memberList.size());

//clear

memberList.clear();

checkTest("Test 12", 0, memberList.size());

NULLCheckTest("Test 13", memberList.get(0));

//empty find

NULLCheckTest("Test 14", memberList.find(-3));

MemberDO::readFromFile("Member.dat", memberList);

// Key of 1st member on list

checkTest("Test 15", 1123, (memberList.find(1123))->getKey());

// Lastname of 2nd member on list

checkTest("Test 16", string("Johns"), (memberList.find(3456))->getLastName());

// First initial of 3rd member on list

checkTest("Test 17", 'B', (memberList.find(4489))->getFirstInitial());

// Dues of 4th member on list

checkTest("Test 18", 99.99, (memberList.find(5555))->getDues());

// Testing proper NULL response from find method

NULLCheckTest("Test 19", memberList.find(5));

//Check size

checkTest("Test 20", 5, memberList.size());

//Make copies

OrderedLinkedList copy(memberList);

OrderedLinkedList copy2;

copy2 = memberList;

// remove - middle

checkTest("Test 21", 4489, memberList.remove(4489));

// Key of first member on list

checkTest("Test 22", 1123, (memberList.get(0))->getKey());

// Lastname of last member on list

checkTest("Test 23", string("Towson"), (memberList.get(3))->getLastName());

// remove - first

memberList.remove(1123);

// Key of 1st member on list

checkTest("Test 24", 3456, (memberList.get(0))->getKey());

// Lastname of 6th member on list

checkTest("Test 25", string("Towson"), (memberList.find(6789))->getLastName());

// remove - last

memberList.remove(6789);

// Dues of last member on list

checkTest("Test 26", 99.99, (memberList.get(1))->getDues());

//Testing proper return value from remove method

checkTest("Test 27", -1, memberList.remove(6789));

//remove all

memberList.remove(5555);

memberList.remove(3456);

//Check size

checkTest("Test 28", 0, memberList.size());

//Check size

checkTest("Test 29", 5, copy.size());

//Check size

checkTest("Test 30", 5, copy2.size());

//Check size

checkTest("Test 31", 6789, copy.find(6789)->getKey());

//Check size

checkTest("Test 32", 6789, copy2.find(6789)->getKey());

cout << "Passed " << correct << "/" << total << " tests" << endl;;

cout << "Points earned: " << float(correct)/total*60 << " out of 60" << endl;

return 0;

}