constructor for a polynomial class that must initialize the coefficients although the degree is unknown

Question

i have this question:

You will implement a polynomial class that uses a dynamic array to store the polynomial's coefficients. The Polynomial class has two private members variables: a dynamic array to store the coefficients and the degree of the polynomial like so:

(private: double *coef; // Pointer to the dynamic array

int degree; // the polynomial degree)

1.Write the constructors permitting the initialization of simple polynomials of the following way:

i. Polynomial p1(3,1); // polynomial of degree 1 p1 = 3 x+1

ii. Polynomial p2(1,4,2); // polynomial of degree 2 p2 = x2+4x+2

iii. Polynomial p3(1,3,3,1); // polynomial of degree 3 p3 = x3+ 3x2 + 3x +1

that is the question.

these constructors are being handed the coefficients but the number of coefficients is chosen by the user, how do i make such constructor(s)?? and i cant put a limit on the degree of the polynomial the user wants to enter(if this were the case, i could put default values that are zero so that if he doesnt give all coefficinets, the rest of coefficients will be zero)

is the dynamic array member going to help in this problem?

Have you tried something like `Polynomial(int coef_1, int constant)`? — Thomas Matthews, Mar 30 '22 at 16:59
no, the constructor i have to give has to be called like the examples given by the question. — Diana Osman, Mar 30 '22 at 17:01
but can you please explain how the way you suggested would solve it?? — Diana Osman, Mar 30 '22 at 17:02
What part are you having issues with? Dynamically allocating memory? writing a constructor? — Thomas Matthews, Mar 30 '22 at 17:16
the question is sort of like a challenge, i have to write a constructor or bunch of constructors, that are called like this: polynomial(user gives as many coef as he wants) — Diana Osman, Mar 30 '22 at 17:23
You can overload the constructors. For example, you can have one constructor with 2 parameters and another constructor with three parameters. See my answer. — Thomas Matthews, Mar 30 '22 at 17:24

Thomas Matthews · Accepted Answer · 2022-03-30T17:22:43.877

I suggest creating a struct Term:

struct Term
{
    int coefficient;
    int power;
};

A polynomial, by definition is a container (or sum) of terms:

class Polynomial
{
  public:
    std::vector<Term>  terms;
    Polynomial(int coef1, int constant1);
}

In the above class, the constructor will create two terms:

Polynomial::Polynomial(int coef1, int constant1)
{
    Term t1;
    Term c;
    t1.coefficient = coef1;
    t1.power = 1;
    c.coefficient = constant1;
    c.power = 0;
    terms.push_back(c);
    terms.push_back(t1);
}

The next constructor, in your requirements, creates 3 terms:

Polynomial::Polynomial(int coef1, int coef2, int constant1)
{
    Term t1 = {coef1, 2};
    Term t2 = {coef2, 1};
    Term constant_term = {constant1, 0};
    terms.push_back(constant_term);
    terms.push_back(t2);
    terms.push_back(t1);
}

One of the theorems of addition is that the terms can be in any order. You can change the order that you append them to the container so you print them in common order (highest exponent term first).

Array of Coefficients

In the requirements, there is double * coef which is supposed to be an array of coefficients (one for each term).

Here's one example of a constructor:

Polynomial::Polynomial(double coef1, double constant)
{
    degree = 1;
    coef = new double[2]; // 2 terms.
    coef[0] = coef1;
    coef[1] = constant;
}

The other constructors are similar to the above one.

Remember, your destructor should contain delete[] coef;.

constructor for a polynomial class that must initialize the coefficients although the degree is unknown

1 Answers1

Array of Coefficients