Where am I going wrong in constructing my LinkedList class?

I've re-declared the pure-virtual methods from IList in your LinkedList class, but LinkedList seems to be getting treated like an abstract class and so the compiler doesn't seem to allow me to create a LinkedList object in my main function:

main.cpp

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

int main()
{
   int A[] {1, 2, 3, 4, 5};
   LinkedList l(A, 5);

   cout << l.getCurrentSize()<<endl;
   l.display();

   return 0;
}

LinkedList.h

#ifndef LINKED_LIST_
#define LINKED_LIST_

#include "IList.h"

class LinkedList : public IList
{
protected:
    struct Node
    {
        int data;
        struct Node* next;
    };
    struct Node* first;

public:
    // constructor
    LinkedList() { first = nullptr; }
    LinkedList(int A[], int n);

    // accessors    void display();
    virtual int getCurrentSize();

    //destructor
    virtual ~LinkedList();
};

#endif

LinkedList.cpp

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

// constructor
LinkedList::LinkedList(int A[], int n)
{
    Node* last, * t;
    int i = 0;
    first = new Node;
    first->data = A[0];
    first->next = nullptr;
    last = first;
    for (i = 1; i < n; i  ) 
    {
        t = new Node;
        t->data = A[i];
        t->next = nullptr;
        last->next = t;
        last = t;
    }
};

// destructor
LinkedList::~LinkedList()
{
    Node* p = first;
    while (first) {
        first = first->next;
        delete p;
        p = first;
    }
}

void LinkedList::display()
{
    Node* p = first;

    while (p) 
    {
        cout << p->data >> " ";
        p = p->next;
    }
    cout << endl;
}

int LinkedList::getCurrentSize() const
{
    Node* p = first;
    int len = 0;
    while (p) 
    {
        len  ;
        p = p->next;
    }
    return len;
}

IList.h

//  Modified from code created by Frank M. Carrano and Timothy M. Henry.
//  Copyright (c) 2017 Pearson Education, Hoboken, New Jersey.

#ifndef I_LIST_
#define I_LIST_

class IList
{
public:
   /** Constructor */
   IList () : traverseCount(0) { }
    
   /** Destroys object and frees memory allocated by object.
    (See C   Interlude 2) */
   virtual ~IList () { }

   /** Gets the current number of entries in this list.
    @return The integer number of entries currently in the list. */
   virtual int getCurrentSize() const = 0;
   
   /** Sees whether this list is empty.
    @return True if the list is empty, or false if not. */
   virtual bool isEmpty() const = 0;
   
   /** Adds a new entry to this list.
    @post  If successful, newEntry is stored in the list and
       the count of items in the list has increased by 1.
    @param newEntry  The object to be added as a new entry.
    @return  True if addition was successful, or false if not. */
   virtual bool add(int newEntry) = 0;
   
   /** Removes one occurrence of a given entry from this list,
       if possible.
    @post  If successful, anEntry has been removed from the list
       and the count of items in the list has decreased by 1.
    @param anEntry  The entry to be removed.
    @return  True if removal was successful, or false if not. */
   virtual bool remove(int anEntry) = 0;
   
   /** Removes all entries from this list.
    @post  List contains no items, and the count of items is 0. */
   virtual void clear() = 0;
   
   /** Tests whether this list contains a given entry.
    @param anEntry  The entry to locate.
    @return  True if list contains anEntry, or false otherwise. */
   virtual bool contains(int anEntry) = 0;
    
   /** Get the count of number of nodes traversed.
    @return  The integer number of nodes traversed since last time the count was reset. */
    virtual int getTraverseCount() const { return traverseCount; }
     
   /** Reset the count of nodes traversed to zero. */
    virtual void resetTraverseCount() { traverseCount = 0; }
    
protected:
    int traverseCount;
}; // end IList

#endif

CodePudding user response：

Your IList is an abstract class with six pure virtual member functions. In order to create the instance of the derived one (i.e. LinkedList) you need to implement those functions inside the child as well.

class LinkedList : public IList
{
    // ..... other members

public:
    // ..... other members
    virtual int getCurrentSize() const override;
    bool isEmpty() const override { // implementation  }
    bool add(int newEntry) override {// implementation }
    bool remove(int anEntry) override { // implementation }
    bool contains(int anEntry) override { // implementation }
    void clear() override { // implementation}
};

Also recommended using the override specifier to override the virtual functions from the base class, so that both the compiler and the reader can easily recognize them, without looking into to the base.

Other Issues:

• Also note that your getCurrentSize() functions declaration in the child class (i.e. LinkedList) lacks a const.
• Typo at cout << p -> data >> " "; should be cout << p->data << " ";
• Why is "using namespace std;" considered bad practice?