huinya

#include <iostream>
#include <string>
#include <vector>

using namespace std;

template <typename T>
class Polynomial {
private:
    vector<T> polynom;
    int size_p = 0;
public:
    void delete_zeros() {
        vector<T> result = polynom;
        for (int i = size_p - 1; i > -1; i--) {
            if (result[i] == 0) {
                result.pop_back();
                size_p--;
            } else {
                i = -1;
            }
        }
        polynom = result;
    }

    template<typename Iter = typename vector<T>::iterator>
    Polynomal(vector<T> pol) {
        Iter it;
        for (it = pol.begin(); it != pol.end(); it++) {
            polynom.push_back(*it);
        }
        size_p = pol.size();
        this->delete_zeros();
    }

    Polynomal(T object) {
        polynom.push_back(object);
        this->size_p = 1;
    }

    template<typename Iter = typename vector<T>::iterator>
    Polynomal(Iter begin, Iter end) {
        Iter it;
        size_p = 0;
        for (it = begin; it != end; it++) {
            polynom.push_back(*it);
            size_p++;
        }
        this->delete_zeros();
    }

    vector<T> get_polynom() {
        return polynom;
    }

    vector<T> get_size() {
        return size_p;
    }

    vector<T> multiply(vector<T> A, vector<T> B) {
        int m = A.size();
        int n = B.size();
        vector<T> prod;
        for (int i = 0; i < m + n - 1; i++) {
            prod.push_back(0);
        }
        for (int i = 0; i< m; i++) {
            for (int j = 0; j < n; j++) {
                prod[i + j] += A[i] * B[j];
            }
        }
        return prod;
    }

    bool operator == (Polynomal<T> pol) {
        return polynom == pol.get_polynom();
    }

    bool operator != (Polynomal<T> pol) {
        return polynom == pol.get_polynom();
    }

    void operator += (Polynomal<T> pol) {
        for (int i = 0; i < size_p; i++) {
            polynom[i] += pol.get_polynom[i];
        }
        *this.delete_zeros();
    }

    void operator -= (Polynomal<T> pol) {
        for (int i = 0; i < size_p; i++) {
            polynom[i] -= pol.get_polynom[i];
        }
        *this.delete_zeros();
    }

    void operator *= (Polynomal<T> pol) {
        size_p = size_p + pol.get_size();
        vector<T> result_coeff = multiply(polynom, pol.get_polynom());
        polynom = result_coeff;
    }

    Polynomal<T> operator + (Polynomal<T> pol) {
        Polynomal<T> result = *this;
        for (int i = 0; i < size_p; i++) {
            result.get_polynom[i] += pol.get_polynom[i];
        }
        return result;
    }

    Polynomal<T> operator - (Polynomal<T> pol) {
        Polynomal<T> result = *this;
        for (int i = 0; i < size_p; i++) {
            result.get_polynom[i] -= pol.get_polynom[i];
        }
        return result;
    }

    Polynomal<T> operator * (Polynomal<T> pol) {
        Polynomal<T> result = *this;
        result *= pol;
        return result;
    }

};

int main() {
    vector<int> result = { 1, 2, 3, 4 };
    Polynomial<int> polynom(5);

}