Trying to use a linked list with ADT, but getting an unexpected error that I am unsure about

[Elliander]

I am attempting to write a doubly linked list with abstract data types to store class objects from files passed to the program as command line arguments. At the present point, I am simply trying to get the linked list to work with anything so it's currently a singly linked list. Much of the other parts of the program present are just for testing things little by little.

Everything compiles and runs correctly, which I tested every time I made a change, but then when I tried to actually use the linked list things started to break. Currently, I am trying to just have it hold an integer as the first step and then when it works I will try to get it to hold objects.

Using either of these declarations work to create a list object:


sleepRecordList<typedef> list;

or

sleepRecordList<int> list;

However, when I try to insert an integer into the list like so:

list.insertLast(1);

I get this error:

Error LNK2019 unresolved external symbol "public: void __thiscall sleepRecordList<int>::insertLast(int const &)" (?insertLast@?$sleepRecordList@H@@QAEXABH@Z) referenced in function _main

Error LNK1120 1 unresolved externals

To me, it sounds like a mismatch between the header and the .cpp file, but I didn't see a problem there so then I removed const from it and got this error instead:

Error C2244 'sleepRecordList<Type>::insertLast': unable to match function definition to an existing declaration

Here's what the method looks like that I am trying to access:

template<class Type>
void sleepRecordList<Type>::insertLast(const Type & item)
{
    Node<Type> *newNode;
    newNode = new Node<Type>;
    newNode->data = item;
    newNode->link = nullptr;

    if (first == nullptr)
    {
        first = newNode;
        last = newNode;
        count++;
    }
    else
    {
        last->link = newNode;
        last = newNode;
    }
}

In my program I am not using namespace std; instead I am using each part of the namespace as I need it, but in the off-chance I missed something I added using namespace std; and then I got these errors instead:

Error C2872 'end': ambiguous symbol

Each time I tried using that object, which incidentally worked fine before adding the entire namespace and the old error comes back when removing them so I am fairly certain now that I'm not missing something simply like that.




Now, I expect that someone would want to see more than this, and I'm not sure just how much will be needed, so the following is the entire program typed out with file name labels:

(will have to put it in a reply, because of max characters)

[Elliander]

include.h

  #pragma once

#include <iostream>
#include <string>
#include <sstream>
#include <iostream> 
#include <iomanip>
#include <fstream>
#include <algorithm>
#include <stdlib.h>

//"using" explicitly as needed rather than the entire namespace. 
// Seems to work as well as the #define approach. 
// If a situation should arise where two namespaces have the same word I want to use, 
// I'd #define the second with a different name

using std::cout;
using std::cin;
using std::endl;
using std::string;
// #define string std::string   
using std::ifstream;
using std::stringstream;
using std::getline;
using std::strcpy;
using std::remove_if;
using std::cerr;
using std::to_string;
using std::setfill;
using std::setw;
using std::logic_error;

class.h

#pragma once
#include "include.h"

enum class checkStatus
{
    Invalid_Status,
    OK,
    Out_Of_Range
};
// TODO: Implement the above and rewrite normalize to use

class Time
{
protected:
    int hour;
    int min;
    int sec;
public:
    Time();
    Time(int hour, int min, int sec);

    long diff(const Time time) const;            // return difference in time in sec
    void diff(const Time start, const Time end); // compute difference in time

    //Setters:
    void setTime(int hour, int min, int sec);
    void setHour(int hour);
    void setMinute(int min);
    void setSecond(int sec);

    //Getters:
    int getHour() const;
    int getMinute() const;
    int getSecond() const;

    //Copy constructor
    Time(const Time &time);

    string toString() const;
    void addTime(const Time time);
    void addTime(const long sec);

    //Destructor
    ~Time();

private:
    void normalize();

};

class Date
{
public:
    int	day;
    int	month;
    int	year;
    string	toString();

    //Destructor
    ~Date();
};

class Sleep //: public Time
{
public: 
    Time startTime;
    Time endTime;
    Date startDate;
    Date endDate;
    int playerNumber;   // expect 0 - 99
    string playerName;  // Last name given so may not be unique

    //	need	operator=
    string	toString()	const;

    //// The following no longer needed:
    //int dayStart;       // Expect 1 - 31
    //int monthStart;     // Expect 1 - 12
    //int yearStart;      // Expect 2017 or larger
    //int hourStart;      // expect 0 - 23
    //int minuteStart;    // expect 0 - 59
    //int secondStart;    // expect 0 - 59
    //int dayEnd;         // expect 1 - 31
    //int monthEnd;       // Expect 1 - 12
    //int yearEnd;        // Expect 2017 or larger
    //int hourEnd;        // Expext 0 - 23
    //int minuteEnd;      // Expect 0 - 59
    //int secondEnd;      // expect 0 - 59
};

template <class Type>
class Node
{
public:
    Type data;
    Node<Type> *link;
};

template <class Type>
class sleepIterator : public Node<Type>
{
private:
    Node<Type> *current;
public:
    sleepIterator();
    sleepIterator(Node<Type> * );
    Type operator * (); //dereference operator
    sleepIterator<Type> operator++(); //increment operator
    bool operator==(const sleepIterator<Type>&) const;
    bool operator!=(const sleepIterator<Type>&) const;
};

template <class Type>
class sleepNode
{
protected:
    int count;
    Node<Type> *first;
    Node<Type> *last;
private:
    void copyList(const sleepNode<Type>&);
public:
    const sleepNode<Type> & operator=(const sleepNode<Type> &);
    void initializeList();
    bool isEmptyList() const;
    void print() const;
    int length() const;
    void destroyList();
    Type front() const;
    Type back() const;
    virtual bool search(const Type &) const = 0;
    virtual void insertFirst(const Type&) = 0;
    virtual void insertLast(const Type&) = 0;
    virtual void deleteNode(const Type&) = 0;
    sleepNode<Type> begin();
    sleepNode<Type> end();
    sleepNode();
    sleepNode(const sleepNode<Type> &);
    ~sleepNode();
};

template <class Type>
class sleepRecordList
{
public:
    bool search(const Type &) const;
    void insertFirst(const Type &);
    void insertLast(const Type &item);
    void deleteNode(const Type &);

};

[Elliander]

main.cpp

#pragma warning(disable: 4996) 
// This was required in order to compile in Visual Studios 2015 because 
// it doesn't like sscanf

#include "class.h"
#include "include.h"

const int maxLines = 100; // Max students
const int maxDays = 31; // Max days in month

// Prototypes
ifstream *openFileWithCheck(string name);

Time start;
Time end;
Time total;
sleepRecordList<Sleep> student;

int main(int argc, char *argv[])
{
    string name = "data.csv"; //This is the filename used
    ifstream *inFile;

    Sleep singleStudentRecord;
    // to meet the requirement to report the bytes stores for each sleep period
    cout << "Size of core record: " << sizeof(singleStudentRecord) << " bytes." << endl; 
    // an interesting extra I was curious about
    cout << "Size of sleep record list: " << sizeof(student) << " byte(s)." << endl << endl;

    if (argc < 2) 
    {
        cout << "No file name given." << endl;
        //TODO: Return string assignment and use the 
        //following when ready to only use command line arguments:
        
        // return(1);
    }
    else
    {
        for (int i = 1; i < argc; i++) 
        {
            
            name = argv[i];

                            // These functions called for each filename given
            inFile = openFileWithCheck(name); 

            //fileAccess(inFile, players);
        }
    }

    

    start.addTime(10000);
    end.addTime(1200);

    start.addTime(10000);
    end.addTime(1200);

    long sec = 0;

    sec += start.diff(end); // time difference

    total.addTime(sec);

    cout << total.toString() << endl << endl;

        /*     The following just to test usage of linked list     */
    sleepRecordList<typedef> list; 
//trying to use anonymous types to test because I want to be able to store the entire record

    //// Doesn't compile when I use the following. 
    //// It says "Unresolved external symbol referenced in main"

//    list.insertLast(1);
//    list.insertLast(2);
//    list.insertLast(3);




     
     /*  -----------------------------------------------------  */

    system("pause");

    return(0);
}

ifstream *openFileWithCheck(string name)
{
    ifstream *inFile;
    inFile = new ifstream(name);

    if (inFile->fail())
    {
        cout << "Invalid file name in the current directory." << endl;
        exit(EXIT_FAILURE);
    }
    else
    {
        string temp1;
        getline(*inFile, temp1);
        cout << temp1;
        return(inFile);
    }
    return(inFile);
}

[Elliander]

class.cpp

  #include "class.h"
#include "include.h"

/* --- Begin Time class --- */

Time::Time() 
{
    hour = 0;
    min = 0;
    sec = 0;
}

Time::Time(int hour, int min, int sec)
{
    this->setTime(hour, min, sec);
}

Time::Time(const Time &time)
{
    //Shallow copying non-pointers
    hour = time.hour;
    min = time.min;
    sec = time.sec;

    ////Following used to test the copy constructor. 
    //cout << "Copy constructor called" << endl;

}

string Time::toString() const {

    string result;
    result = std::to_string(hour) + ":" + to_string(min) + ":" + to_string(sec);
    return result;
}

long Time::diff(const Time time) const 
{
    long diff = 0;

    diff += sec - time.sec;
    diff += (min - time.min) * 60;
    diff += (hour - time.hour) * 3600;
    return diff;
}

void Time::diff(const Time start, const Time end)
{
}

void Time::setTime(int hour, int min, int sec)
{
    setHour(hour);
    setMinute(min);
    setSecond(sec);
}

void Time::setHour(int hour)
{
    this->hour = hour;
}

void Time::setMinute(int min)
{
    this->min = min;
}

void Time::setSecond(int sec)
{
    this->sec = sec;
}

int Time::getHour() const
{
    return this->hour;
}

int Time::getMinute() const
{
    return this->min;
}

int Time::getSecond() const
{
    return this->sec;
}

void Time::addTime(const Time time) {
    min += time.min;
    sec += time.sec;
    hour += time.hour;
    normalize();
}

void Time::addTime(const long sec) {
    this->sec += sec;
    normalize();
}

Time::~Time()
{
    //// The following used to test:
    // cout << "Destructor Called!" << endl;
}

void Time::normalize() {
    min += sec / 60;
    sec = sec % 60;
    hour += min / 60;
    min = min % 60;
}

/* --- Begin Date class --- */


string Date::toString()
{
    return string();
}

Date::~Date()
{
}

/* --- Begin Sleep class --- */

string Sleep::toString() const
{
    return string();
}

/* --- Begin Node class --- */


/* --- Begin sleepIterator class --- */


template<class Type>
sleepIterator<Type>::sleepIterator() //constructor
{
    current = nullptr;
}

template<class Type>
sleepIterator<Type>::sleepIterator(Node<Type>*) //constructor with parameters
{
    current = ptr;
}

template<class Type>
Type sleepIterator<Type>::operator*() //deference overload
{
    return current->data;
}

template<class Type>
sleepIterator<Type> sleepIterator<Type>::operator++() //increment overload
{
    current = current->link;
    return *this;
}

template<class Type>
bool sleepIterator<Type>::operator==(const sleepIterator<Type>&) const //equality operator
{
    return (current == other.current);
}

template<class Type>
bool sleepIterator<Type>::operator!=(const sleepIterator<Type>&) const //inequality operator
{
    return (current != other.current);
}

/* --- Begin sleepNode class --- */

template<class Type>
void sleepNode<Type>::copyList(const sleepNode<Type>&)
{
    Node<Type> *newNode, *current;
    
    if (first != nullptr)
    {
        destroyList();
    }

    if (other.first == nullptr)
    {
        first = nullptr;
        last = nullptr;
        count = 0
    }
    else
    {
        current = other.first;
        count = other.count;
        first = new Node<Type>;
        first->data = current->data;
        first->link = nullptr;
        current = current->link;

        while (current != nullptr)
        {
            newNode = new Node<Type>;
            first->data = current->data;
            newNode->link = nullptr;
            last = newNode;
            current = current->link;
        }
    }
}

template<class Type>
const sleepNode<Type>& sleepNode<Type>::operator=(const sleepNode<Type>&)
{
    if (!= &other)
    {
        copyList(other);
    }
    return *this;
}

template<class Type>
void sleepNode<Type>::initializeList() // reinitializes the list to empty
{
    destroyList();
}

template<class Type>
bool sleepNode<Type>::isEmptyList() const
{
    return(first == nullptr);
}

template<class Type>
void sleepNode<Type>::print() const
{
    Node<Type> *current;
    current = first;

    while (current != nullptr)
    {
        cout << current->data << " ";
        current = current->link;
    }
}

template<class Type>
int sleepNode<Type>::length() const
{
    return count;
}

template<class Type>
void sleepNode<Type>::destroyList()
{
    Node<Type> *temp;
    
    while (first != nullptr)
    {
        temp = first;
        first = first->link;
        delete temp;
    }

    last = nullptr;
    count = 0;
}

template<class Type>
Type sleepNode<Type>::front() const
{
    assert(first != nullptr)
    return first->data;
}

template<class Type>
Type sleepNode<Type>::back() const
{
    return Type();
}

template<class Type>
sleepNode<Type> sleepNode<Type>::begin()
{
    sleepNode<Type> temp(first);
    return temp;
}

template<class Type>
sleepNode<Type> sleepNode<Type>::end()
{
    sleepNode<Type> temp(nullptr);
    return temp;
}

template<class Type>
sleepNode<Type>::sleepNode()
{
    first = nullptr;
    last = nullptr;
    count = 0;
}

template<class Type>
sleepNode<Type>::sleepNode(const sleepNode<Type>& other)
{
    first = nullptr;
    copyList(other);
}

template<class Type>
sleepNode<Type>::~sleepNode()
{
}

/* --- Begin sleepRecordList class --- */

template<class Type>
bool sleepRecordList<Type>::search(const Type & searchItem) const
{
    Node<Type> *current;
    bool found = false;
    current = first;

    while (current != nullptr && !found)
    {
        if (current->data == searchItem)
        {
            found = true;
        }
        else
        {
            current = current->link;
        }
    }

    return found;
}

template<class Type>
void sleepRecordList<Type>::insertFirst(const Type & item)
{
    Node<Type> *newNode;
    newNode = new Node<Type>;
    newNode->data = item;
    newNode->link = first;
    first = newNode;
    count++;

    if (last == nullptr)
    {
        last = newNode;
    }
}

template<class Type>
void sleepRecordList<Type>::insertLast(const Type & item)
{
    Node<Type> *newNode;
    newNode = new Node<Type>;
    newNode->data = item;
    newNode->link = nullptr;

    if (first == nullptr)
    {
        first = newNode;
        last = newNode;
        count++;
    }
    else
    {
        last->link = newNode;
        last = newNode;
    }
}

template<class Type>
void sleepRecordList<Type>::deleteNode(const Type & item)
{
    Node<Type> *current, *trailCurrent;
    bool found;

    if (first == nullptr)
    {
        cout << "This is an empty list." << endl;
    }
    else
    {
        if (first->data == item)
        {
            current = first;
            first = first->link;
            count--;
            if (first == nullptr)
            {
                last = nullptr;
            }
            else
            {
                found = false;
                trailCurrent = first;
                current = first->link;

                while (current != nullptr && !found)
                {
                    if (current->data != item)
                    {
                        trailCurrent = current;
                        current = current->link;
                    }
                    else
                    {
                        found = true;
                    }
                }

                if (found)
                {
                    trailCurrent->link = current->link;
                    count--;

                    if (last == current)
                    {
                        last = trailCurrent;
                    }

                    delete current;
                }
                else
                {
                    cout << "List does not contain the item requested." << endl;
                }
            }
        }
    }
}

That's the entire program as it is right now, which compiles and runs with the problem area commented out with comments noting it in main.cpp