编译器说定义的函数是虚拟的

Question

当我尝试只使用 stackType 的构造函数时，编译器说我不能，因为重载的 == 是纯虚拟的。但是，如您所见，我在 stackType 中重新定义了它。请帮忙。 （我认为运算符可以声明为纯虚拟，但我不确定。我是 C++ 新手）。

谢谢！

我将代码缩减到最低限度（学校作业）：

#include <iostream>
#include <cstdlib>
#include <cassert>

using namespace std;

template <class Type>
class stackADT
{
public:
    virtual bool operator ==(const stackADT<Type> & b) = 0;
};
template <class Type>
class stackType: public stackADT<Type>
{
public:
    bool isFullStack() const;
    stackType(int stackSize = 100);
    bool operator == (const stackType<Type> & b) {
        if (this->stackTop != b.stackTop) {
            return false;
        }
        else {
            bool equivalence = true;
            for (int cntr = 0; cntr < b.stackTop; cntr++) {
                if (this->list[cntr] != b.list[cntr]) {
                    equivalence = false;
                }
            }
            return equivalence;
        }
    }
private:
    int maxStackSize; //variable to store the maximum stack size
    int stackTop;     //variable to point to the top of the stack
    Type *list;       //pointer to the array that holds the
                      //stack elements
};
template <class Type>
bool stackType<Type>::isFullStack() const
{
    return(stackTop == maxStackSize);
} //end isFullStack

template <class Type>
template <class Type>
stackType<Type>::stackType(int stackSize) 
{
    if (stackSize <= 0)
    {
        cout << "Size of the array to hold the stack must "
             << "be positive." << endl;
        cout << "Creating an array of size 100." << endl;

        maxStackSize = 100;
    }
    else
        maxStackSize = stackSize;   //set the stack size to 
                                    //the value specified by
                                    //the parameter stackSize

    stackTop = 0;                   //set stackTop to 0
    list = new Type[maxStackSize];  //create the array to
                                    //hold the stack elements
}//end constructor



int main() {
    stackType<int> a(34);
}

Answer 1

stackADT 中的operator== 采用const stackADT<Type>& 类型的参数，stackType 中的operator== 采用const stackType<Type>& 类型之一。由于它们具有不同的签名，因此它们具有不同的功能。

如果您想确保派生类中的函数覆盖基类中的函数，您可以（在 C++11 中）使用 override 关键字。如果你的函数没有覆盖任何东西，它会让编译器抱怨。

就目前而言，您的抽象基类要求每个派生类都与基类具有可比性。因此，您可以仅基于基础中可用的成员进行比较。由于比较应该是可传递的，这也意味着可以仅基于基类中存在的成员来比较不同的派生类。如果这不是您想要的，您应该从基础中删除运算符。

Answer 2

这个

bool operator == (const stackType<Type> & b)

不覆盖

virtual bool operator ==(const stackADT<Type> & b) = 0

因为参数类型不同。第一个采用对stackType<Type> 的常量引用。第二个采用 const 引用 stackADT<Type>. 所以你的派生类中有两个不同的 operator== 函数，第一个是纯虚拟的——因此编译器错误。

这里引用了几种解决此问题的方法： Dynamic Casts or Function Overloads? 一种方法涉及使用 dynamic_cast，另一种方法使用 双重调度。