Polynomial

# pragma once
#include <iostream>
#include <map>

using namespace std;

class Poly{
  public:
    Poly(); //konstruktor
    Poly(double); // konstruktor z zadeklarowanym pierwszym elementem
    map <int, double> coefMap; // mapa
    void eraseZeros(); // usuwamy wartosci zero
    double &operator[] (unsigned int); // zwraca element na miejscu w nawiasach
    Poly operator- () const; //neguje wartosci
    double operator() (double) const; //liczy wartosc poly dla podanej liczby
    ~Poly();

};

ostream & operator<< (ostream&, const Poly&); // printuje
Poly operator+ (const Poly&, const Poly&);
Poly operator- (const Poly&, const Poly&);
Poly operator* (const Poly&, const Poly&);

#include "Poly.h"
#include <math.h>


Poly::Poly() {}

Poly::Poly(double value)
{
    coefMap.insert(pair<int, double>(0, value));
}

Poly::~Poly()
{
    this->coefMap.clear();
}


double &Poly:: operator[] (unsigned int key)
{
  return coefMap[key];
}

ostream & operator << (ostream& out, const Poly& polynomial)
{
    bool firstElement = true;
    map<int, double>::const_reverse_iterator iterator = polynomial.coefMap.rbegin();
    for(; iterator != polynomial.coefMap.rend(); iterator++)
    {
        if(iterator->second == 0)
        {
            continue;
        }
        if(iterator->second > 0)
        {
            if(!firstElement) out << " + ";
        }
        else
        {
            out << " - ";
        }
        firstElement = false;
        if(abs(iterator->second) != 1)
        {
            out << abs(iterator->second);
        }
        if(iterator->first == 0) continue;
        {
        out << "x";
        }
        if(iterator->first != 1)
        {
            out << "^" << iterator->first;

        }
    }
    return out;
}

Poly operator+ (const Poly& p1, const Poly& p2)
{
  Poly result;
  for(map<int,double>::const_iterator  iterator = p1.coefMap.begin(); iterator != p1.coefMap.end(); iterator++)
  {
    result.coefMap[iterator->first] = iterator->second;
  }
  for(map<int,double>::const_iterator  iterator = p2.coefMap.begin(); iterator != p2.coefMap.end(); iterator++)
  {
    result.coefMap[iterator->first] += iterator->second;
  }
  result.eraseZeros();
  return result;
}


Poly operator- (const Poly& p1, const Poly& p2)
{
  Poly result;
  for(map<int,double>::const_iterator  iterator = p1.coefMap.begin(); iterator != p1.coefMap.end(); iterator++)
  {
    result.coefMap[iterator->first] = iterator->second;
  }
  for(map<int,double>::const_iterator  iterator = p2.coefMap.begin(); iterator != p2.coefMap.end(); iterator++)
  {
    result.coefMap[iterator->first] -= iterator->second;
  }
  result.eraseZeros();
  if(result.coefMap.empty())
  {
    result.coefMap[0] = 0;
  }
  return result;
}

Poly operator* (const Poly& p1, const Poly& p2)
{
  Poly result;
  for(map<int,double>::const_iterator  iterator1 = p1.coefMap.begin(); iterator1 != p1.coefMap.end(); iterator1++)
  {
    for(map<int,double>::const_iterator  iterator2 = p2.coefMap.begin(); iterator2 != p2.coefMap.end(); iterator2++)
    {
      result.coefMap[iterator1->first + iterator2->first] += iterator1->second * iterator2->second;
    }
  }
  result.eraseZeros();
  return result;
}

Poly Poly::operator- () const
{
    Poly result;
    map<int,double>::const_iterator  iterator = coefMap.begin();
    while(iterator != coefMap.end())
    {
        result.coefMap[iterator->first] = -(iterator->second);
        iterator++;
    }
    return result;
}

double Poly::operator() (double argument) const
{
  double result = 0;
  for(map<int,double>::const_iterator  iterator = coefMap.begin(); iterator != coefMap.end(); iterator++)
  {
    result += pow(argument, iterator->first)*iterator->second;
  }
  return result;
}

void Poly::eraseZeros() {
    map<int, double >::iterator iterator = coefMap.begin();
    while(iterator != coefMap.end())
    {
        if(iterator->second == 0){
            iterator = coefMap.erase(iterator);
        }
        else {
            iterator++;
        }
    }
}