Polynom& Polynom::operator+ (const Polynom& poly)
{
    ...
    Polynom& p = new Polynom(...);
    ...
    return p;
}

Polynom Polynom::operator+ (const Polynom& right)
{
    Polynom res(...);
    res.plus( *this , right)
    ...
    return res;
}

#include <iostream>

class Polynom
{
private:
	int power;
	double *koefs;
	void copy(const Polynom& right);

public:
	Polynom(int power, const double* koefs);
	Polynom(const Polynom& right);
             Polynom& operator=(const Polynom& right);

	virtual ~Polynom();
	
	double getValue(double argument);
	
	Polynom add(const Polynom& right);
	Polynom sub(const Polynom& right);
	Polynom multiply(const Polynom& right);
	
	Polynom operator+ (const Polynom& right);
	Polynom operator- (const Polynom& right);
	Polynom operator- ();
	Polynom operator* (const Polynom& right);
	friend ostream& operator<< (ostream& os, const Polynom& right);

};

ostream& operator<< (ostream& os, const Polynom& right);

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

Polynom::Polynom(int power, const double* koefs)
: power( 0 ), koefs(NULL)
{
	this->power = power;
	this->koefs = new double[power +  1 ];
	for (int i =  0 ; i <= power; ++i)
	{
	   this->koefs[i] = koefs[i];
	};
}

void Polynom::copy(const Polynom& right)
{
             if( koefs && power != right.power) 
               { delete[] koefs; koefs = NULL; }
	power = right.power;
             if( !koefs ) 
	  koefs = new double[power +  1 ];

             // вообще -то можно и memcpy использовать,
             // которая часто вообще в одну ассемблерную комманду компилируется.
	for (int i =  0 ; i <= power; ++i)
	{
	   koefs[i] = right.koefs[i];
	};
}

Polynom::Polynom(const Polynom& right)
{
   if( this != &right)
     copy(right);
}

Polynom& Polynom::operator=(const Polynom& right)
{
   if( this != &right)
     copy(right);
}

Polynom::~Polynom()
{
  if( koefs )
  { delete[] koefs; koefs = NULL; }
}

double Polynom::getValue(double argument)  const
{
	double result =  0 ;
	for(int i =  0 ; i <= power; ++i)
	{
		result += koefs[i -  1 ] * pow(i, argument);
	};
	return result;
}

Polynom Polynom::add(cons Polynom& poly)  const
{
	Polynom* bigger = (power > poly.power) ? this : &poly;
	Polynom* smaller = (power < poly.power) ? this : &poly;
	Polynom newPoly(bigger->power, bigger->koefs);
	
	for (int i =  0 ; i <= smaller->power; ++i)
	{
		newPoly.koefs[i] += smaller->koefs[i];
	};
	
	return newPoly;
}

Polynom Polynom::sub(cons Polynom& poly)  const
{
	Polynom p = - poly;
	return add(p);
}

Polynom Polynom::multiply(cons Polynom& poly)  const
{
	int p = power + poly.power;
	double* kfs = new double[p +  1 ];
	for (int c =  0 ; c <= p; ++c)
	{
		kfs[c] =  0 ;
	};
	
	for (int i =  0 ; i <= power; ++i)
	{
		for (int j =  0 ; j <= poly.power; ++j)
		{
			kfs[i + j] += koefs[i] * poly.koefs[j];
		};
	};
	
	Polynom newPoly(p, kfs);
	delete[] kfs; // эта переменная не должна динамически выделяться.
            // можно использовать newPoly.koefs, если объявить его раньше.
	return newPoly;
}

Polynom Polynom::operator+(cons Polynom& poly)  const
{
	return add(poly);
}

Polynom Polynom::operator-(cons Polynom& poly)  const
{
	return sub(poly);
}

Polynom Polynom::operator-() const
{
	Polynom p(power, koefs);
	for (int i =  0 ; i <= p.power; ++i)
	{
		p.koefs[i] = (- 1 ) * p.koefs[i];
	};
	return p;
}

Polynom Polynom::operator*(Polynom poly)
{
	return multiply(poly);
}

ostream& operator<<(ostream& os, Polynom poly)
{
	for (int i = poly.power; i >= 0 ; --i)
	{
		os << poly.koefs[i] << " ";
	};
	return os;
}

#include <iostream>

class Polynom
{
};