poly

#include <cmath>
#include <iostream>
#include <list>

class Term {
public:
    int coef;
    int exp;
};

using Polynomial = std::list<Term>;

void getPolynomial(Polynomial &);

int calcPolynomial(const Polynomial &, int);

void combineLikeTerms(Polynomial &);

bool cmp(const Term &, const Term &);

std::ostream &operator<<(std::ostream &, const Polynomial &);

Polynomial operator+(Polynomial, Polynomial);

Polynomial operator-(Polynomial, Polynomial);

int main() {
    Polynomial p, q;

    getPolynomial(p);
    getPolynomial(q);

    p.sort(cmp);
    q.sort(cmp);

    std::cout << "P(x) = " << p << std::endl;
    std::cout << "Q(x) = " << q << std::endl;

    int x;
    std::cout << "x = ";
    std::cin >> x;
    std::cout << "P(" << x << ") = " << calcPolynomial(p, x) << std::endl;
    std::cout << "Q(" << x << ") = " << calcPolynomial(q, x) << std::endl;

    std::cout << "R(x) = " << p + q << std::endl;
    std::cout << "T(x) = " << p - q << std::endl;

    return 0;
}

void getPolynomial(Polynomial &p) {
    int terms;
    std::cin >> terms;
    for (int i = 0; i < terms; i++) {
        Term tmp{};
        std::cin >> tmp.coef >> tmp.exp;
        p.emplace_back(tmp);
    }
}

int calcPolynomial(const Polynomial &p, int x) {
    int r = 0;
    for (const auto it: p) {
        r += it.coef * static_cast<int>(pow(x, it.exp));
    }
    return r;
}

void combineLikeTerms(Polynomial &p) {
    auto it = p.begin();
    while (it != p.end() && std::next(it) != p.end()) {
        if (it->exp == std::next(it)->exp) {
            it->coef += std::next(it)->coef;
            it = p.erase(++it);
        } else {
            it++;
        }
    }
}

bool cmp(const Term &a, const Term &b) {
    return a.exp >= b.exp;
}

std::ostream &operator<<(std::ostream &os, const Polynomial &p) {
    auto it = p.begin();
    os << std::noshowpos << it->coef << "x^" << it->exp;
    while (++it != p.end()) {
        os << std::showpos << it->coef << "x^" << std::noshowpos << it->exp;
    }
    return os;
}

Polynomial operator+(Polynomial p, Polynomial q) {
    auto it = p.end();
    p.splice(it, q);

    p.sort(cmp);
    combineLikeTerms(p);
    return p;
}

Polynomial operator-(Polynomial p, Polynomial q) {
    for (auto &it: q) {
        it.coef *= -1;
    }
    auto it = p.end();
    p.splice(it, q);

    p.sort(cmp);
    combineLikeTerms(p);
    return p;
}