C++ 如何比较文件包含的下一个字符？

我在阅读代码时遇到了一些问题。这是文本文件

2X^6+3X^3+4X^0=0
5X^6+X^2+X^1-4X^0=0

我得到了第一行的正确输入，但在第二行，我需要忽略第一行。我在这里搜索，发现了如何使用它，并且忽略第一行的所有剩余字符，进入下一行是很困难的

您可以在第二行中看到，X中没有整数，现在的问题是第二行循环连续运行。如果我在文本文件中添加带有X的1，则该文件的读取效果非常好。另外，我如何设置一个条件来满足这一点，即当直接存在X或-X时，它应该存储1或-1，并转到下一个字符？您还可以看到^我必须将其存储在变量中，而我应该忽略它，但不知道如何忽略它

提前谢谢

int main()
{
int in;
int power;
char x;
char f;
fstream fin;
fin.open("input1.txt");
list l1,l2;

while(fin.peek() != 61)
{
        fin>>in;
        fin>>x;
        fin>>f;
        fin>>power;
        cout<<in<<endl<<x<<endl<<f<<endl<<power<<endl;
        l1.addtoend(in,power,x);
        cout<<endl;
}
fin.ignore(2,'\n');

while(fin.peek() != 61)
{
        fin>>in;
        fin>>x;
        fin>>f;
        fin>>power;
        cout<<in<<endl<<x<<endl<<f<<endl<<power<<endl;
        l2.addtoend(in,power,x);
        cout<<endl;
}
l1.display();
l2.display();
}

intmain（）
{
int-in；
整数幂；
字符x；
字符f；
流鳍；
fin.open（“input1.txt”）；
列表l1、l2；
而（fin.peek（）！=61）
{
fin>>中；
fin>>x；
fin>>f；
fin>>功率；
不幸的是，这并不像预期的那么简单

我们需要把任务分成几个小部分

你要做的是，把你的方程分解，从中提取系数和指数

将某些东西分成相似的部分也被称为标记化

因此，你的方程由项组成，它们都遵循相同的模式。首先是可选符号，然后是系数，然后是“X^”，最后是指数（可能有符号，也可能没有符号）

由于所有的术语都有相同的模式，所以我们可以用一个所谓的正则表达式来找到它们。C++支持这个功能。同样，在小的令牌/术语/模式匹配中分割文本时，我们有一个特殊的迭代器<代码>：ST:：SReExxItoKeNoTyRetrase< /C++ >。（并复制）所有匹配的图案

好的，那么我们已经找到了第一个子任务的解决方案。提取所有术语并将它们放入
std:：vector
中。我们将在定义变量时使用
std:：vector
s range构造函数来执行此操作

下一步是得到系数。这里我们需要一些特殊的处理，因为系数可以用一个假设1省略。使用这个假设，我们将读取该项并将系数转换为整数。因为我们想在一个语句中实现这一点，我们使用STL算法库中的
std:：transform

获取指数更容易。我们只需将“^”符号后面的项中的任何内容转换为整数。我们再次使用
std:：transform
处理一条语句中的所有项

最后但并非最不重要的是，我们将得到方程的右侧，并将其转换为整数

请注意:

所有这些都可以通过浮点型值来完成
我们也可以在方程中留出空间

为此，我们只需修改
std:：regex
-字符串

请参见下面的完整示例：

#include <iostream>
#include <string>
#include <vector>
#include <iterator>
#include <regex>
#include <algorithm>
#include <iomanip>

int main() {

    std::string equation{ "5X^6+X^2+X^1-4X^0=0" };

    const std::regex re(R"(([+-]?\d?X\^[+-]?\d+))");
    std::vector<std::string> terms{ std::sregex_token_iterator(equation.begin(), equation.end(), re,1),std::sregex_token_iterator() };


    std::vector<int> coefficients(terms.size());
    std::vector<int> exponents(terms.size());
    int rightHandSite{ 0 };

    // Everything in front of X is the coefficient. Handle special case, when no digit is given
    std::transform(terms.begin(), terms.end(), coefficients.begin(), [](const std::string& s) {
        std::string temp = s.substr(0U, s.find('X'));
        if (1 == temp.size() && !std::isdigit(temp[0])) temp += '1';
        return std::stoi(temp); });

    // Get all exponents
    std::transform(terms.begin(), terms.end(), exponents.begin(), [](const std::string & s) {
        return std::stoi(s.substr(s.find('^') + 1)); });

    // Get right Hand site of equation
    rightHandSite = std::stoi(equation.substr(equation.find('=') + 1));

    // Show result
    std::cout << "\nEquation: " << equation << "\n\nFound '" << terms.size() << "' terms.\n\nCoeffient  Exponent\n";
    for (size_t i = 0U; i < terms.size(); ++i)
        std::cout << std::right << std::setw(9) << coefficients[i] << std::setw(10) << exponents[i] << "\n";
    std::cout << "\n                  --> " << rightHandSite << "\n";

    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
int main（）{
字符串方程{“5X^6+X^2+X^1-4X^0=0”}；
常量std：：正则表达式re（R）（（[+-]？\d？X\^[+-]？\d+）；
std：：向量项{std：：sregex_令牌迭代器（等式.begin（），等式.end（），re，1），std：：sregex_令牌迭代器（）；
向量系数（terms.size（））；
std:：向量指数（terms.size（））；
int rightHandSite{0}；
//X前面的所有内容都是系数。如果没有数字，请处理特殊情况
std:：transform（terms.begin（）、terms.end（）、coverties.begin（）、[]（const std:：string&s）{
std:：string temp=s.substr（0U，s.find（'X'））；
如果（1==temp.size（）&&！std:：isdigit（temp[0]））temp+='1'；
返回标准：：stoi（温度）；}）；
//获取所有指数
std:：transform（terms.begin（）、terms.end（）、exponents.begin（）、[]（const std:：string&s）{
返回std:：stoi（s.substr（s.find（'^'）+1））；}；
//得到方程的右侧位置
rightHandSite=std:：stoi（等式substr（等式find（'='）+1））；
//显示结果
std：：无法将整行作为字符串读入并解析字符串，将其分解为其组件。通过调用
操作符>
和
peek
来实现这一点不是应该的方式。@PaulMcKenzle我知道这种方式，但需要很多条件才能获得正确的输入。我知道这种方式——这就是实现这一点的方式这样做。--但是它需要很多条件来获得正确的输入——LOL。这正是你最终要做的——这是任务的本质。标记化，使用正则表达式，解析等等。这就是所有工作的方式。你希望输入例程解析你的字符串——同样，这几乎从来没有用这种方式完成过。