0

我在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;
}
4

3 回答 3

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);

取决于您的实施细节。

于 2013-04-25T03:15:58.690 回答
1

第一次调用比较方法不应该修改它被调用的对象。宣布它const。

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

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

例如，微软的 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());
    }
于 2013-04-25T03:16:51.460 回答
0

You are making local copies of both this and op. This is unnecessary and you can do the comparisons directly between the data in this and op instead. It looks like you are trying to pass a const-object to a function taking a non-const parameter. copyStack should take a const reference or pointer.

于 2013-04-25T03:21:41.327 回答