多项式类

这是我写的一个多项式的类，因为是作业，所以只实现了输入、输出和两个多项式相加而已。

polynomial.h:

#ifndef POLYNOMIAL_H
#define POLYNOMIAL_H

#include <iostream>
#include <map>
#include <functional>

class Polynomial
{
private:
     // using map container to store the terms, all terms are in descending order of exponentials
    typedef std::map<int, int, std::greater<int> > TermsMap;

    TermsMap terms;

    bool printTerm(std::ostream &out, int coefficient, int exponential, bool firstTerm) const;
public:
    typedef TermsMap::iterator Iterator; // the iterator of terms
    typedef TermsMap::const_iterator ConstIterator; // the const iterator of terms

    // here are some interfaces, but some of them not be used in this project
    // they are only for integrality of the class
    Iterator begin(void) { return terms.begin(); }
    Iterator end(void) { return terms.end(); }
    ConstIterator begin(void) const { return terms.begin(); }
    ConstIterator end(void) const { return terms.end(); }
    int getCoefficient(int exponential) { return terms[exponential]; }
    void clear(void) { terms.clear(); }

    Polynomial &operator+=(const Polynomial &p);

    friend std::istream &operator>>(std::istream &in, Polynomial &p);
    friend std::ostream &operator<<(std::ostream &out, const Polynomial &p);
};

Polynomial operator+(const Polynomial &leftPolynomial, const Polynomial &rightPolynomial);

std::istream &operator>>(std::istream &in, Polynomial &p);
std::ostream &operator<<(std::ostream &out, const Polynomial &p);

#endif

 polynomial.cpp:

#include <iostream>
#include "polynomial.h"
using namespace std;

// print a term in the correct form, return printed or not
bool Polynomial::printTerm(ostream &out, int coefficient, int exponential, bool firstTerm) const
{
    if (coefficient == 0) // do not print terms with coefficient zero
        return false;

    // print the coefficient
    if (coefficient > 0 && !firstTerm)
        out << "+";
    else if (coefficient < 0)
        out << "-";
    coefficient = abs(coefficient);
    if (coefficient != 1 || exponential == 0)
        out << coefficient;

    if (exponential > 0)
        out << 'X';
    if (exponential > 1)
        out << '^' << exponential;

    return true;
}

// the '+='operation of polynomial, more operations can be added
Polynomial &Polynomial::operator+=(const Polynomial &p)
{
    for (ConstIterator it = p.begin(); it != p.end(); ++it)
        terms[it->first] += it->second;

    return *this;
}

// the plus operation of polynomial, more operations can be added
Polynomial operator+(const Polynomial &leftPolynomial, const Polynomial &rightPolynomial)
{
    Polynomial result(leftPolynomial);
    result += rightPolynomial;
    return result;
}

// input a polynomial
istream &operator>>(istream &in, Polynomial &p)
{
    char separator;

    p.clear();
    do {
        int coefficient, exponential;
        in >> coefficient >> exponential;
        p.terms[exponential] = coefficient;
        in >> noskipws >> separator >> skipws; // not skip white spaces, in order to read a space or a newline
    } while (separator != ' '); // input until a newline

    return in;
}

// print a polynomial
ostream &operator<<(ostream &out, const Polynomial &p)
{
    bool printed = false; // whether there is a term printed or not
    for (Polynomial::ConstIterator it = p.begin(); it != p.end(); ++it)
        printed = p.printTerm(out, it->second, it->first, !printed) || printed;
    if (!printed) // no terms printed, print a zero to mark an empty polynomial
        out << "0";
    out << endl;

    return out;
}