H / W: C ++ Ошибка «попытка инициализировать абстрактный базовый класс»

Question

Попытка инициализировать класс с именем StackAsLinkedList, который должен быть производным классом абстрактного класса Stack (тестирующий код, который доступен здесь: http://www.brpreiss.com/books/opus4/).

Однако я получаю ошибку, пытаясь создать экземпляр этого кодав main ():

StackAsLinkedList stack;

error C2259: 'StackAsLinkedList' : cannot instantiate abstract class

Я запутался в этом, потому что я думал, что StackAsLinkedList определен как производный класс Stack:

#ifndef STACK_H
#define STACK_H

#include "object.h"
#include "linkList.h"
#include "container.h"

class Stack : public virtual Container
{
public:

    virtual Object& Top () const = 0;
    virtual void Push (Object&) = 0;
    virtual Object& Pop () = 0;
};

class StackAsLinkedList : public Stack
{
    LinkedList<Object*> list;

    class Iter;

public:

    StackAsLinkedList () : list() {}
    ~StackAsLinkedList() { Purge(); }

    //
    // Push, Pop and Top
    //
    void Push(Object& object);
    Object& Pop();
    Object& Top() const;

    //
    // purge elements from, and accept elements onto, the list
    //
    void Purge();
    void Accept (Visitor&) const;

    friend class Iter;
};

class StackAsLinkedList::Iter : public Iterator
{
    StackAsLinkedList const& stack;
    ListElement<Object*> const* position;

public:

    Iter (StackAsLinkedList const& _stack) : stack(_stack) { Reset(); }

    //
    // determine whether iterator is pointing at null
    //
    bool IsDone() const { return position == 0; }

    //
    // overloaded dereference and increment operator
    //
    Object& operator*() const;
    void   operator++() const;

    void Reset() { position = stack.list.Head(); }
};

#endif

Реализация:

#include "stack.h"

void StackAsLinkedList::Purge()
{
    if ( IsOwner() )
    {
        ListElement<Object*> const* ptr;

        for(ptr = list.Head(); ptr != 0; ptr = ptr->Next() )
            delete ptr->Datum();

        list.Purge();
        count = 0;
    }
}

void StackAsLinkedList::Push(Object& object)
{
    list.Prepend(&object);
    ++count;
}

Object& StackAsLinkedList::Pop()
{
    if(count == 0)
        throw domain_error ("stack is empty");

    Object& result = *list.First();
    list.Extract(&result);
    --count;
    return result;
}

Object& StackAsLinkedList::Top() const
{
    if(count == 0)
        throw domain_error ("stack is empty");

    return *list.First();
}

void StackAsLinkedList::Accept(Visitor& visitor) const
{
    ListElement<Object*> const* ptr;

    for(ptr = list.Head(); ptr != 0 && !visitor.IsDone(); ptr = ptr->Next())
    visitor.Visit(*ptr->Datum());
}

class Container:

#ifndef CONTAINER_H
#define CONTAINER_H

#include "object.h"
#include "visitor.h"
#include "iterator.h"
#include "ownership.h"

class Container : public virtual Object, public virtual Ownership
{
protected:

    unsigned int count;
Container () : count(0) {}

public:

    virtual unsigned int Count () const { return count; }
    virtual bool IsEmpty () const { return Count () == 0; }
    virtual bool IsFull () const { return false; }
    //virtual HashValue Hash () const;
    virtual void Put (ostream&) const;
    virtual Iterator& NewIterator () const { return *new NullIterator (); }

    virtual void Purge () = 0;
    virtual void Accept (Visitor&) const = 0;
 };

 #endif

EDIT: Похоже, что компилятор говорит, что метод CompareTo () в Object не реализован ни в одном из производных классов. Однако эта функциональность реализована впроизводный класс Object с именем "Wrapper":

#ifndef WRAPPER_H
#define WRAPPER_H

#include "object.h"


template <class T>
class Wrapper : public Object
{
protected:

    T datum;
    int CompareTo (Object const&) const;

public:

    Wrapper ();
    Wrapper (T const&);
    Wrapper& operator = (T const&);
    operator T const& () const;
    //HashValue Hash () const;
    void Put (ostream&) const;
};

//
// typedefs for for Wrappers representing different primitive
// data types
//
typedef Wrapper <int> Int;
typedef Wrapper <char> Char;
typedef Wrapper <double> Double;
typedef Wrapper <std::string> String;

#include "wrapper.inc"

#endif

Но Stack не наследуется от Wrapper - поэтому я предполагаю, что это означает, что для Stack должен быть реализован другой метод CompareTo? Не знаете, как получился оригинальный авторэто сработает (царапает голову).

Answer 1

Поскольку вы уже объяснили, что пытаетесь это исправить, я предлагаю:

• Первым шагом является компиляция, которую вы можете сделать, добавив CompareTo(Object&) constчлен StackAsLinkedList.Вы можете использовать механизм dynamic_cast или Visitor, чтобы выяснить, является ли сравниваемый объект другой коллекцией.

• Далее, в любом случае избавьтесь от опорных параметровбудет сохранен вызываемым пользователем и использован после возврата из функции.И искоренить ссылочные типы возврата, где право собственности передается.Вы можете использовать указатели или изменить коллекцию на передачу по значению (но не передавайте по значению, если коллекция должна быть полиморфной).Вы получите:

  class Stack : public virtual Container
  {
  public:
      virtual Object& Top () const = 0; // short-term access to object, no ownership transfer, reference is ok here.
      virtual void Push (Object*) = 0;  // pointer kept, ownership transfer, use pointer
      virtual Object* Pop () = 0;       // ownership transfer (caller must delete), use pointer
  };
  

• Затем вы должны что-то предпринять в отношении поломки в реализации Visitor.Прямо сейчас, Accept всегда вызывает Visit(Object&) независимо от динамического типа.Вам нужно было бы вызвать виртуальную функцию Accept для каждого отдельного члена, чтобы позволить Visitor корректно работать с полиморфными коллекциями.

Мы уже в путина слом дизайн к этому моменту.