Polynomial Class Implementation Issue

[marcchmiel96]

Hello. I'm currently having issues with one of my programs and I can't figure out why it doesn't work. I have tried different variations of my code, and other ways of doing it and it still won't work.

#ifndef __POLYNOMIAL_CPP__
#define __POLYNOMIAL_CPP__

#include "polynomial.h"
#include <iostream>
#include <list>

using namespace std;

//copy assignment
template<typename NumberType>
/*Done*/ const Polynomial<NumberType> & Polynomial<NumberType>::operator=(const Polynomial<NumberType> & rhs) {
	if (this != &rhs) {
		term_list = rhs.term_list;
		highest_degree = rhs.highest_degree;
		number_of_terms = rhs.number_of_terms;
	}
	return *this;
}

 //binary math function things start//
template<typename NumberType>
/*Done*/ Polynomial<NumberType> Polynomial<NumberType>::operator+=(const Monomial<NumberType> &m) {
	insert_in_poly(*this, m);
	return *this;
}
template<typename NumberType>
/*Done*/ Polynomial<NumberType> Polynomial<NumberType>::operator+=(const Polynomial<NumberType> & rhs) {
	Polynomial<NumberType> sumTemp;
	list<Monomial<NumberType>>::const_iterator listItr = term_list.begin();

	while (!(*listItr).end()) {
		sumTemp += rhs.*listItr;
	}
	*this = sumTemp;
	return *this;
}
template<typename NumberType>
/*Done*/ const Polynomial<NumberType> Polynomial<NumberType>::operator+ (const Monomial<NumberType> &m)const {
	return Polynomial(*this) += m;
}
template<typename NumberType>
/*Done*/ const Polynomial<NumberType> Polynomial<NumberType>::operator+ (const Polynomial<NumberType> & rhs) const {
	return Polynomial(*this) += rhs;
}
template<typename NumberType>
Polynomial<NumberType> Polynomial<NumberType>::operator-=(const Monomial<NumberType> &m) {
	insert_in_poly(*this, m);
}
template<typename NumberType>
Polynomial<NumberType> Polynomial<NumberType>::operator-=(const Polynomial<NumberType> & rhs) {

}
template<typename NumberType>
/*Done*/const Polynomial<NumberType> Polynomial<NumberType>::operator-(const Monomial<NumberType> &m)const {
	return Polynomial(*this) -= m;
}
template<typename NumberType>
/*Done*/const Polynomial<NumberType> Polynomial<NumberType>::operator- (const Polynomial<NumberType> & rhs) const {
	return Polynomial(*this) -= rhs;
}
template<typename NumberType>
Polynomial<NumberType> Polynomial<NumberType>::operator*=(const Monomial<NumberType> &m) {
	insert_in_poly(*this, m); 
}
template<typename NumberType>
Polynomial<NumberType> Polynomial<NumberType>::operator*=(const Polynomial<NumberType> & rhs) {

}
template<typename NumberType>
/*Done*/const Polynomial<NumberType> Polynomial<NumberType>::operator*(const Monomial<NumberType> &m) const {
	return (*this) *= m;
}
template<typename NumberType>
/*Done*/const Polynomial<NumberType> Polynomial<NumberType>::operator*(const Polynomial<NumberType> &rhs)const {
	return (*this) *= rhs;
}
//binary math function things end//

//evaluate things
template<typename NumberType>
const NumberType Polynomial<NumberType>::evaluate(NumberType x) const {

}

//bool operators
template<typename NumberType>
/*Done*/ bool Polynomial<NumberType>::operator==(const Polynomial<NumberType> &p) const {
	return (number_of_terms == p.number_of_terms && highest_degree == p.highest_degree);
}
template<typename NumberType>
/*Done*/ bool Polynomial<NumberType>::operator!=(const Polynomial<NumberType> &p) const {
	return (number_of_terms != p.number_of_terms || highest_degree != p.highest_degree);
}


//Read and Print Functions
template<typename NumberType>
void Polynomial<NumberType>::read(istream & in = cin) {
	Monomial<NumberType> newMonom;
	int coeff;
	int degree;
	while (true) {
		in >> coeff;
		in >> degree;
		if (coeff == 0) {
			break;
		}
		else if (degree < 0) {
			cout << "No negatives, no bueno.";
			break;
		}
		else {
			newMonom.assign_coefficient(coeff);
			newMonom.assign_degree(degree);
			insert_in_poly(*this, newMonom);
		}
	}
	return;
}
template<typename NumberType>
void Polynomial<NumberType>::print(ostream & out = cout) const {
	Monomial<NumberType> mono;
	list<Monomial<NumberType>>::const_iterator listItr = term_list.begin();
	
	while (listItr != term_list.end()) {
		if ((*listItr).coefficient() == 0) {
			break;
		}
		else if ((*listItr).degree() == 0 && (*listItr).coefficient() > 0) {
			out << " + " << (*listItr).coefficient();
			if (listItr == term_list.end()) {
				break;
			}
		}
		else if ((*listItr).degree() == 0 && (*listItr).coefficient() < 0) {
			out << " - " << (*listItr).coefficient();
			if (listItr == term_list.end()) {
				break;
			}
		}
		else if ((*listItr).degree() == 1 && (*listItr).coefficient() > 0) {
			out << " + " << (*listItr).coefficient() << 'x';
		}
		else if ((*listItr).degree() == 1 && (*listItr).coefficient() < 0) {
			out << " - " << (*listItr).coefficient() << 'x';
		}
		else if ((*listItr).coefficient() > 0 && (*listItr).degree() != 0){
			out << " + " << (*listItr).coefficient() << "x^" << (*listItr).degree();
		}
		else if ((*listItr).coefficient() < 0 && (*listItr).degree() != 0) {
			out << " - " << (*listItr).coefficient() << "x^" << (*listItr).degree();
		}
		else if (gethighestdegree() && (*listItr).coefficient() > 0) {
			out << (*listItr).coefficient() << "x^" << (*listItr).degree();
		}
		else if (gethighestdegree() && (*listItr).coefficient() < 0) {
			out << "- " << (*listItr).coefficient() << "x^" << (*listItr).degree();
		}
	}
	// if degree == 1 print x
	//if degree == 0 print coeff
	//else print coeff x^ degree
	return;
}


//Insert Monomial into Polynomial
template<typename NumberType>
/*Done*/ void Polynomial<NumberType>::insert_in_poly(Polynomial<NumberType> & p, const Monomial<NumberType> & m) {
	int m_degree = m.degree();
	if (p == Polynomial<NumberType>::ZERO) {
		p.term_list.pop_front(); //get rid of (0, 0) term
		p.term_list.push_front(m);
		p.highest_degree = m.degree();
		p.number_of_terms = 1;
	}
	else {
		list<Monomial<NumberType>>::iterator itr = p.term_list.begin();
		while (itr != p.term_list.end()) {
			Monomial<NumberType> current_m = *itr;
			if (current_m == m_degree) {
				if ((current_m.coefficient() + m.coefficient()) == 0) {
					itr = p.term_list.erase(itr);
					p.number_of_terms--;
					if (p.number_of_terms == 0) {
						p.highest_degree = 0;
						p.term_list.push_back(Monomial<NumberType>(0, 0));
					}
					else {
						if (p.highest_degree == m_degree) {
							p.highest_degree = (*itr).degree();
						}
					}
				}
				else {
					(*itr).assign_coefficient(current_m.coefficient() + m.coefficient());
				}
				return;
			}
		}

	}
}


//Power Function
template<typename NumberType>
/*Done*/ NumberType Polynomial<NumberType>::power(NumberType x, int n) const {
	NumberType product;
	for (int i = 0; i < n; i++) {
		product *= x;
	}
	return product;
}

//istream and ostream operators
template<typename NumberType> 
/*Done*/ istream& operator>>(istream & in, Polynomial<NumberType> & rhs) {
	rhs.read(in);
	return in;
}
template<typename NumberType>
/*Done*/ ostream& operator<<(ostream & out, const Polynomial<NumberType> & rhs) {
	rhs.print(out);
	return out;
}

#endif 

I am having a problem with my print and read functions (mostly the print function), because trying to print everything will go into an infinite loop and putting breaks only prints up to 2 monomials. Can someone explain what is wrong with them? My insert_in_poly works because my professor gave it to us in class.

//Main Driver Code
#include "polynomial.cpp"
#include <iostream>

using namespace std;

int main() {
	Polynomial<int> a(9, 3);
	Polynomial<int> c;
	cin >> c;
	cout << a << endl;
	cout << c << endl;
	return 0;
}