Не понимаю в чём ошибка

[levandowskiy]

Доброго времени суток, уважаемые посетители форума)

Пишу класс Polynom - целью, которого является представление многочленов и операции над ними. У меня не работают перегруженные операторы сложения, вычитания и умножения. Так как все они пишутся подобным образом прошу обьяснить в чём моя ошибка и представить правильный код для одного из операторов (с остальными хочу разобраться сам по аналогии).
Прилагаю к теме pdf-файл с реализацией класса.
Заранее вам благодарен за помощь)

[MaTBeu]

Pdf-файл? А почему не закриптованый/обфусцированный файл с исходным кодом, в архиве под паролем?

Читаем правила вверху раздела. Для кода ТОЛЬКО тэг CODE. Аттачи удалил.

[levandowskiy]

Уважаемый , MaTBeu, что такое закриптованый/обфусцированный файл я к сожалению не понимаю и прошу простить меня за невнимательность относительно правил)
добавляю код в нужных тэгах

Файл заголовочный

#ifndef POLY_H
#define POLY_H
#include "stdafx.h"
#include <cstddef>
#include <iostream>
using namespace std;


struct Node
{
	int coef;
	int power;
	Node *link;
};

typedef Node* nodeptr;

class Polynom
{
public:

	Polynom();
	/*Конструктор по умолчанию: устанавливает 
	last = NULL и head = NULL;*/

	Polynom(const Polynom& p);
	//Конструктор копирования

	Polynom (int C);
	/*Конструктор: устанавливает свободному члену
	многочлена значение С*/

	Polynom (int coefficient, int p);
	/*Конструктор: создаёт одночлен вида
	coefficient*x^p*/

	~Polynom();
	/*Деструктор*/

	friend Polynom operator +(const Polynom& one, const Polynom& two);
	/*Складывает два полинома*/

	friend Polynom operator -(const Polynom& one, const Polynom& two);
	/*Вычитает из полинома one полином two*/

	friend Polynom operator *(const Polynom& one, const Polynom& two);
	/*Умножает полином one на полином two*/

	friend Polynom operator +(int C, const Polynom& one);
	/*Складывает константу и полином*/

	friend Polynom operator +(const Polynom& one, int C);
	/*Складывает полином и константу*/

	friend Polynom operator -(int C, const Polynom& one);
	/*Вычитает из константы полином*/

	friend Polynom operator -(const Polynom& one, int C);
	/*Вычитает из полинома константу*/

	friend Polynom operator *(int C, const Polynom& one);
	/*Умножает константу на полином*/

	friend Polynom operator *(const Polynom& one, int C);
	/*Умножает полином на константу*/

	friend istream& operator >>(istream& fin, Polynom& one);
	/*Осуществляет ввод полинома*/

	friend ostream& operator <<(ostream& fout, const Polynom& one);
	/*Осуществляет вывод полинома*/

	double f(double x) const;
	/*Возвращает значение функции F(x)*/

	bool empty() const;
	/*Если список пуст - возвращает true*/

	void order ();
	/*Возвращает полином без повторения членов с одинаковыми степенями
	и степени расположены в порядке убывания*/

private:
	nodeptr head;
	nodeptr last;
};
#endif

Файл реализации

#include "stdafx.h"
#include "Polynom.h"
#include <cstddef>
#include <cstdlib>
#include <iostream>
#include <cmath>
using namespace std;

void insert (nodeptr& head, nodeptr& last, int c, int p);
void del (nodeptr& head, nodeptr& t);

Polynom::Polynom():head(NULL), last(NULL)
{
}
Polynom::Polynom(const Polynom& p)
{
	if (p.empty())
		head = NULL;
	else
	{
		head = NULL;
		last = NULL;
		for (nodeptr i=p.head; i!=NULL; i=i->link)
			insert(head,last,i->coef,i->power);
	}
}
bool Polynom::empty() const
{
	return (head==NULL);
}
Polynom::Polynom(int C)
{
	nodeptr temp = new Node;
	temp->coef = C;
	temp->power = 0;

	head = temp;
	last = head;
	last->link = NULL;
}
Polynom::Polynom(int coefficient, int p)
{
	nodeptr temp = new Node;
	temp->coef = coefficient;
	temp->power = p;

	head = temp;
	last = head;
	last->link = NULL;
}
Polynom::~Polynom()
{
	nodeptr temp;
	while (!empty())
	{
		temp = head;
		head = head->link;
		delete temp;
	}
}
void Polynom::order()
{
	Polynom temp;
	bool d=false;
	for (nodeptr i=head; i!=NULL; i=i->link)
	{
		for (nodeptr j=i->link; j!=NULL; j=j->link)
		{
			if ((i->power)==(j->power))
			{
				insert (temp.head,temp.last,(i->coef+j->coef),i->power);
				del(head,j);
				d = true;
			}

		}
			if (!d)
				insert (temp.head, temp.last, i->coef, i->power);
			d=false;
	}
	head = temp.head;
	last = temp.last;
}
Polynom operator *(const Polynom& one, const Polynom& two)
{
	Polynom temp;
	for (nodeptr i=one.head; i!=NULL; i=i->link)
	{
		for (nodeptr j=two.head; j!=NULL; j=j->link)
		{
			insert (temp.head, temp.last, ((i->coef)*(j->coef)), (i->power)+(j->power));
		}
	}
	return temp;
}

void insert (nodeptr& head, nodeptr& last, int c, int p)
{
	nodeptr temp = new Node;
	temp->coef = c;
	temp->power = p;

	if (!head)
	{
		head = temp;
		last = head;
	}
	else
	{
		last->link = temp;
		last = temp;
	}
	last->link = NULL;
}
void del (nodeptr& head,nodeptr& t)
{
	nodeptr before;
	for (nodeptr i=head; i!=t; i=i->link)
		before = i;
	before->link = t->link;
	delete t;
}

[levandowskiy]

А вот функции

Polynom operator +(const Polynom& one, const Polynom& two)
{
	Polynom temp;
	for (nodeptr i=one.head; i!=NULL; i=i->link)
	{
		for (nodeptr j=two.head; j!=NULL; j=j->link)
		{
			if ((i->power)==(j->power))
			{
				insert (temp.head,temp.last,(i->coef+j->coef),i->power);
			}
			else if ((i->power)>(j->power))
			{
				insert (temp.head,temp.last,i->coef,i->power);
				insert (temp.head,temp.last,j->coef,j->power);
			}
			else
			{
				insert (temp.head,temp.last,j->coef,j->power);
				insert (temp.head,temp.last,i->coef,i->power);
			}
		}
	}
	return temp;
}
Polynom operator -(const Polynom& one, const Polynom& two)
{
	Polynom temp;
	for (nodeptr i=one.head; i!=NULL; i=i->link)
	{
		for (nodeptr j=two.head; j!=NULL; j=j->link)
		{
			if ((i->power)==(j->power))
			{
				insert (temp.head,temp.last,(i->coef+j->coef),i->power);
			}
			else if ((i->power)>(j->power))
			{
				insert (temp.head,temp.last,i->coef,i->power);
				insert (temp.head,temp.last,-(j->coef),j->power);
			}
			else
			{
				insert (temp.head,temp.last,-(j->coef),j->power);
				insert (temp.head,temp.last,i->coef,i->power);
			}
		}
	}
	return temp;
}
Polynom operator *(const Polynom& one, const Polynom& two)
{
	Polynom temp;
	for (nodeptr i=one.head; i!=NULL; i=i->link)
	{
		for (nodeptr j=two.head; j!=NULL; j=j->link)
		{
			insert (temp.head, temp.last, ((i->coef)*(j->coef)), (i->power)+(j->power));
		}
	}
	return temp;
}