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

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

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

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

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