C++ 带堆栈类的后缀计算，C++；

我试图使用自定义堆栈类来计算后缀形式的方程。由于某种原因，程序不断崩溃

这是堆栈头文件

#ifndef aStack_h
#define aStack_h
#include <string>
#include <iostream>

using std::string; using std::cout;
class aStack
{
    private:
        int top, size;
        int *stack;
    public:
        aStack(int s)
        {
            size = s;
            top = -1;
            stack = new int [s];
        }

        ~aStack() 
        {
            delete [] stack;
        }
        void reset();
        void push(int);
        void pop();
        int getTop();
        void getSize()
        {
            std::cout << size;
        }
};

#endif

\ifndef aStack\h
#定义aStack_h
#包括
#包括
使用std:：string；使用std：：cout；
类阿斯塔克
{
私人：
int-top，大小；
int*堆栈；
公众：
阿斯塔克（INTS）
{
尺寸=s；
top=-1；
堆栈=新整数[s]；
}
~aStack（）
{
删除[]堆栈；
}
无效重置（）；
无效推力（int）；
void pop（）；
int getTop（）；
void getSize（）
{
std:：cout您的堆栈类在注释中已经指出了各种各样的问题。修复了这些问题后，主程序中只剩下一些bug

我在数组中使用了
std:：unique_ptr
，而不是原始指针，并禁用了移动语义，因此它既不可复制（因为
unique_ptr
），也不可移动

我还添加了在试图访问堆栈时抛出异常

#include <cctype>
#include <cstddef>
#include <exception>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>
#include <utility>

template<typename T>
class aStack {
public:
    using value_type = T;

    explicit aStack(size_t c) :
        cap(c), stored(0), stack(std::make_unique<value_type[]>(cap)) {}

    aStack(aStack&&) = delete;  // moving disabled

    void reset() noexcept { stored = 0; }

    void push(const value_type& v) {
        if(stored == cap) throw std::runtime_error("stack is full");
        stack[stored++] = v;
    }
    void push(value_type&& v) {
        if(stored == cap) throw std::runtime_error("stack is full");
        stack[stored++] = std::move(v);
    }
    value_type& pop() {
        if(stored == 0) throw std::runtime_error("stack is empty");
        return stack[--stored];
    }
    [[nodiscard]] const value_type& top() const {
        if(stored == 0) throw std::runtime_error("stack is empty");
        return stack[stored - 1];
    }
    [[nodiscard]] value_type& top() {
        if(stored == 0) throw std::runtime_error("stack is empty");
        return stack[stored - 1];
    }
    [[nodiscard]] size_t capability() const noexcept { return cap; }
    [[nodiscard]] size_t size() const noexcept { return stored; }

private:
    size_t cap, stored;
    std::unique_ptr<value_type[]> stack;
};

当它崩溃时，您是否收到任何消息？如果收到，请将其包含在您的帖子中。无关：
Stack
冲突。您是否自己进行过调试以确定崩溃发生的位置/时间？您认为在
Stack[top++]中发生了什么=v；
当
top==-1
时？还要注意堆栈的
getTop
方法返回的是顶部索引，而不是堆栈中的顶部值。它可能应该是
return stack[top]；
而不是
return top；
#include <iostream>
#include "aStack.h"
#include <string>
using namespace std; 

int main()
{
    string equation {"35+1*"};
    int op, count = 0, *oparray, result;
    aStack stack(equation.length());

    for (int i = 0; i < equation.length(); i++)
        {
            if (isdigit(equation[i]))
            {

                stack.push(equation[i]);
                count++;
            }
            else 
                {
                    oparray = new int [count];
                    for (int o = 0; o < count; o++) 
                        {
                            oparray[o] = stack.getTop();
                            stack.pop();
                        }
                    switch(equation[i])
                        {
                            case '+':
                                for (int i =0; i < count; i++)
                                    {
                                        op += oparray[i];
                                        count--;
                                    }
                                stack.push(op);
                                break;


                            case '-':
                                for (int i =0; i < count; i++)
                                    {
                                        op-=oparray[i];
                                        count--;
                                    }
                                stack.push(op);
                                break;
                            case '*':
                                for (int i =0; i < count; i++)
                                    {
                                        op*=oparray[i];
                                        count--;
                                    }
                                stack.push(op);
                                break;
                            case '/':
                                for (int i =0; i < count; i++)
                                    {
                                        op/=oparray[i];
                                        count--;
                                    }
                                stack.push(op);
                                break;
                        }
                    delete [] oparray;
                }
        }
    result = stack.getTop();
    cout << result;
}

#include <cctype>
#include <cstddef>
#include <exception>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>
#include <utility>

template<typename T>
class aStack {
public:
    using value_type = T;

    explicit aStack(size_t c) :
        cap(c), stored(0), stack(std::make_unique<value_type[]>(cap)) {}

    aStack(aStack&&) = delete;  // moving disabled

    void reset() noexcept { stored = 0; }

    void push(const value_type& v) {
        if(stored == cap) throw std::runtime_error("stack is full");
        stack[stored++] = v;
    }
    void push(value_type&& v) {
        if(stored == cap) throw std::runtime_error("stack is full");
        stack[stored++] = std::move(v);
    }
    value_type& pop() {
        if(stored == 0) throw std::runtime_error("stack is empty");
        return stack[--stored];
    }
    [[nodiscard]] const value_type& top() const {
        if(stored == 0) throw std::runtime_error("stack is empty");
        return stack[stored - 1];
    }
    [[nodiscard]] value_type& top() {
        if(stored == 0) throw std::runtime_error("stack is empty");
        return stack[stored - 1];
    }
    [[nodiscard]] size_t capability() const noexcept { return cap; }
    [[nodiscard]] size_t size() const noexcept { return stored; }

private:
    size_t cap, stored;
    std::unique_ptr<value_type[]> stack;
};

int main(int argc, char* argv[]) {
    if(argc < 2) {
        std::cout << "USAGE: " << argv[0] << " <equation>\n";
        return 1;
    }
    std::string equation(argv[1]);
    try {
        int op, result;
        aStack<int> stack(equation.length());

        for(size_t ei = 0; ei < equation.length(); ++ei) {
            if(std::isdigit(equation[ei])) {
                stack.push(equation[ei] - '0'); // from ASCII to digit
            } else {
                op = stack.pop();               // start with what's on the stack
                switch(equation[ei]) {
                case '+':
                    while(stack.size()) {
                        op += stack.pop();
                    }
                    stack.push(op);
                    break;
                case '-':
                    while(stack.size()) {
                        op -= stack.pop();
                    }
                    stack.push(op);
                    break;
                case '*':
                    while(stack.size()) {
                        op *= stack.pop();
                    }
                    stack.push(op);
                    break;
                case '/':
                    while(stack.size()) {
                        op /= stack.pop();
                    }
                    stack.push(op);
                    break;
                default:
                    throw std::runtime_error("invalid operation");
                }
            }
        }
        result = stack.pop();
        if(stack.size() != 0)
            throw std::runtime_error("stack not empty when calculation ended");

        std::cout << result << '\n';
    } catch(const std::exception& ex) {
        std::cerr << "Exception: " << ex.what() << '\n';
    }
}