一个交互多项式计算器的实现

一个交互多项式计算器的实现

                                         

----------------------个人作业，如果有后辈的作业习题一致，可以参考学习，一起交流，请勿直接copy,关于这部分的代码，有不清楚或者有错误的地方，还请评论或者私聊指正，一起学习

 

 

摘要

为实现多项式的一些运算求解问题，包括加法，减法，乘法，判断是否相等，求导，代入x的值求解共六种运算，同时实现与用户之间的交互，提供便于输入和查找的菜单和，输入输出。主要使用typedef pair<int, int> term; typedef vector<term> polynomial; struct P{char x;polynomial p;}; 三种新定义的类型，以vector为主要的数据结构，构造多个函数，并重载了运算符，最终达成了实验的目标。

 

一 问题说明

首先要解决的是如何输入并使程序理解所输入的多项式，并为多项式找到一种表示方法，以便能够在之后的运算中读取和计算。考虑到多项式的主要性质为不同项的系数和指数，即多组数对，于是采用了vector< pair<int, int>> polynomial 这个类型来储存多项式的重点要素系数和指数。

其次是运算的部分，仿照数学中计算的方式方法，构造相应的函数，并重载了’ + ’ 、’ - ’、’ * ’  三个运算符，这样就解决了运算的问题。

最后为了使结果输出能够符合一般的多项式的表示形式，重载了’<<’，使其输出的形式为ax^b-cx^d+x-1来表示。

这样实现了功能之后，为了更好的用户体验，还额外添加了初始界面和菜单项以及结束项，成功解决了问题，实现了要求的功能。

二 设计与实现

图1为该程序的大致流程图，其余细节的判断和处理，以及具体的函数实现步骤方法，在这里就不赘述了，只列出了所用的函数头和其实现的作用（不包括用于选择order的viod fx()系列函数）：

polynomial getPoly(string s);//从输入的字符串中得到表示多项式的polynomial数据类型，不接受空格或其他非标准的输入。将‘（’到‘，’间的字符转换为int类型存储为系数，‘，’到‘）’的内容转换成int存储为指数，一个括号内为一个pair，构成了pair的组合输出。

polynomial operator +(const polynomial &p, const polynomial &q); //重载双目运算符‘+’，同样的还有‘-’和‘*’，详细说明在之后

bool equal(const polynomial &p, const polynomial &q);//判断多项式p和q是否相等，判断每一项对应的值是否一致，如果不，false，判断完所有数据，没有false输出，则输出true

polynomial der(const polynomial &p);//求多项式p的导数，模拟多项式求导的数学方法，指数与系数相乘作为新的系数，指数减1作为新的指数

int value(int x, polynomial& p);//给定x的值int x;代入求p的结果，系数乘以x的指数次幂，把每一项的结果相加

ostream& operator <<(ostream& out, const polynomial &q);//重载输出运算符，详细说明在之后

ostream& operator <<(ostream& out, const P &q);//同上，调用多项式的重载，循环输出

bool inter(polynomial x);//判断输入的多项式是否合法（按降幂输入）逐个判断是否后一位大于等于前一位，是则输出false，全部判断后未输出，则输出true；

bool rename(char x);//判断多项式是否重命名，逐个查找，如果P[i].x与x一致，则输出true，全部判断后未输出，则输出false；

      

 

                                图1.程序流程图

 

 

              这里具体对加法和乘法以及输出运算符的重载三个个主要的函数的实现进行一下说明：

   首先是加法，对于两个多项式的加法，考虑到多项式加法的基本流程，和已经确定的降幂输入，采用了merge类似的方法来对两个多项式进行处理，指数大的排序在前，小的在后，相同时执行系数的加法后排序，所得的polynomial类型所储存的pair的组合，就是两个多项式相加后的结果。

其次是乘法，模拟一般的人工求多项式相乘的步骤会方式方法，使第一个多项式的每一项分别与第二个多项式的所有项相乘，存为新的多项式，再全部相加，就得到了两个多项式相乘后的结果。

最后是输出运算符，按顺序输出每一项，如果是第一项系数为0，判断是否只有一项，是则输出0，不是则令下一项变成第一项；如果第一项系数为1，再判断指数是否为1，为1则输出x,是否为0，为0则输出系数，都不是则输出系数x^指数；如果第一项系数为-1，同上；第一项不为1,0，-1，判断指数，执行结果类似；然后逐个输出之后的项，类似第一项，但是预先判断正负，正数前加‘+’。

 

三 程序使用和测试说明

在使用程序的时候，会出现如下的一些界面，用户需要安装对应的提示来输入，并通过输入order的序号来执行对应的操作。

打开程序，得到如图2的开始界面

 

图2.开始界面

 

       输入0得到如图3的菜单列表

 

 

图3.输入0，得到菜单列表

 

       输入1得到如图4的输入多项式的命令空间

 

 

 

图4.输入1，转到输入多项式

 

 

输入的多项式为：

 

q (2,6)(5,5)(-9,4)(6,3)(0,2)(-1,1)(1,0)

o (0,2)(-1,1)(-1,0)

w (3,6)(1,1)(9,2)(0,1)

e (-5,7)(9,5)(0,0)

x (9,9)(6,5)(-1,3)

d (9,9)(6,5)(-1,3)

f (0,0)

t (-1,1)

时，输入order 2得到了多项式列表如图5。

可以看出，各项输出均正确且符合多项式的一般形式规则。

 

                          图5.输出2时的多项式列表

 

       输入3时，转到两个多项式相加的界面如图6，结果正确；

       输入4时，转到两个多项式相减的界面，如图6结果正确.

 

图6.分别输入3和4，转到多项式的加法和减法界面

    输入5，转到多项式相乘的界面，如图7，结果正确；

       输入6，转到判断多项式相等的界面，如图7，结果正确；

 

图7.输入5和6，分别为多项式相乘和判断是否相等

       输入7，转到多项式求导，如图8，结果正确；

       输入8，转到多项式代入求值界面，如图8，结果正确。

 

图8.输入7和8，分别为多项式求导和代入求值

       输入9时程序终止退出。

除此之外，每个命令都测试了多组带有特殊数值，如（0,0）（1,0）（-1,0）（a,1）（0，a）（1,1）等的多项式，并两两进行每一个测试，均正确输出得到相应的结果。数据太过繁琐，在这里就不一一例举了。

需要注意的是，程序对应有一些格式错误的值，不能处理，所以会输出报错的语句。在测试时，使每一个输入都产生不同的错误，查看输出的报错提示。比如：重命名多项式时会报错；输入多项式的名称，但该多项式不存在时会报错；输入order不规范时会报错等等，这也体现了程序的强壮性。

而且在任何一个输入order的时间输入0时，出现菜单；输入9时，退出程序；输入对应的order，实现对应的运算；非规定输入时输出报错，重新输入。

但是程序在输入时不能判别空格和数字以及括号以外的内容，所以请按照举例和说明的样例输入输入多项式，否则程序就会出现错误，这一点还需要继续改进。

 

四 总结和讨论

这次的project大致完成要求的任务，遇到的困难除了一些编译器能检查得出来的错误之外，在写函数的算法以及实现的时候，也遇到了一些问题。

比如重载‘*’的时候，就出现了算法上的错误，最开始的时候是每一项分别相乘得到pair，按顺序push至新的多项式时，如果有系数一致的就合并。但是在测试的时候发现，逐个相乘并不一定是降幂的结果，会导致错误的出现，于是修改了算法，使第一个多项式的每一项分别与第二个多项式的所有项相乘，存为新的多项式，再全部相加；修改后的算法成功地实现了乘法的功能。

之后，同样是在重载函数时出现了问题。在重载‘<<’时，因为考虑的时候，顺序有一些颠倒，if语句和接下来的else的条件考虑不是很完善，先后出现了多个错误，包括（0,0）的问题、首项系数为0不输出的问题和不输入时的i的变化等等。在多次输入带有0,1，-1的特殊条件的检测，和推敲下，最终写出了正确的重载函数。

而且在完成value函数时，因为将一个if语句里的‘==’错打成了‘=’，导致了程序输出的不正确，而这个错误，编译器并没有报错而是正常地运行了。查找的时候，并没有认真回看代码，以为编译器没有报错，代码的书写就是正确的，一直在算法上思考，第二天的时候再回过头看代码时才发现了这个问题。这种“幼稚”的问题，在一个相对不小的程序设计中，可以说是致命的，以后一定要多加注意！

完成的函数没有什么特别突出的优点或者特点，但是尽可能地使整个程序更加清楚，清晰，用户的界面也做了一些小小的装饰，与代码和程序没有什么太大的关系，但是能够给用户更舒适开心的体验。

相对的存在的问题，突出的就是对输入的要求比较多，不允许输入非降幂的多项式，也不允许输入空格和其他非数字、逗号以及小括号以外的字符，同时还要保证括号和逗号位置的一定顺序。这一点还是需要改进，但是考虑到，这样的输入有益于用户的理解，所以衡量了一下，决定输入还是就这样规定了，今后也可以再对其进行改进。

完成这次的project，再一次让我了解到了正确的算法的重要性，认真细心，严密的逻辑思维，和耐心是身为一个程序员，在书写代码的时候，不可或缺的要素，在今后的学习和实验里，要吸取教训，耐心冷静，仔细思考，先想好算法再动手。

 

五 致谢和参考文献

http://www.sgi.com/tech/stl/

http://soj.sysu.edu.cn/

http://sist.sysu.edu.cn/~lh/cplusplus.html

C++程序设计 Y. Daniel Liang 著 （第3版）

Introduction to Programming with C++ (Third Edition)

#include <iostream>
#include <vector>
#include <string>
#include <cstring>
#include <cstdlib>
#include <sstream>
#include <utility>
#include <cmath>

using namespace std;
/*这份编程实验是15年9月编写的，编写实验时没有添加过多的注释，但是所幸命名比较友善，如果有不清楚或有错误的地方，欢迎指正，一起学习~！*/
typedef pair<int, int> term;
typedef vector<term> polynomial;
struct P
{
    char x;
    polynomial p;
};
vector <P> polys;
polynomial getPoly(string s);
polynomial operator +(const polynomial &p, const polynomial &q);
polynomial operator -(const polynomial &p, const polynomial &q);
polynomial operator *(const polynomial &p, const polynomial &q);
bool equal(const polynomial &p, const polynomial &q);
polynomial der(const polynomial &p);
int value(int x, polynomial& p);
ostream& operator <<(ostream& out, const polynomial &q);
ostream& operator <<(ostream& out, const P &q);
bool inter(polynomial x);
bool rename(char x);
void f();
void f1_push();
void f2_print();
void f3_plus();
void f4_sub();
void f5_mul();
void f6_equal();
void f7_der();
void f8_value();
void f0_menu();

polynomial getPoly(string s)
{

    int f, g, h;
    polynomial x;
    for (unsigned int i = 0; i<s.size(); i++)
    {
        if (s[i] == '(')
            f = i;
        else if (s[i] == ',')
            g = i;
        else if (s[i] == ')')
        {
            h = i;
            int a = atoi((s.substr(f + 1, g - 1)).c_str());
            int b = atoi((s.substr(g + 1, h - 1)).c_str());
            x.push_back(make_pair(a, b));
        }
    }
    return x;
}

polynomial operator +(const polynomial &p, const polynomial &q)
{
    polynomial w;
    if (p.size() == 0)
    {
        for (int i = 0; i<q.size(); i++)
            w.push_back(q[i]);
    }
    else if (q.size() == 0)
    {
        for (int i = 0; i<p.size(); i++)
            w.push_back(p[i]);
    }
    else
    {
        int j = 0;    int i = 0;
        while (j <p.size() && i <q.size())
        {
            if (p[j].second >q[i].second)
            {
                w.push_back(p[j]);      j++;
            }
            else if (p[j].second == q[i].second)
            {
                if (p[j].first + q[i].first != 0)
                    w.push_back(make_pair(p[j].first + q[i].first, q[i].second));
                i++;
                j++;
            }
            else
            {
                w.push_back(q[i]);      i++;
            }
        }
        while (j >= p.size() && i <q.size())
        {
            w.push_back(q[i]);    i++;
        }
        while (j <p.size() && i >= q.size())
        {
            w.push_back(p[j]);    j++;
        }
    }

    return w;
}
polynomial operator -(const polynomial &p, const polynomial &q)
{
    polynomial w, x;
    for (int i = 0; i<q.size(); i++)
    {
        x.push_back(make_pair(-q[i].first, q[i].second));
    }
    return p + x;
}

polynomial operator *(const polynomial &p, const polynomial &q)
{
    polynomial x;
    term t;
    vector<polynomial> w;
    polynomial v;
    for (int i = 0; i<p.size(); i++)
    {
        for (int j = 0; j<q.size(); j++)
        {
            t = make_pair(p[i].first*q[j].first, p[i].second + q[j].second);
            v.push_back(t);
        }
        w.push_back(v);
        v.clear();
    }
    x.push_back (make_pair(0,0));
    for (int i = 0; i<w.size(); i++)
    {
        x=w[i]+x;
    }
    return x;
}

bool equal(const polynomial &p, const polynomial &q)
{
    int n = p.size();
    if (n != q.size()) return false;
    for (int i = 0; i<n; i++)
    {
        if (q[i].first != p[i].first || p[i].second != q[i].second)
            return false;
    }
    return true;
}

polynomial der(const polynomial &p)
{
    polynomial w;
    for (int i = 0; i<p.size(); i++)
    {
        if (p[i].second == 0) w.push_back(make_pair(0, 0));
        else w.push_back(make_pair(p[i].first*p[i].second, p[i].second - 1));
    }

    return w;
}

int value(int x, polynomial& p)
{
    int a = 0;
    for (int i = 0; i<p.size(); i++)
    {
        a = a + (p[i].first*(pow(x, p[i].second)));
    }
    return a;
}

ostream& operator <<(ostream& out, const polynomial &q)
{
    int x = 0;
    for (int i=0; i<q.size(); i++)
    {
        if (i == x)
        {
             if (q[i].first == 0)
            {
                 if (q.size() == 1) out << 0;
                 else x++;
            }
            else if (q[i].first == 1)
            {
                if (q[i].second == 1)
                    out << "x";
                else if (q[i].second == 0)
                    out << q[i].first;
                else out << "x^" << q[i].second;

            }
            else if (q[i].first == -1)
            {
                if (q[i].second == 1)
                    out << "-x";
                else if (q[i].second == 0)
                    out << q[i].first;
                else out << "-x^" << q[i].second;

            }
            else if (q[i].second == 1)
                out << q[i].first << "x";
            else if (q[i].second == 0)
                out << q[i].first;
            else
                out << q[i].first << "x^" << q[i].second;
        }
        else if (q[i].first == 0) continue;
        else if (q[i].first == 1)
        {
            if (q[i].second == 1)
                out << "+x";
            else if (q[i].second == 0)
                out << "+" << q[i].first;
            else out << "+x^" << q[i].second;
        }
        else if (q[i].first == -1)
        {
            if (q[i].second == 1)
                out << "-x";
            else if (q[i].second == 0)
                out << q[i].first;
            else out << "-x^" << q[i].second;
        }
        else if (q[i].second == 1)
        {
            if (q[i].first>0)
                out << "+" << q[i].first << "x";
            else out << q[i].first << "x";
        }

        else if (q[i].second == 0)
        {
            if (q[i].first>0)
                out << "+" << q[i].first;
            else out << q[i].first;
        }
        else if (q[i].first<0)
            out << q[i].first << "x^" << q[i].second;
        else if (q[i].first>0)
            out << "+" << q[i].first << "x^" << q[i].second;
    }
    return out;
}

ostream& operator <<(ostream& out, const P &q)
{
    out << q.x << " " << q.p;
    return out;
}

bool inter(polynomial x)
{
    for (int i = 1; i < x.size(); i++)
    {
        if (x[i].second >x[i - 1].second || x[i].second == x[i - 1].second)
            return false;
    }
    return true;
}

bool rename(char x)
{
    if (polys.empty()) return false;
    for (int i = 0; i<polys.size(); i++)
    {
        if (x == polys[i].x)
            return true;
    }
    return false;
}
void f()
{
    cout << "\n       *******************************************************\n" ;
    cout << "           ****************你好，我是多项式计算器*****************\n" ;
    cout << "       *******************************************************\n" ;
    cout << "        ^_^ 很高兴认识你~~~~~你可以用我来计算多项式ＹＯ～～～～～～\n\n" ;
    cout << "下面是功能列表以及相应的order序号，\n"
        << "输入对应的序号就可以开始计算了 ^_^ \n\n" ;
    cout << "1.输入一个多项式\n" ;
    cout << "2.显示一个多项式\n" ;
    cout << "3.两个多项式相加\n" ;
    cout << "4.两个多项式相减\n" ;
    cout << "5.两个多项式相乘\n" ;
    cout << "6.判断两个多项式是否相等\n" ;
    cout << "7.求多项式的导数\n" ;
    cout << "8.求多项式代入某点的值\n" ;
    cout << "9.退出系统\n" ;
    cout << "0.显示菜单\n\n" ;

}

void f1_push()
{
    cout << endl;
    cout << "请输入多项式的名称，最好用一个小写的英文字母命名:   ";
    char x;
    cin >> x;
    if (rename(x))
        cout << "您输入的多项式有误或有重名，请确认之后再从菜单的命令重新输入！\n";
    else
    {
        cout << "请输入多项式，形如(1,3)(2,2)(6,1)代表 x^3+2x^2+6x ，请按降幂输入并不要使用空格键：  ";
        string y;
        cin >> y;
        polynomial p = getPoly(y);
        if (inter(p)==true)
        {
            P P1 = { x, p };
            polys.push_back(P1);
                        cout << "已成功输入，可进行下一步操作或退出~！\n";
        }
        else cout << "您输入的多项式必须按照降幂排列！ \n";
    }
}

void f2_print()
{
    cout << endl;
    cout << "如下是您添加过的多项式：\n" ;
    for (int i = 0; i<polys.size(); i++)
    {
        cout << i << " " << polys[i] << endl;
    }
    cout << "请输入您要输出的多项式的名称，例如 p :   ";
    int ap = -1;
    char x;
    cin >> x;
    for (int i = 0; i<polys.size(); i++)
    {
        if (x == polys[i].x)
            ap = i;
    }
    if (ap == -1) cout << "您输入的该多项式不存在，请确认之后再从菜单的命令重新输入！\n";
    else cout << polys[ap] << endl;
}

void f3_plus()
{
    cout << endl;
    cout << "请输入两个您要相加的多项式，形如p+q，或r=p+q:   ";
    string x;
    cin >> x;
    int a = -1, ap = -1, bp = -1;
    for (int i = 0; i<x.size(); i++)
    {
        if (x[1] == '+') a = 0;
        else if (x[1] == '='&&x[3] == '+') a = 1;
    }
    if (a == 0)
    {
        for (int i = 0; i<polys.size(); i++)
        {
            if (x[0] == polys[i].x)
                ap = i;
        }
        for (int i = 0; i<polys.size(); i++)
        {
            if (x[2] == polys[i].x)
                bp = i;
        }
        if (ap == -1 || bp == -1) cout << "您输入的该多项式不存在，请确认之后再从菜单的命令重新输入！\n";
        else cout << polys[ap].p + polys[bp].p << endl;
    }
    if (a == 1)
    {
        if (rename(x[0]))
            cout << "您新命名的多项式有误或有重名，请确认之后再从菜单的命令重新输入！\n";
        else
        {
            for (int i = 0; i<polys.size(); i++)
            {
                if (x[2] == polys[i].x)
                    ap = i;
            }
            for (int i = 0; i<polys.size(); i++)
            {
                if (x[4] == polys[i].x)
                    bp = i;
            }
            if (ap == -1 || bp == -1) cout << "您输入的多项式不存在，请确认之后再从菜单的命令重新输入！\n";
            else
            {
                cout << x[0] << " " << polys[ap].p + polys[bp].p << endl;
                P P1 = { x[0], polys[ap].p + polys[bp].p };
                polys.push_back(P1);
            }
        }

    }
    if (a == -1) cout << "输入格式有误，请确认之后再从菜单的命令重新输入！\n";
}

void f4_sub()
{
    cout << endl;
    cout << "请输入两个您要相减的多项式，形如p-q，或r=p-q:   ";
    string x;
    cin >> x;
    int a = -1, ap = -1, bp = -1;
    for (int i = 0; i<x.size(); i++)
    {
        if (x[1] == '-') a = 0;
        else if (x[1] == '='&&x[3] == '-') a = 1;
    }
    if (a == 0)
    {
        for (int i = 0; i<polys.size(); i++)
        {
            if (x[0] == polys[i].x)
                ap = i;
        }
        for (int i = 0; i<polys.size(); i++)
        {
            if (x[2] == polys[i].x)
                bp = i;
        }
        if (ap == -1 || bp == -1) cout << "您输入的多项式不存在，请确认之后再从菜单的命令重新输入！\n";
        else cout << polys[ap].p - polys[bp].p << endl;
    }
    if (a == 1)
    {
        if (rename(x[0]))
            cout << "您的输入的多项式有误或有重名，请确认之后再从菜单的命令重新输入！\n";
        else
        {
            for (int i = 0; i<polys.size(); i++)
            {
                if (x[2] == polys[i].x)
                    ap = i;
            }
            for (int i = 0; i<polys.size(); i++)
            {
                if (x[4] == polys[i].x)
                    bp = i;
            }
            if (ap == -1 || bp == -1) cout << "您输入的多项式不存在，请确认之后再从菜单的命令重新输入！\n";
            else
            {
                cout << x[0] << " " << polys[ap].p - polys[bp].p << endl;
                P P1 = { x[0], polys[ap].p - polys[bp].p };
                polys.push_back(P1);
            }
        }
    }
    if (a == -1) cout << "输入格式有误，请确认之后再从菜单的命令重新输入！\n";
}

void f5_mul()
{
    cout << endl;
    cout << "请输入两个您要相乘的多项式，形如p*q，或r=p*q:   ";
    string x;
    cin >> x;
    int a = -1, ap = -1, bp = -1;
    for (int i = 0; i<x.size(); i++)
    {
        if (x[1] == '*') a = 0;
        else if (x[1] == '='&&x[3] == '*') a = 1;
    }
    if (a == 0)
    {
        for (int i = 0; i<polys.size(); i++)
        {
            if (x[0] == polys[i].x)
                ap = i;
        }
        for (int i = 0; i<polys.size(); i++)
        {
            if (x[2] == polys[i].x)
                bp = i;
        }
        if (ap == -1 || bp == -1) cout << "您输入的多项式不存在，请确认之后再从菜单的命令重新输入！\n";
        else cout << polys[ap].p*polys[bp].p << endl;
    }
    if (a == 1)
    {
        if (rename(x[0]))
            cout << "您的输入的多项式有误或有重名，请确认之后再从菜单的命令重新输入！\n";
        else
        {

            for (int i = 0; i<polys.size(); i++)
            {
                if (x[2] == polys[i].x)
                    ap = i;
            }
            for (int i = 0; i<polys.size(); i++)
            {
                if (x[4] == polys[i].x)
                    bp = i;
            }
            if (ap == -1 || bp == -1) cout << "您输入的多项式不存在，请确认之后再从菜单的命令重新输入！\n";
            else
            {
                cout << x[0] << " " << polys[ap].p*polys[bp].p << endl;
                P P1 = { x[0], polys[ap].p*polys[bp].p };
                polys.push_back(P1);
            }

        }
    }
    if (a == -1) cout << "输入格式有误，请确认之后再从菜单的命令重新输入！\n";
}

void f6_equal()
{
    cout << endl;
    cout << "请输入您要判断的两个多项式，形如p==q:   ";
    string x;
    cin >> x;
    int ap = -1, bp = -1;
    if (x[1] != '=' || x[2] != '=') cout << "输入格式有误，请确认之后再从菜单的命令重新输入！\n";
    else
    {
        for (int i = 0; i<polys.size(); i++)
        {
            if (x[0] == polys[i].x)
                ap = i;
        }
        for (int i = 0; i<polys.size(); i++)
        {
            if (x[3] == polys[i].x)
                bp = i;
        }
        if (ap == -1 || bp == -1) cout << "您输入的多项式不存在，请确认之后再从菜单的命令重新输入！\n";
        else
        {
            if (equal(polys[ap].p, polys[bp].p))
                cout << "true" << endl;

            else cout << "false" << endl;

        }
    }
}

void f7_der()
{
    cout << endl;
    cout << "请输入您要求导的多项式的名称，形如 p` 或 r=p` :   ";
    string x;
    cin >> x;
    int a = -1, ap = -1, bp = -1;
    for (int i = 0; i<x.size(); i++)
    {
        if (x[1] == '`') a = 0;
        else if (x[1] == '='&&x[3] == '`') a = 1;
    }
    if (a == 0)
    {
        for (int i = 0; i<polys.size(); i++)
        {
            if (x[0] == polys[i].x)
                ap = i;
        }
        if (ap == -1) cout << "您输入的多项式不存在，请确认之后再从菜单的命令重新输入！\n";
        else cout << der(polys[ap].p) << endl;
    }
    if (a == 1)
    {
        if (rename(x[0]))
            cout << "您的输入的多项式有误或有重名，请确认之后再从菜单的命令重新输入！\n";
        else{

            for (int i = 0; i<polys.size(); i++)
            {
                if (x[2] == polys[i].x)
                    bp = i;
            }
            if (bp == -1) cout << "您输入的多项式不存在，请确认之后再从菜单的命令重新输入！\n";
            else
            {
                cout << x[0] << " " << der(polys[bp].p) << endl;
                P P1 = { x[0], der(polys[bp].p) };
                polys.push_back(P1);
            }
        }
    }
    if (a == -1) cout << "输入格式有误，请确认之后再从菜单的命令重新输入！\n";

}

void f8_value()
{
    cout << endl;
    cout << "请输入要求的多项式和x的值，形如 p[x=3] :   ";
    string x;
    cin >> x;
    int ap = -1;
    if (x[1] != '[' || x[2] != 'x' || x[3] != '=' || x[x.size() - 1] != ']') 
        cout << "输入格式有误，请确认之后再从菜单的命令重新输入！\n";
    else
    {
        for (int i = 0; i<polys.size(); i++)
        {
            if (x[0] == polys[i].x)
                ap = i;
        }
        int a = atoi((x.substr(4, x.size() - 4)).c_str());
        if (ap == -1) cout << "您输入的多项式不存在，请确认之后再从菜单的命令重新输入！\n";
        else cout << value(a, polys[ap].p) << endl;
    }

}

void f0_menu()
{
    cout << "\n\n1.输入一个多项式\n" ;
    cout << "2.显示一个多项式\n" ;
    cout << "3.两个多项式相加\n" ;
    cout << "4.两个多项式相减\n" ;
    cout << "5.两个多项式相乘\n" ;
    cout << "6.判断两个多项式是否相等\n" ;
    cout << "7.求多项式的导数\n" ;
    cout << "8.求多项式代入某点的值\n" ;
    cout << "9.退出系统\n" ;
    cout << "0.显示菜单\n\n" ;
}


int main()
{
    f();

    string order;
    cin >> order;

    while (1)
    {
        if (order != "1"&&order != "2"&&order != "3"&&order != "4"&&order != "5"
            &&order != "6"&&order != "7"&&order != "8"&&order != "9"&&order != "0")
            cout << "您输入的是非法order，请重新输入！\n" ;

        if (order == "1")  f1_push();
        if (order == "2")  f2_print();
        if (order == "3")  f3_plus();
        if (order == "4")  f4_sub();
        if (order == "5")  f5_mul();
        if (order == "6")  f6_equal();
        if (order == "7")  f7_der();
        if (order == "8")  f8_value();
        if (order == "9")
        {
            cout << "感谢您的使用，与您下次再见~\n" ;
            return 0;
        }
        if (order == "0")  f0_menu();

        cin >> order;
    }

    return 0;
}