Question

我在为我的堆栈类编写operator==函数时遇到了很多麻烦，我似乎无法将逻辑降低。目前我有：

template<class myType>
bool linkedStack<myType>::operator==(const linkedStack<myType>& op)
{
    linkedStack<myType> stackA, stackB;
    bool res = false;
    stackA.copyStack(this);
    stackB.copyStack(op);

    while(!stackA.isStackEmpty() && !stackB.isStackEmpty())
    {
        if (stackA.peek() == stackB.peek()) {
            stackA.pop();
            stackB.pop();
            if (stackA.isStackEmpty() && stackB.isStackEmpty())
                res = true;
        } else
            res = false;
    }
    return res;
}

问题是我无法将当前的类堆栈复制到stackA中，因为this是一个const指针而我的copyStack会发出编译器错误。必须有一个更容易的解决方案，有人能指出我正确的方向吗？谢谢！

编辑：我的代码的修订部分：

template<class myType>
bool linkedStack<myType>::operator==(const linkedStack<myType>& op)
{
    nodeType<myType> *current, *opcurrent;
    current = stackTop;
    opcurrent = op.stackTop;

    while(current != NULL && opcurrent != NULL)
    {
        if (current->info != opcurrent->info) {
            return false;
        }
        current = current->link;
        opcurrent = opcurrent->link;
    }
    return true;
}

Answer 1

一旦发现差异，您就不需要遍历所有堆栈，此时您可以直接返回false。

while(!stackA.isStackEmpty() && !stackB.isStackEmpty())
{
    if (stackA.peek() == stackB.peek()) {
        stackA.pop();
        stackB.pop();
    } else
        return false;
}
return stackA.isStackEmpty() && stackB.isStackEmpty();

更一般地说，如果你是在班级内部进行操作，你也可以直接使用班级的内部数据，而不是制作副本（这会产生堆栈所持有的所有数据的副本）好）。您应该使用几个指针来遵循内部列表。这段代码可以很容易地从上面的代码中得到，它应该提供以下内容：

node *a_ptr = head_ptr;
node *b_ptr = op.head_ptr;
while(!(a_ptr == tail || b_ptr == tail)
{
    if (a_ptr->data == b_ptr->data) {
        a_ptr = a_ptr->next;
        b_ptr = b_ptr->next;
    } else
        return false;
}
return (a_ptr == tail && b_ptr == tail);

取决于您的实施细节。

Answer 2

首先调用比较方法不应该修改它被调用的对象。声明它为const。

其次我认为像这样复制你的对象不是一个好主意，因为对于非常大的堆栈，它可能会导致性能问题（我假设一般用法）。

但最重要的是，如果这是你的堆栈实现，为什么不使用内部数据而不是像这样调用公共方法呢？

例如，Microsoft的STD使用deque作为堆栈的内部数据表示，operator==简单地定义为：

template<class _Ty,
    class _Container> inline
    bool operator==(const stack<_Ty, _Container>& _Left,
        const stack<_Ty, _Container>& _Right)
    {   // test for stack equality
    return (_Left._Get_container() == _Right._Get_container());
    }

Answer 3

您正在制作this和op的本地副本。这是不必要的，您可以直接在this和op中的数据之间进行比较。看起来您正在尝试将const对象传递给采用非const参数的函数。 copyStack应该使用const引用或指针。

为单链接堆栈编写运算符==

3 个答案: