Polynomial

// C++20
#include <algorithm>
#include <iostream>
#include <set>
#include <string>
#include <vector>

using namespace std;

struct Coefficient
{
    char sign;
    int value;

    Coefficient()
        : sign('+'), value(1)
    {
    }

    Coefficient(const char sign, const int value)
        : sign(sign), value(value)
    {
    }
};

struct Unknown
{
    char name;
    int power;

    Unknown()
        : name(' '), power(1)
    {
    }

    Unknown(const char name)
        : name(name), power(1)
    {
    }

    Unknown(const char name, const int power)
        : name(name), power(power)
    {
    }
private:
    friend bool operator<(const Unknown& a, const Unknown& b) {
        return a.name < b.name;
    }

    friend bool operator==(const Unknown& a, const Unknown& b) {
        return a.name == b.name && a.power == b.power;
    }
};

struct Member
{
    Coefficient coefficient;
    set<Unknown> unknown;

    Member(const Coefficient& coefficient, const set<Unknown>& unknown = {})
        : coefficient(coefficient), unknown(unknown)
    {
    }

    const Member& operator-() {
        if (coefficient.sign == '-') {
            coefficient.sign = '+';
        }
        else {
            coefficient.sign = '-';
        }
        return *this;
    }

    string tostring() const {
        string member;
        if (coefficient.value == 0) {
            return member;
        }
        member += coefficient.sign;
        if (coefficient.value != 1) {
            member += to_string(coefficient.value);
        }
        else if (unknown.empty()) {
            member += '1';
        }
        for (const auto& item : unknown) {
            if (item.name != ' ') {
                member += item.name;
                if (item.power != 1) {
                    member += '^' + to_string(item.power);
                }
            }
        }
        return member;
    }
private:
    friend Member operator+(const Member& a, const Member& b) {
        const auto qa = a.coefficient.sign == '-' ? -a.coefficient.value : a.coefficient.value;
        const auto qb = b.coefficient.sign == '-' ? -b.coefficient.value : b.coefficient.value;
        const auto sum = qa + qb;
        const auto sign = sum < 0 ? '-' : '+';
        Coefficient q{ sign, abs(sum) };
        return { q, a.unknown};
    }

    friend Member operator-(const Member& a, const Member& b) {
        const auto qa = a.coefficient.sign == '-' ? a.coefficient.value : -a.coefficient.value;
        const auto qb = b.coefficient.sign == '-' ? b.coefficient.value : -b.coefficient.value;
        const auto sum = qa + qb;
        const auto sign = sum < 0 ? '-' : '+';
        Coefficient q{ sign, abs(sum) };
        return { q, a.unknown };
    }

    friend bool operator==(const Member& a, const Member& b) {
        return a.unknown == b.unknown;
    }
};

struct Polynomial
{
    vector<Member> polynomial;

    Polynomial() = default;

    Polynomial(const vector<Member>& polynomial)
        : polynomial(polynomial)
    {
    }

    // Метод принимает строку многочлена
    // Выполняет синтаксический анализ
    // В случае успеха заносит члены в вектор и возвращает true
    // В противном случае возвращает false
    bool parse(const string& ps) {
        if (!polynomial.empty()) {
            polynomial.clear();
        }
        // TODO: Осталось начать и кончить :)

        return true;
    }
private:
    // Метод собирает члены из вектора в строку многочлена
    string tostring() const {
        string total;
        for (const auto& polynom : polynomial) {
            total += polynom.tostring();
        }
        if (total.front() == '+') {
            total = total.erase(0, 1);
        }
        // TODO: При необходимости расставить пробелы
        return total;
    }

    friend Polynomial operator+(const Polynomial& a, const Polynomial& b) {
        Polynomial sum = a;
        for (const auto& polynom : b.polynomial) {
            auto it = find(sum.polynomial.begin(), sum.polynomial.end(), polynom);
            if (it == sum.polynomial.end()) {
                sum.polynomial.push_back(polynom);
            }
            else {
                *it = *it + polynom;
            }
        }
        return sum;
    }

    friend Polynomial operator-(const Polynomial& a, const Polynomial& b) {
        Polynomial sub = a;
        for (Member polynom : b.polynomial) {
            auto it = find(sub.polynomial.begin(), sub.polynomial.end(), polynom);
            if (it == sub.polynomial.end()) {
                sub.polynomial.push_back(-polynom);
            }
            else {
                *it = *it + -polynom;
            }
        }
        return sub;
    }

    friend ostream& operator<<(ostream& out, const Polynomial& p) {
        return out << p.tostring();
    }
};

void test() {
    vector<Member> a{
        {{}, {{'x', 2}}},
        {{'+', 5}, {{'x', 1}}},
        {{'+', 2}}
    };
    vector<Member> b{
        {{}, {{'x', 2}}},
        {{'-', 5}, {{'x', 1}}},
        {{'+', 3}}
    };
    Polynomial pa(a);
    Polynomial pb(b);
    const auto ab_sum = pa + pb;
    const auto pb_sub = pa - pb;
    cout << pa << " + " << pb << " = " << ab_sum << '\n';
    cout << pa << " - " << pb << " = " << pb_sub << '\n';
}

void run() {
    string a;
    getline(cin, a); // >>> x^2+5x+2
    Polynomial pa;
    pa.parse(a);
    string b;
    getline(cin, b); // >>> x^2-5x+3
    Polynomial pb;
    pa.parse(b);
    const auto sum_ab = pa + pb;
    cout << pa << " + " << pb << " = " << sum_ab << '\n'; // <<< 2x^2+5
    const auto sub_ab = pa - pb;
    cout << pa << " - " << pb << " = " << sub_ab << '\n'; // <<< 10x-1
}

int main() {
    test();
    //run(); // После реализации лексического анализа начнёт работать
}