Classe Polynomial. Desenvolva a classe Polynomial.

A representação interna de um Polynomial é um array

de termos. Cada termo contém um coeficiente e um expoente,

por exemplo, o termo

2x4

tem o coeficiente 2 e o expoente 4. Desenvolva uma classe

completa que contenha as funções construtor e destrutor

apropriadas, além de funções set e get. A classe também

deverá fornecer as seguintes capacidades de operador sobrecarregado:

a) Sobrecarregue o operador de adição (+) para somar

dois Polynomials.

b) Sobrecarregue o operador de subtração (-) para

subtrair dois Polynomials.

c) Sobrecarregue o operador de atribuição para atribuir

um Polynomial a outro.

d) Sobrecarregue o operador de multiplicação (*) para

multiplicar dois Polynomials.

e) Sobrecarregue o operador de atribuição com adição

(+=), o operador de atribuição com subtração (-=)

e o operador de atribuição com multiplicação (*=).

Passo 1

Vamos criar a classe Polynomial. A classe vai conter um vetor de termos que definiremos como um tipo de estrutura que contém dois valores: um coeficiente e um expoente.

Não vamos nos preocupar em ordenar o polinômio para ter o formato convencional de um polinômio porque isso só é importante na saída dos valores.

Vamos declarar a classe no arquivo de cabeçalho "Polynomial.h" da seguinte forma:

#ifndef H_POLYNOMIAL_H

#define H_POLYNOMIAL_H

#include

using namespace std;

struct Term {

int coefficient;

int exponent;

};

class Polynomial {

public:

explicit Polynomial(const vector &terms);

Polynomial();

const vector &getTerms() const;

void setTerms(const vector &terms);

Polynomial operator+(const Polynomial&) const;

Polynomial operator-(const Polynomial&) const;

Polynomial& operator=(const Polynomial&);

Polynomial operator*(const Polynomial&) const;

Polynomial operator+=(const Polynomial&);

Polynomial operator-=(const Polynomial&);

Polynomial operator*=(const Polynomial&);

void print() const;

private:

void add(vector& dest,

const Term& term) const;

vector terms;

};

#endif

Agora, vamos implementar as funções no arquivo fonte "Polynomial.cpp".

Em primeiro lugar, o cabeçalho do arquivo junto com as implementações do construtor e as implementações das funções getter e setter:

#include

#include "Polynomial.h"

using namespace std;

Polynomial::Polynomial(const vector &terms)

: terms(terms) {}

Polynomial::Polynomial() {}

const vector &Polynomial::getTerms() const {

return terms;

}

void Polynomial::setTerms(const vector &terms) {

Polynomial::terms = terms;

}

...

Passo 2

  1. Para adicionar dois polinômios, vamos iterar através do vetor de um polinômio, encontrando e adicionando coeficientes de expoentes correspondentes e empurrando novos elementos para a matriz no caso de uma figura de expoente inexistente. Antes de fazermos isso, vamos extrair uma função porque ela se repetirá dentro da função de sobrecarga do operador de multiplicação.
  2. A função privada add() adicionará um único termo ao polinômio (vetor de termos).

    Use um valor booleano para ver se havia uma figura de expoente correspondente.

    Itere através dos termos no vetor para encontrar o expoente correspondente da seguinte forma:

    void Polynomial::add(vector &dest,

    const Term& term) const {

    bool used = false;

    for (int i = 0; i

    {

    if (term.exponent

    == dest.at(i).exponent)

    {

    dest.at(i).coefficient

    += term.coefficient;

    used = true;

    break;

    }

    }

    if (!used)

    dest.push_back(term);

    }

    Agora, na função do operador de sobrecarga de adição, criaremos um novo objeto e adicionaremos todos os termos do operando direito (polinômio):

    Polynomial Polynomial::operator+(

    const Polynomial &op2) const {

    Polynomial res = *this;

    for (Term op2Term : op2.terms)

    add(res.terms, op2Term);

    return res;

    }

    Passo 3

  3. Agora, na função do operador de sobrecarga de adição, criaremos um novo objeto e adicionaremos todos os termos do operando direito (polinômio):
  4. Polynomial Polynomial::operator-(

    const Polynomial &op2) const {

    Polynomial res = *this;

    for (Term op2Term : op2.terms)

    {

    bool used = false;

    for (int i = 0; i

    {

    if (op2Term.exponent

    == res.terms.at(i).exponent)

    {

    res.terms.at(i).coefficient

    -= op2Term.coefficient;

    used = true;

    break;

    }

    }

    if (!used)

    res.terms.push_back({-op2Term.coefficient,

    op2Term.exponent});

    }

    return res;

    }

    Passo 4

  5. Para atribuir um polinômio a outro objeto, primeiro veremos se ambos os objetos são o mesmo objeto comparando suas referências da seguinte forma:
  6. Polynomial &Polynomial::operator=(const Polynomial &right)

    {

    if (&right != this)

    {

    ...

    }

    ...

    }

    Caso contrário, limpe o vetor e adicione todos os termos do polinômio:

    Polynomial &Polynomial::operator=(const Polynomial &right)

    {

    if (&right != this)

    {

    terms.clear();

    for (Term term : right.terms)

    terms.push_back(term);

    }

    ...

    }

    Certifique-se de retornar *this para habilitar a cascata:

    Polynomial &Polynomial::operator=(const Polynomial &right)

    {

    ...

    return *this;

    }

  7. Para multiplicar dois polinômios, vamos iterar pelos termos de ambos os polinômios, adicionando os produtos a um novo objeto que será finalmente retornado:
  8. Utilize a função privada add() definida anteriormente para adicionar termos a um polinômio.

    Polynomial Polynomial::operator*(

    const Polynomial &op2) const {

    Polynomial res;

    for (Term op2Term : op2.terms)

    for (Term term : terms)

    add(res.terms, {term.coefficient *

    op2Term.coefficient,

    term.exponent

    + op2Term.exponent});

    return res;

    }

  9. Agora, para criar sobrecargas de operador de atribuição de adição/subtração/multiplicação, usaremos as sobrecargas de operador de adição/subtração/multiplicação já definidas para modificar o polinômio esquerdo *this e retornar *this para habilitar a cascata:

Polynomial Polynomial::operator+=(

const Polynomial &op2) {

*this = *this + op2;

return *this;

}

Polynomial Polynomial::operator-=(

const Polynomial &op2) {

*this = *this - op2;

return *this;

}

Polynomial Polynomial::operator*=(

const Polynomial &op2) {

*this = *this * op2;

return *this;

}

Para fins de demonstração, criaremos uma função print() que exibirá os valores de um objeto Polynomial na forma convencional:

void Polynomial::print() const {

vector sorted;

int cnt = 0, i = 0;

while (cnt

{

for (Term term : terms)

{

if (term.exponent == i)

{

sorted.push_back(term);

cnt++;

break;

}

}

i++;

}

for (int j = sorted.size() - 1; j >= 0; j--)

{

if (sorted.at(j).coefficient >= 0

&& j != sorted.size() - 1)

cout

if (sorted.at(j).exponent == 0)

cout

else if (sorted.at(j).exponent == 1)

cout

else

cout

}

cout

}

O arquivo principal para fins de demonstração:

#include

#include "Polynomial.h"

using namespace std;

int main()

{

Polynomial p1(vector{

{1, 1},

{1, 0}});

Polynomial p2(vector{

{2, 1},

{3, 3}});

(p1 + p2).print();

(p1 - p2).print();

(p1 * p2).print();

p1 *= p2;

p1.print();

}

Resposta

Ver desenvolvimento.