字符串后缀表达式计算记录

完成了一半的后缀表达式计算C++代码，后面的大整数除法和大整数取模运算到时候再实现吧

编译环境(VScode g++8.1.0)

/*
 * @Author: KarenFu
 * @Date: 2021-03-14 20:05:32
 * @LastEditTime: 2021-03-16 21:09:28
 * @LastEditors: Please set LastEditors
 * @Description: In User Settings Edit
 * @FilePath: \.vscode_C++\Demo_main.cpp
 * 
 * Attention: this Demo is written for only integer calculation
 * And that all nums must be in correct form (+-x or continuous operators are not allowed)
 */
#include <iostream>
#include <vector>
#include <string>
#include <map>
using namespace std;

map<char, int> level;

string opts = "";
string nums = "";
string expr = "";
string rslt = "";

void Calculator(const string& s);
bool isopt(const char& c);
bool isdgt(const char& c);
string operator+(const string& s1, const string& s2);
string operator-(const string& s1, const string& s2);
string operator*(const string& s1, const string& s2);
string operator/(const string& s1, const string& s2);

int main()
{
    level['+'] = 1; level['-'] = 1;
    level['*'] = 2; level['/'] = 2;

    string temp = "5+(1+2)*4-3";
    Calculator(temp);
    cout << expr << endl;
    
    string s2 = "99099";
    string s1 = "99900999";
    string multi = s1 - s2;
    cout << multi << endl;
    system("pause");
    return 0;
}

void Calculator(const string &s)
{
    int len_s = s.length();
    if (len_s == 0)
        return;
    for (int i = 0; i < len_s; ++i)
    {
        if (s[i] == '(')
            opts += '(';
        else if (isdgt(s[i]))
        {
            int j = i;
            while (j < len_s && isdgt(s[j])) j++;
            expr += s.substr(i, j - i);
            expr += ' ';
            i = j - 1;
        }
        else if (isopt(s[i]))
        {
            int idx_opts = opts.length() - 1;
            while (idx_opts >= 0 && opts[idx_opts] != '(' && level[s[i]] <= level[opts[idx_opts]])
            {
                expr += opts[idx_opts];
                expr += ' ';
                idx_opts--;
            }
            opts.erase(opts.begin() + 1 + idx_opts, opts.end());
            opts += s[i];
        }
        else if (s[i] == ')')
        {
            int idx_opts = opts.length() - 1;
            while (idx_opts >= 0 && opts[idx_opts] != '(')
            {
                expr += opts[idx_opts];
                expr += ' ';
                idx_opts--;
            }
            opts.erase(opts.begin() + idx_opts, opts.end());
        }
        else if (s[i] == ' ')
            continue;
        else
        {
            expr = "Invalid Expression\n";
            return;
        }   
    }
    // Push in rest of the operators
    int idx_opts = opts.length() - 1;
    while (idx_opts >= 0)
    {
        expr += opts[idx_opts];
        idx_opts--;
    }
    opts = "";

    // Calculate the value
    
}

bool isopt(const char &c)
{
    if (c == '+' || c == '-' || c == '*' || c == '/')
        return true;
    return false;
}
bool isdgt(const char &c)
{
    if (c >= '0' && c <= '9')
        return true;
    return false;
}
string operator+(const string& s1, const string& s2)
{
    string result = "";
    int len_1 = s1.length();
    int len_2 = s2.length();
    int len_g = len_1 > len_2 ? len_1 : len_2;
    vector<int> store(len_g + 1, 0);
    result.resize(len_g + 1);
    len_1--;
    len_2--;
    while (len_1 >= 0 && len_2 >= 0)
    {
        store[len_g] = (s1[len_1] - 48) + (s2[len_2] - 48);
        len_1--; len_2--; len_g--;
    }
    while (len_1 >= 0)
    {
        store[len_g] = s1[len_1] - 48;
        len_1--; len_g--;
    }
    while (len_2 >= 0)
    {
        store[len_g] = s2[len_2] - 48;
        len_2--; len_g--;
    }
    len_g = store.size() - 1;
    int carry = 0;
    while (len_g > 0)
    {
        carry = store[len_g] / 10;
        store[len_g - 1] += carry;
        store[len_g] = store[len_g] % 10;
        result[len_g] = char(store[len_g] + 48);
        len_g--;
    }
    if (store[0])
        result[0] = char(store[0] + 48);
    else
        result.erase(result.begin());
    return result;
}
string operator-(const string& s1, const string& s2)
{
    string result = "";
    int len_u = s1.length();
    int len_d = s2.length();
    string su = s1;
    string sd = s2;
    int len_g = len_u;
    int sign = 1;
    if (len_u < len_d)
    {
        sign = -1;
        len_g = len_d;
        su = s2;
        sd = s1;
        swap(len_u, len_d);
    }
    vector<int> store(len_g, 0);
    result.resize(len_g);
    len_u--; len_d--; len_g--;
    while (len_u >= 0 && len_d >= 0)
    {
        store[len_g] = (su[len_u] - 48) - (sd[len_d] - 48);
        len_u--; len_d--; len_g--;
    }
    while (len_u >= 0)
    {
        store[len_g] = su[len_u] - 48;
        len_u--; len_g--;
    }
    len_g = store.size() - 1;
    while (len_g >= 0)
    {
        if (store[len_g] < 0)
        {
            store[len_g] += 10;
            store[len_g - 1] -= 1;
        }
        result[len_g] = store[len_g] + 48;
        len_g--;
    }
    if (sign < 0)
        result.insert(result.begin(), '-');
    return result;
}
string operator*(const string& s1, const string& s2)
{
    string result = "";
    int len1 = s1.length();
    int len2 = s2.length();
    vector<int> store(len1 + len2, 0);
    result.resize(len1 + len2);
    for (int i = len1 - 1; i >= 0; --i)
    {
        for (int j = len2 - 1; j >= 0; --j)
        {
            store[i + j + 1] += (s1[i] - 48) * (s2[j] - 48);
        }
    }
    int carry = 0;
    for (int i = len1 + len2 - 1; i > 0; --i)
    {
        carry = store[i] / 10;
        store[i] = store[i] % 10;
        store[i - 1] += carry;
        result[i] = char(store[i] + 48);
    }
    if (store[0])
        result[0] = char(store[0] + 48);
    else
        result.erase(result.begin());
    return result;
}
string operator/(const string& s1, const string& s2)
{
    string result = "";
    // todo
    return result;
}