C++ 如何重新排列字符串方程？

我被要求开发一个程序来解线性方程组。节目 首先读取一个整数n，它是方程的数目。 然后程序读取包含方程式的n行。 例如，程序的输入如下：

3
2x1+3x2+4x3=16
1x1+2x2+1x3=8
3x1+1x2+2x3=13

任何操作都应首先将每个方程转换为 正确的形式。方程本身应具有以下性质

变量按字母顺序从左到右排列：

3x2+2x1+4x3=16

应该是

2x1+3x2+4x3=16

2x1+3x2+4x3=16

2x1+3x2+4x3=16

任何变量只能出现一次：

4x1+3x2-2x1+4x3=16

应该是

2x1+3x2+4x3=16

2x1+3x2+4x3=16

2x1+3x2+4x3=16

方程式中只应出现一个常数项，且应为 在右侧：

2x1+3x2+5+4x3-11=10

应该是

2x1+3x2+4x3=16

2x1+3x2+4x3=16

2x1+3x2+4x3=16

系数等于1或-1时，数字1是可选的：

1x1+3x2-1x3=10

可以按原样输入

x1+3x2-x3=10

到目前为止，我所做的工作如下：

#include<iostream>
#include<string>
#include<sstream>
#include<cstdlib>

using namespace std;

int main() {
    int n;
    cin >> n;
    string eqn[100];
    //get eq from user
    for (int i = 0; i < n; i++) {
        cin >> eqn[i];
    }

    size_t  s = 0;
    size_t  y = 0;
    for (int i = 0; i < n; i++) {
        for (int x = 1; x <= ((eqn[i].length() - ((eqn[i].length() - 3) / 4)) / 3); x++)
        {
            int counter = 0;
            ostringstream ss;
            ss << x;
            string j = ss.str();
            for (int t = 0; t < eqn[i].length(); t++) {
                y = eqn[t].find("x" + j, y + 1);
                if (y < eqn[i].length()) { counter++; }
            }
            for (int o = 1; o <= counter; o++) {
                s = eqn[i].find("x" + j, s + 1);
                string x1 = eqn[i].substr(s - 1, 3);
                string x2 = x2 + x1;
                cout << x1;


            }


        }
        cout << endl;
    }
    int k;  cin >> k;

    return 0;
}

#包括
#包括
#包括
#包括
使用名称空间std；
int main（）{
int n；
cin>>n；
字符串eqn[100]；
//从用户处获取eq
对于（int i=0；i>eqn[i]；
}
尺寸=0；
尺寸y=0；
对于（int i=0；i

然后我把它翻译成一个手写的解析器

解析方程.cc
：

#include <iostream>
#include <algorithm>

int parseDigit(const char *&la)
{
  switch (*la) {
    case '0': ++la; return 0;
    case '1': ++la; return 1;
    case '2': ++la; return 2;
    case '3': ++la; return 3;
    case '4': ++la; return 4;
    case '5': ++la; return 5;
    case '6': ++la; return 6;
    case '7': ++la; return 7;
    case '8': ++la; return 8;
    case '9': ++la; return 9;
    default: return -1; // ERROR!
  }
}

int parseNumber(const char *&la)
{
  int value = parseDigit(la);
  if (value < 0) return -1; // ERROR!
  for (;;) {
    const int digit = parseDigit(la);
    if (digit < 0) return value;
    value *= 10; value += digit;
  }
}

struct Term {
  int coeff; // -1 ... missing
  int expon; // -1 ... missing -> ERROR

  Term(int coeff = -1, int expon = 0): coeff(coeff), expon(expon) { }
};

Term parseTerm(const char *&la)
{
  Term term;
  term.coeff = parseNumber(la);
  if (*la == 'x') {
    ++la;
    term.expon = parseDigit(la);
    if (term.coeff < 0) term.coeff = 1; // tolerate missing coeff. for x
  }
  return term;
}

struct Expression {
  bool error;
  int coeffs[10];

  Expression(bool error = false): error(error)
  {
    std::fill(std::begin(coeffs), std::end(coeffs), 0);
  }
};

Expression parseExpression(const char *&la)
{
  Expression expr;
  int sign = +1;
  do {
    const Term term = parseTerm(la);
    if (term.expon < 0) return Expression(true); // ERROR!
    expr.coeffs[term.expon] += sign * term.coeff;
    switch (*la) {
      case '+': sign = +1; ++la; break;
      case '-': sign = -1; ++la; break;
      case '=': break;
      default: return Expression(true); // ERROR!
    }
  } while (*la != '=');
  ++la;
  // parse right hand side
  const int result = parseNumber(la);
  if (result < 0) return Expression(true); // ERROR!
  expr.coeffs[0] -= result;
  // check for extra chars
  switch (*la) {
    case '\n': ++la;
    case '\0': break;
    default: return Expression(true); // ERROR!
  }
  return expr;
}

std::ostream& operator<<(std::ostream &out, const Expression &expr)
{
  if (expr.error) out << "ERROR!";
  else {
    bool empty = true;
    for (size_t i = 9; i; --i) {
      const int coeff = expr.coeffs[i];
      if (coeff) out << coeff << 'x' << i << std::showpos, empty = false;
    }
    if (empty) out << 0;
    out << std::noshowpos << '=' << -expr.coeffs[0];
  }
  return out;
}

int main()
{
  const char *samples[] = {
    "2x1+3x2+4x3=16",
    "1x1+2x2+1x3=8",
    "3x1+1x2+2x3=13",
    "2x1+3x2+5+4x3-11=10",
    "x1+3x2-x3=10"
  };
  enum { nSamples = sizeof samples / sizeof *samples };
  for (size_t i = 0; i < nSamples; ++i) {
    std::cout << "Parse '" << samples[i] << "'\n";
    const char *la = samples[i];
    std::cout << "Got    " << parseExpression(la) << std::endl;
  }
  return 0;
}


注:

可以使用而不是
parseDigit（）
和
parseNumber（）
。这将显著减少代码

<> L> >P>我使用了“读写头”<代码> La<代码>（……“向前看”的缩写）。纯C++方式可能是<>代码> STD:：StrugSuth，但是，我可能对这些新奇的东西还不够用。对于我来说，<代码> const char */Cuth>是最直观的方式…

右手边的结果只是从x0的系数中减去。所以，要么右手边是0，要么x0的负系数变成右手边。对于我漂亮的印刷
操作员来说，声音就像作业？这是一个大学项目，我的任务是，但我陷入了困境，不知道如何更好地处理这个问题em.使用
find（）
，
substr（）
这样做可能是可行的，但很乏味。对我来说，编写语法和编写语法分析器听起来很简单但是，如果你从未听说过编译器构造或形式语言，这也可能是一个挑战。我只是建议其他有类似问题的人来看看。如果你成功地制作了这样一个语法图，那么将其翻译成一个带有
if
s、
switch
s和
for的手写解析器可能并不难-循环。