从模板库覆盖纯虚函数 Class

Question

所以我正在尝试制作一个基于数组的包，它在添加到顶部的意义上表现得像一个堆栈，但它也可以检查和删除不在顶部的元素。

为了我的作业，我的教授给了我这个 bagADT class 模板，里面有纯虚函数。

#ifndef BAGADT_H
#define BAGADT_H

#include <stdlib.h>
#include "book.h"

template <typename E>
class Bag {
public:
    Bag() {}            // base constructor
    virtual ~Bag() {}   // base destructor
// Insert a new item into the bag -- return false if fails and true if
// successful
virtual bool addItem(const E& item) = 0;

// Looks for 'item' in the bag and if found updates 'item' with the 
// bag value and returns true.  Otherwise 'item' is left unchanged
// and the method returns false.
virtual bool remove(E& item) = 0;

// Removes the top record from the bag, puts it in returnValue, and
// returns true if the bag is not empty.  If the bag is empty the 
// function returns false and returnValue remains unchanged.
virtual bool removeTop(E& returnValue) = 0;

// Finds the record using returnValue and if the record is found updates
// returnValue based on the contents of the bag and returns true.  If the
// record is not found the function returns false.  Works just like remove()
// except that the found record is not removed from the bag.
virtual bool find(E& returnValue) const = 0;

// Inspect the top of the bag.  If the bag is empty return
// false and leave 'item' unchanged; otherwise, return true and update 
// 'item' with the contents of the bag.
virtual bool inspectTop(E& item) const = 0;

// empties the bag
virtual void emptyBag() = 0;

// use the += operator to add an item to the bag
virtual bool operator+=(const E& addend) = 0;

// get the size of the bag
virtual int size() const = 0;

// get the capacity of the bag
virtual int bagCapacity() const = 0;
};

#endif  /* BAGADT_H */

鉴于此，我创建了一个继承的 ABag class。

#pragma once
#include "bagADT.h"


#ifndef ABAG_H
#define ABAG_H

template <typename E>
class ABag : public Bag<E>
{
public:
    ABag(int size = 10)
    {
        maxSize = size;
        top = 0;
        listArray = new E[size];
    }
     virtual ~ABag()
    {
        delete[] listArray;
    }

    template <typename E>
    bool addItem(const E& item)
    {
        if (top < maxSize)
        {
            listArray[top] = item;
            top++;
            return true;
        }
        else
            return false;

    }


    // Looks for 'item' in the bag and if found updates 'item' with the 
    // bag value and returns true.  Otherwise 'item' is left unchanged
    // and the method returns false.
    //template <typename E>
    bool remove(E& item)
    {
        for (int i = 0; i <= top; i++)
        {
            if (listArray[i] == item)
            {
                for (int j = i + 1; j <= top; j++)
                {
                    listArray[i] = listArray[j];
                    i++;
                }
                top--;
                return true;
            }
        }
        return false;
    }


    // Removes the top record from the bag, puts it in returnValue, and
    // returns true if the bag is not empty.  If the bag is empty the 
    // function returns false and returnValue remains unchanged.
    //template <typename E>
    bool removeTop(E& returnValue)
    {
        if (top > 0)
        {
            returnValue = listArray[top--];
        }


    }


    // Finds the record using returnValue and if the record is found updates
    // returnValue based on the contents of the bag and returns true.  If the
    // record is not found the function returns false.  Works just like remove()
    // except that the found record is not removed from the bag.
    //template <typename E>
    bool find(E& returnValue)
    {

    }

    // Inspect the top of the bag.  If the bag is empty return
    // false and leave 'item' unchanged; otherwise, return true and update 
    // 'item' with the contents of the bag.
    //template <typename E>
    bool inspectTop(E& item)
    {
        if (top != 0)
        {
            item = listArray[top];
            return true;
        }
        else
            return false;
    }

    // empties the bag
    //template <typename E>
    void emptyBag()
    {
        top = 0;
    }

    // use the += operator to add an item to the bag
    //template <typename E>
    bool operator+=(const E& addEnd)
    {

    }

    // get the size of the bag
    //template <typename E>
    int size()
    {
        return top;
    }

    // get the capacity of the bag
    //template <typename E>
    int bagCapacity()
    {
        return maxSize;
    }

private:
    int maxSize;
    int top;
    E *listArray;
};


/*template <typename E>
ABag<E>::ABag()
{
    int size = 10
    maxSize = size;
    top = 0;
    listArray = new E[size];
}


template <typename E>
ABag<E>::~ABag()
{
    delete [] listArray;
}*/
#endif

这是我的 source.cpp 尝试从 class 实例化一个对象。

#include <iostream>
#include <string>
#include "ABag.h"
#include "BDictionary.h"

using namespace std;

int main(){
    ABag<int> myBag;

    cout << myBag.bagCapacity();

    system("Pause");
    return 0;
}

出于某种原因。我不断收到此错误。

error C2259: 'ABag<int>' : cannot instantiate abstract class

我在一个又一个的堆栈交换、教科书和论坛中跋涉，试图弄清楚为什么这行不通。我明白错误是什么。我知道你不能从抽象 class 中创建对象。但是我已经尝试了十几种不同的方法来尝试覆盖基础 class 中的纯虚函数，但我做不到。有一个 IntelliSense 错误告诉我每个纯虚函数都没有覆盖。

谁能帮帮我？

Answer 1

这是问题所在：

template <typename E>
bool addItem(const E& item)
{
    if (top < maxSize)
    {
        listArray[top] = item;
        top++;
        return true;
    }
    else
        return false;

}

你看，抽象classC的任何子classD都被认为是抽象本身，除非D绝对实现了所有纯虚方法C 个。 Bag<E> 的 addItem() 是一个带有签名 bool Bag<E>::addItem( const E& ) 的纯虚函数。另一方面，ABag<E> 的 addItem() 是一个函数 template，它采用名为 E 的类型模板参数，它隐藏了另一个 E 在 ABag<E>。一旦实例化，它将产生签名函数bool ABag<E1>::addItem<E2>( const E2& ).

这里重要的一点是函数模板与函数不同。您可以 将函数模板实例化 为函数，但这两个概念本身是不兼容的。 ABag<E> 中的函数模板未实现 Bag<E> 中的相应纯虚函数，因为它们的签名本质上是不兼容的。当您不匹配 constness 时也会发生这种情况。签名为 void foo( int ) 的函数不与 void foo( int ) const 兼容。前者根本不会 override/implement 后者在任何情况下都不会。

从模板库覆盖纯虚函数 Class

Overriding Pure Virtual Functions from a Template Base Class

c++

inheritance

pure-virtual