硬件：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

编辑：编译器似乎说Object 中的 CompareTo() 方法未在任何派生类中实现。但是，此功能是在名为“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：公共虚拟容器
  {
  民众：
      虚拟对象& top() const = 0; // 短期访问对象，没有所有权转移，这里引用就可以了。
      虚拟无效推（对象*）= 0； // 指针保留，所有权转移，使用指针
      虚拟对象* Pop () = 0; // 所有权转移（调用者必须删除），使用指针
  };
  

• 然后，您应该对 Visitor 实现中的损坏采取一些措施。现在，无论动态类型如何，Accept 始终调用 Visit(Object&)。您需要对每个单独的成员调用虚拟 Accept 函数，以便让 Visitor 在多态集合上正确执行。

至此，我们已经开始放弃设计了。