Question

以下是我要解决的问题：

使用动态数组，用多项式加法实现多项式类，减法和乘法。讨论：多项式中的变量除了作为占位符之外什么也不做系数。因此，关于多项式的唯一有趣的事情是数组系数和相应的指数。想想多项式 x x x + x + 1 x * x中的术语在哪里？实现多项式类的一种简单方法是使用双精度数组来存储系数。数组的索引是相应术语的指数。如果缺少一个术语，那么它只是一个零系数。存在用于表示具有许多缺失的高度多项式的技术条款。这些使用所谓的稀疏矩阵技术。除非你已经知道这些技术，或者学得很快，不要使用这些技术。提供默认构造函数，复制构造函数和参数化构造函数这使得能够构造任意多项式。提供一个重载的operator =和一个析构函数。提供以下操作：多项式+多项式，常数+多项式，多项式+常数，多项式 - 多项式，常数 - 多项式，多项式 - 常数。多项式*多项式，常数*多项式，多项式*常数，提供分配和提取系数的函数，由指数索引。提供一个函数来评估double类型的多项式。您应该决定是将这些功能实现为成员，朋友还是独立功能。

这不适合上课，我只是想自学C ++，因为我需要它，因为今年秋天我将在FSU开始我的金融数学研究生课程。这是我到目前为止的代码：

class Polynomial
{
private:
    double *coefficients; //this will be the array where we store the coefficients       
    int degree; //this is the degree of the polynomial (i.e. one less then the length of the array of coefficients)

public:
    Polynomial(); //the default constructor to initialize a polynomial equal to 0
    Polynomial(double coeffs[] , int nterms); //the constructor to initialize a polynomial with the given coefficient array and degree
    Polynomial(Polynomial&); //the copy constructor
    Polynomial(double); //the constructor to initialize a polynomial equal to the given constant
    ~Polynomial() { delete coefficients; } //the deconstructor to clear up the allocated memory

    //the operations to define for the Polynomial class
    Polynomial operator+(Polynomial p) const;
    Polynomial operator-(Polynomial p) const;
    Polynomial operator*(Polynomial p) const;
};

//This is  the default constructor 
Polynomial::Polynomial() {
    degree = 0;
    coefficients = new double[degree + 1];
    coefficients[0] = 0;
}

//Initialize a polynomial with the given coefficient array and degree
Polynomial::Polynomial(double coeffs[], int nterms){
    degree = nterms;
    coefficients = new double[degree]; //array to hold coefficient values
    for(int i = 0; i < degree; i++)
        coefficients[i] = coeffs[i];
}

Polynomial::Polynomial(Polynomial&){

}

//The constructor to initialize a polynomial equal to the given constant
Polynomial::Polynomial(double){

}

Polynomial::operator *(Polynomial p) const{

}

Polynomial::operator +(Polynomial p) const{

}

Polynomial::operator -(Polynomial p) const{

}

我只是想知道我是否走在正确的轨道上，如果有更好的方法，请告诉我。任何意见或建议将不胜感激。

Answer 1

您的代码状态

到目前为止，如果nterms表示多项式的最大度

，则代码是正确的

实现多项式类的一种简单方法是使用双精度数组来存储系数。

这就是你做的

数组的索引是相应术语的指数

这就是为什么我告诉你你的数组大小等于程度数+ 1 这样你就可以使用它的度数（这将是关键）来访问系数（数组的值）

如果缺少一个术语，那么它只有一个零系数。

请注意，在给出的示例中，x²不存在，但代码中存在coefficients[2]且等于0

提供以下操作：多项式+多项式，常数+多项式，多项式+常数，多项式 - 多项式，常数 - 多项式，多项式 - 常数。多项式*多项式，常数*多项式，多项式*常数，提供分配和提取系数的函数，由指数索引。提供一个函数来计算double类型的多项式

正如您所提到的，您错过了一些运算符重载。

更进一步

这是一个非详尽的列表，列出了在完成本练习后可以通过C ++获得更多经验的方法： - 你可以实现一个表达式解析器（使用） - 处理更复杂的多项式（即x²+y²+ 2xy + 1） - 使用map来存储你的系数（通过这个练习可能不会将Map视为动态数组，但你可能会很有趣）或其他数据结构来获取你的系数中的零点！（参见稀疏矩阵/数组技术）

在将来的学习中享受乐趣！

Answer 2

这不是一个完整的答案，而是一个起点。我使用std :: set因为它保持了元素的顺序，所以我实现了一个仿函数并用于我的集合。现在，集合中的元素将根据我的比较函数进行排序。在当前的实现中，术语将按指数的降序排序。

#include<set>

struct Term
{
    int coefficient;
    int exponent;
    Term(int coef, int exp) : coefficient{ coef }, exponent{ exp } {}
};
struct TermComparator
{
    bool operator()(const Term& lhs, const Term& rhs) {
        return lhs.exponent < rhs.exponent;
    }
};


class Polynomial
{
private:
    std::set<Term, TermComparator> terms;
public:
    Polynomial();
    ~Polynomial();
    Polynomial operator+(Polynomial p); 
};

我的实现允许您有效地存储更高阶的多项式。我为你实现了补充。它在OOP方面不是最好的形状，但你可以重构它。

Polynomial Polynomial::operator+(Polynomial p) 
{
    auto my_it = terms.begin();
    auto p_it = p.terms.begin();
    Polynomial result;

    while (my_it != terms.end() && p_it != p.terms.end())
    {
        if (my_it->exponent > p_it->exponent)
        {
            result.terms.insert(*my_it);
            ++my_it;
        }
        else if (my_it->exponent == p_it->exponent)
        {
            result.terms.insert(Term(my_it->coefficient + p_it->coefficient, my_it->exponent));
            ++my_it;
            ++p_it;
        }
        else
        {
            result.terms.insert(*p_it);
            ++p_it;
        }
    }

    //only one of the for loops will be effective
    for (; my_it != terms.end(); ++my_it) result.terms.insert(*my_it);
    for (; p_it != p.terms.end(); ++p_it) result.terms.insert(*p_it);

    return result;
}

多项式类

2 个答案: