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
Polynomial();
const vector
void setTerms(const vector
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
const Term& term) const;
vector
};
#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) {}
Polynomial::Polynomial() {}
const vector
return terms;
}
void Polynomial::setTerms(const vector
Polynomial::terms = terms;
}
...
Passo 2
- 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.
- 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):
- 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:
- 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:
- 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:
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
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
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
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;
}
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;
}
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
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.