asfdg

#include <algorithm>
#include <iostream>
#include <vector>

class T {
public:
    // reduced all by -1 in ctor
    // default - 2
    int x;

    T(): x(2) {}
    T(int _x): x(_x - 1) {}

    bool operator==(int _x) const {
        return x + 1 == _x;
    }

    bool operator!=(int _x) const {
        return !(*this == _x);
    }
};

std::ostream& operator<<(std::ostream& out, const T& t) {
    out << (t.x + 1);
    return out;
}








// можно сравнивать с ValueType с int == и !=

template <typename ValueType>
class Polynomial {
//private:
public:
    ValueType ZERO;
    std::vector<ValueType> coeffs;

    void delete_leading_zeros();

//public:
    // ctors
    explicit Polynomial(const std::vector<ValueType>&);
    explicit Polynomial(const ValueType& = ValueType());

    template <typename Iter>
    Polynomial(Iter first, Iter last);

    int Degree() const;

    const ValueType& operator[](size_t index) const;
    ValueType& operator[](size_t index);

    typename std::vector<ValueType>::const_iterator begin();
    typename std::vector<ValueType>::const_iterator end();
};

//template<typename ValueType>
//const ValueType Polynomial<ValueType>::ZERO(0);

template<typename ValueType>
void Polynomial<ValueType>::delete_leading_zeros() {
    while (!coeffs.empty() && coeffs.back() == 0) {
        coeffs.pop_back();
    }
}

template<typename ValueType>
Polynomial<ValueType>::Polynomial(const std::vector<ValueType>& coeffs_vec):
                                coeffs(coeffs_vec.begin(), coeffs_vec.end()), ZERO(ValueType(0)) {
    delete_leading_zeros();
}

template<typename ValueType>
Polynomial<ValueType>::Polynomial(const ValueType& coeff): coeffs{coeff}, ZERO(ValueType(0)) {
    delete_leading_zeros();
}

template<typename ValueType>
template<typename Iter>
Polynomial<ValueType>::Polynomial(Iter first, Iter last): coeffs(first, last), ZERO(ValueType(0)) {
    delete_leading_zeros();
}

template<typename ValueType>
int Polynomial<ValueType>::Degree() const {
    return static_cast<int>(coeffs.size()) - 1;
}

template<typename ValueType>
const ValueType& Polynomial<ValueType>::operator[](size_t index) const {
    if (index > Degree()) {
        return ZERO;
    } else {
        return coeffs[index];
    }
}

template<typename ValueType>
ValueType &Polynomial<ValueType>::operator[](size_t index) {
    return coeffs[index];
}

template<typename ValueType>
typename std::vector<ValueType>::const_iterator Polynomial<ValueType>::begin() {
    return coeffs.begin();
}

template<typename ValueType>
typename std::vector<ValueType>::const_iterator Polynomial<ValueType>::end() {
    return coeffs.end();
}

template<typename ValueType>
ValueType operator+(const Polynomial<ValueType>& lhs, const Polynomial<ValueType>& rhs) {
    std::vector<ValueType> res;

    for (size_t deg = 0; deg <= std::max(lhs.Degree(), rhs.Degree()); ++deg) {
        res.push_back(lhs[deg] + rhs[deg]);
    }
    return Polynomial(res);
}

template<typename ValueType>
ValueType operator+(const Polynomial<ValueType>& lhs, const ValueType& rhs) {
    return Polynomial(lhs[0] + rhs);
}

template<typename ValueType>
ValueType operator+(const ValueType& lhs, const Polynomial<ValueType>& rhs) {
    return rhs + lhs;
}

template<typename ValueType>
ValueType operator-(const Polynomial<ValueType>& lhs, const Polynomial<ValueType>& rhs) {
    std::vector<ValueType> res;
    for (size_t deg = 0; deg <= std::max(lhs.Degree(), rhs.Degree()); ++deg) {
        res.push_back(lhs[deg] + rhs[deg]);
    }
    return Polynomial(res);
}

template<typename ValueType>
ValueType operator-(const Polynomial<ValueType>& lhs, const ValueType& rhs) {
    return Polynomial(lhs[0] - rhs);
}

template<typename ValueType>
ValueType operator-(const ValueType& lhs, const Polynomial<ValueType>& rhs) {
    return Polynomial(lhs - rhs[0]);
}

using namespace std;

int main() {
    vector<T> vec = {{1}, {2}, {-5}};

    Polynomial<T> poly(vec);
    for (const auto& x : poly) {
        cout << x << ' ';
    }
}