C++ 将堆栈中的每个值相加

我试图找出一种方法，将堆栈中的每个值相加

目标是使用该值确定堆栈中的所有值是否为偶数。 我已经编写了代码来实现这一点

template <class Object>
bool Stack<Object>::objectIsEven( Object value ) const {
     bool answer = false;
     if (value % 2 == 0)
          answer = true;
     return( answer );
}

模板
布尔堆栈：：ObjectSeven（对象值）常量{
布尔答案=假；
如果（值%2==0）
答案=正确；
返回（回答）；
}

然而，如何在一个单独的方法中添加堆栈的所有值，这让我感到困惑

Stack.cpp

#ifndef STACK_CPP
#define STACK_CPP

#include "Stack.h"

namespace cs20 {

template <class Object>
Stack<Object>::Stack() {
    topNode = NULL;
}

template <class Object>
Stack<Object>::Stack( const Stack<Object>& rhs ) {
    topNode = NULL;
    *this = rhs;
}

template <class Object>
Stack<Object>::~Stack() {
    makeEmpty();
    delete topNode;
}

template <class Object>
bool Stack<Object>::isEmpty() const {
    return( (topNode == NULL) );
}

template <class Object>
bool Stack<Object>::even() const
    {

    }
// template Object must support the % operator which ints do
template <class Object>
bool Stack<Object>::objectIsEven( Object value ) const {
    bool answer = false;
    if (value % 2 == 0)
        answer = true;
    return( answer );
}


template <class Object>
void Stack<Object>::makeEmpty() {
    while (!isEmpty()) {
        pop();
    }
}


template <class Object>
void Stack<Object>::push( const Object& data ) {
    StackNode<Object>* newNode = new StackNode<Object>( data, topNode );
    topNode = newNode;
}

template <class Object>
void Stack<Object>::pop() {
    if (isEmpty()) {
        throw EmptyStack();
    }
    StackNode<Object> *oldTop = topNode;
    topNode = topNode->getNext();
    delete oldTop;
}

template <class Object>
const Object& Stack<Object>::top( ) const {
    if (isEmpty()) {
        throw EmptyStack();
    }
    StackNode<Object> node = *topNode;
    return( node.getElement() );
}

template <class Object>
Object Stack<Object>::topAndPop( ) {
    Object o = top();
    pop();
    return( o );
}

// Deep copy of linked Stack
template <class Object>
const Stack<Object>& Stack<Object>::operator =( const Stack<Object>& rhs ) {
    if (this != &rhs) {
        makeEmpty();
        if (!(rhs.isEmpty())) {
            StackNode<Object> * rhsTopNode = rhs.topNode;
            StackNode<Object> * myTopNode = new StackNode<Object>( rhsTopNode->getElement() );
            topNode = myTopNode;

            rhsTopNode = rhsTopNode->getNext();
            while (rhsTopNode != NULL) {
                myTopNode->setNext( new StackNode<Object>( rhsTopNode->getElement() ) );
                myTopNode = myTopNode->getNext();
                rhsTopNode = rhsTopNode->getNext();
            }
        }
    }
    return( *this );
}

template <class Object> 
std::ostream& Stack<Object>::printStack( std::ostream& outs ) const {
    if (isEmpty()) {
        outs << "Empty Stack";
    }
    else {
        outs << "TOP: ";
        StackNode<Object> * node = topNode;
        while (node != NULL) {
            outs << node->getElement();
            outs << "\n     ";           /// for visual alignment
            node = node->getNext();
        }
    }
    return( outs );
}

}

#endif

#ifndef STACK\u CPP
#定义堆栈_CPP
#包括“Stack.h”
名称空间cs20{
模板
Stack:：Stack（）{
topNode=NULL；
}
模板
堆栈：：堆栈（常量堆栈和rhs）{
topNode=NULL；
*这=rhs；
}
模板
堆栈：：~Stack（）{
makeEmpty（）；
删除topNode；
}
模板
布尔堆栈：：isEmpty（）常量{
返回（（topNode==NULL））；
}
模板
布尔堆栈：：偶数（）常量
{
}
//模板对象必须支持ints所支持的%运算符
模板
布尔堆栈：：ObjectSeven（对象值）常量{
布尔答案=假；
如果（值%2==0）
答案=正确；
返回（回答）；
}
模板
void Stack:：makeEmpty（）{
而（！isEmpty（））{
pop（）；
}
}
模板
void Stack:：push（常量对象和数据）{
StackNode*newNode=新StackNode（数据，topNode）；
topNode=newNode；
}
模板
void Stack:：pop（）{
if（isEmpty（））{
抛出空包（）；
}
StackNode*oldTop=topNode；
topNode=topNode->getNext（）；
删除oldTop；
}
模板
常量对象和堆栈：：top（）常量{
if（isEmpty（））{
抛出空包（）；
}
StackNode节点=*topNode；
返回（node.getElement（））；
}
模板
对象堆栈：：topAndPop（）{
对象o=top（）；
pop（）；
返回（o）；
}
//链接堆栈的深度复制
模板
常量堆栈和堆栈：：运算符=（常量堆栈和rhs）{
如果（此！=&rhs）{
makeEmpty（）；
如果（！（rhs.isEmpty（））{
StackNode*rhsTopNode=rhs.topNode；
StackNode*myTopNode=新的StackNode（rhsTopNode->getElement（））；
topNode=myTopNode；
rhsTopNode=rhsTopNode->getNext（）；
while（rhsTopNode！=NULL）{
myTopNode->setNext（新的StackNode（rhsTopNode->getElement（））；
myTopNode=myTopNode->getNext（）；
rhsTopNode=rhsTopNode->getNext（）；
}
}
}
返回（*本条）；
}
模板
std:：ostream&Stack:：printStack（std:：ostream&outs）常量{
if（isEmpty（））{
使用这个例子：

只需将总和保存在本地，然后从堆栈中一次弹出一个值：

void MathStack::addAll()
{
    int num = 0, sum = 0;

    while(!isEmpty())
    {
        pop(num);
        sum += num;
    }

    push(sum);
}

您不能在堆栈实现中定义getSum（）函数吗？或者有任何限制吗

Sol-1：

template <class Object> 
Object Stack<Object>::getSum( ) {
    Object sum = 0;  // or memset or other stuffs
    StackNode<Object> * node = topNode;
    while (node != NULL) {
        sum += node->getElement();
        node = node->getNext();
    }
    return sum;
}

模板
对象堆栈：：getSum（）{
Object sum=0；//或memset或其他内容
StackNode*node=topNode；
while（节点！=NULL）{
sum+=节点->获取元素（）；
node=node->getNext（）；
}
回报金额；
}

正如Gary提到的，您还可以通过在每次推送或弹出时缓存总和值来提高效率（即，堆栈已更改）
Sol-2：

添加一个表示总和的成员属性（例如，g-sum）

模板
Stack:：Stack（）{
topNode=NULL；
this->sum=0；//初始化或新建对象
}

每当推送对象时更新总和

template <class Object>
void Stack<Object>::push( const Object& data ) {
    StackNode<Object>* newNode = new StackNode<Object>( data, topNode );
    topNode = newNode;
    this->sum = this->sum + data;
}

模板
void Stack:：push（常量对象和数据）{
StackNode*newNode=新StackNode（数据，topNode）；
topNode=newNode；
此->求和=此->求和+数据；
}

每当删除对象时，pop（）也会进行相同的更新

template <class Object>
void Stack<Object>::pop() {
    if (isEmpty()) {
        throw EmptyStack();
    }
    StackNode<Object> *oldTop = topNode;
    topNode = topNode->getNext();
    this->sum = this->sum - oldTop->getElement();
    delete oldTop;
}

模板
void Stack:：pop（）{
if（isEmpty（））{
抛出空包（）；
}
StackNode*oldTop=topNode；
topNode=topNode->getNext（）；
this->sum=this->sum-oldTop->getElement（）；
删除oldTop；
}

现在是最后一个函数getSum（）

模板
对象堆栈：：getSum（）{
返回此->总和；
}

溶胶-1的成本为O（N）=N，而溶胶-2的成本为O（N）=1

现在您应该能够使用pStack->objectIsEven（pStack->getSum（））

我认为您不必担心堆栈实现中的线程问题，否则您应该在插入/删除操作时使用某种同步机制，以使堆栈一致

希望这有帮助。
关于，
您需要向我们展示堆栈的外观。我认为命名一个模板参数
Object
@ZacWrangler Made edit很奇怪
template <class Object>
void Stack<Object>::pop() {
    if (isEmpty()) {
        throw EmptyStack();
    }
    StackNode<Object> *oldTop = topNode;
    topNode = topNode->getNext();
    this->sum = this->sum - oldTop->getElement();
    delete oldTop;
}

template <class Object> 
    Object Stack<Object>::getSum( ) {
        return this->sum;
    }