调车-场算法C++不正确传递之间的方法？

Question

我的任务是编写一个调车-场算法，用于我的最后一个项目(计算器)。我用对我来说有意义的方式编写了程序，但是，在调用主算法函数(toRPN)时，我没有得到任何输出。我认为这是在解析和toRPN之间传递值的一个问题，因为我已经在main内部直接测试了解析，并且它工作得很好，但是当我尝试在toRPN函数中进行打印测试时，它什么也不打印。有人能给我指明正确的方向吗？

头：

#include <iostream>
#include <math.h>
#include <vector>
#include <stack>
#include <queue>

using namespace std;

#ifndef SHUNTING_YARD_ALGORITHM_SHUNTINGYARD_H
#define SHUNTING_YARD_ALGORITHM_SHUNTINGYARD_H


class ShuntingYard {
public:
    stack <string> stack;
    vector <string> tokens;
    queue <string> outputList;
    vector <char> operators;
    vector <int> precedence;
    vector <char> associativity;
    ShuntingYard ();
    bool hasOnlyDigits(const string s);
    int getPrecedence(const string s);
    int getAssociativity(const char c);
    vector<string> parse(const string input) const;
    string mainAlgorithm(const string);
};

#endif //SHUNTING_YARD_ALGORITHM_SHUNTINGYARD_H

cpp:

#include "ShuntingYard.h"
#include <iostream>
#include <math.h>
#include <vector>
#include <stack>
#include <queue>
#include <sstream>
#include <numeric>
using namespace std;

stack <string> stack1;
queue <string> outputList;
vector <string> operators;
vector <int> precedence;
vector <char> associativity;

ShuntingYard::ShuntingYard () = default;

bool hasOnlyDigits(const string s){
    return s.find_first_not_of( "0123456789" ) == string::npos;
}

int getPrecedence(const string s) {
    for(int i = 0; i < operators.size(); i++) {
        if (s ==  operators[i])
            return precedence[i];
    }
}
char getAssociativity(const string s) {
    for(int i = 0; i < operators.size(); i++) {
        if (s == operators[i])
            return associativity[i];
    }
}

vector<string> parse(const string input) {
// Parses the string by white space
    istringstream ss(input);
    vector <string> tokenVector;

    // Fill vector with ss
    for (string input; ss >> input;) {
        tokenVector.push_back(input);
    }
    return tokenVector;
}


string toRPN(const string s) {

    // Delimit string by white space and store in vector
    vector <string> tokens = parse(s);

    // Test print
    for (int i = 0; i < tokens.size(); i ++)
        cout << tokens[i];

    //Change "rt" to "$" to be easily accessed
    for (int i = 0; i < tokens.size(); i ++) {
        if (tokens[i] == "rt")
            tokens[i] = "$";
    }

    // Stores operators and their precedence/associativity to vectors using same index
    operators.push_back("+"); precedence.push_back(2); associativity.push_back('L');
    operators.push_back("-"); precedence.push_back(2); associativity.push_back('L');
    operators.push_back("/"); precedence.push_back(3); associativity.push_back('L');
    operators.push_back("*"); precedence.push_back(3); associativity.push_back('L');
    operators.push_back("^"); precedence.push_back(4); associativity.push_back('R');
    operators.push_back("$"); precedence.push_back(4); associativity.push_back('R');


    // Shunting-Yard logic
    while (tokens.size() != 0) {
        for (int i = 0; i < tokens.size(); i++) {
            if (hasOnlyDigits(tokens[i]))
            outputList.push(tokens[i]);
            if ( find(operators.begin(), operators.end(), tokens[i]) != operators.end()) {
                while (getPrecedence(stack1.top()) > getPrecedence(tokens[i]) || (getPrecedence(stack1.top()) == getPrecedence(tokens[i]) &&
                getAssociativity(tokens[i]) == 'L') && stack1.top() != "(") {
                    outputList.push(stack1.top());
                    stack1.pop();
                    stack1.push(tokens[i]);
                }
            }
            if (tokens[i] == "(")
                stack1.push(tokens[i]);
            if (tokens[i] == ")")
                while(!stack1.empty() && stack1.top() != "(") {
                    outputList.push(stack1.top());
                    stack1.pop();
                }
                stack1.pop();
        }
            if (tokens.size() == 0) {
                while(!stack1.empty()) {
                    outputList.push(stack1.top());
                    stack1.pop();
                }
            }
    }

    // Replaces values with "$" back to "rt"
    string str;
    while (!outputList.empty()) {
        if (outputList.front() == "$") {
            str.insert(0,"rt");
            outputList.pop();
        }
        else {
            str.insert(0, (outputList.front()));
            outputList.pop();
        }
    }
    return str;
}

int main() {
    string s1 = "3 + 4";
    cout << toRPN(s1);
}

更新：

我把这个问题缩小到了以下while循环：

while (getPrecedence(stack1.top()) > getPrecedence(tokens[i]) || (getPrecedence(stack1.top()) == getPrecedence(tokens[i]) &&
                getAssociativity(tokens[i]) == 'L') && stack1.top() != "(") {
                    outputList.push(stack1.top());
                    stack1.pop();
                    stack1.push(tokens[i]);
                }

getPrecedence行(stack1.top()> getPrecedence(tokensI) )是问题所在。特别是，在stack1.top()上运行getPrecedence。这个函数基本上接受一个字符串，并将其与保存所有存储运算符的向量进行比较。当它找到索引时，它返回该索引处的优先级(它们与所有索引一起按顺序设置)。我不明白为什么我不能用这种方式调用这个函数。stack1.top()只提供一个字符串，该字符串将被传递并进行比较。有什么想法吗？

Answer 1

弄明白了。有几件事情正在进行中，但困扰程序的主要原因是，当我不应该从堆栈中弹出一些东西时，导致堆栈是空的，所以它永远不会进入。

while (getPrecedence(stack1.top()) > getPrecedence(tokens[i]) || (getPrecedence(stack1.top()) == getPrecedence(tokens[i]) &&
                getAssociativity(tokens[i]) == 'L') && stack1.top() != "(")