Перегрузка операций

Требуется перегрузить операции сложения + и присваивания =

Вопрос: почему при завершении метода, результат удаляется?
Как сделать так, чтобы значение нормлаьно возвращалось и не стиралось попути?

#include <iostream>
#include <fstream>
using namespace std;

typedef struct Pol {
int x; // степень Х
int y; // коэффициент перед Х
Pol *next; // ссылка на следующий элемент
} F;

typedef Pol *polyn;

class polynome {
public:
polynome(); // constructor
~polynome(); // destructor
polynome operator = (polynome & X); // оператор присваивания
polynome operator + (polynome & X); // addition of function

public:
polyn Poly;
};

polynome :: polynome() { // создание первого элемента списка
Poly = NULL;
};

polynome :: ~polynome() { // удаление списка
polyn R; // рабочая переменная
while (Poly != NULL ) {
// копируем хвост
R = Poly;
Poly = Poly -> next;
delete R;
};
};

// переворачивание списка
void conv (polynome & X) {
polyn R , Y ;
Y = new F;
Y = NULL;
while (X.Poly != NULL) {
R = new F;
// save 1 element
R -> x = X.Poly -> x;
R -> y = X.Poly -> y;
R -> next = Y;
Y = R;
X.Poly = X.Poly -> next;
};
X.Poly = Y;
};

// копирование элемента
void copyPol (polynome X, polynome & Y, polynome & X1) {
polyn R, K;
R = X.Poly;
X1.Poly = NULL; // копия Х, но в процедуре должна быть отдльной переменной
while (R != NULL) {
X.Poly = X.Poly -> next;

K = new F;
K -> x = R -> x;
K -> y = R -> y;
K -> next = X1.Poly;
X1.Poly = K;

K = new F;
K -> x = R -> x;
K -> y = R -> y;
K -> next = Y.Poly;
Y.Poly = K;

R = X.Poly;
};
conv (X1);
conv (Y);
};

// оператор присваивания
polynome polynome :: operator = (polynome & X1) {
polynome X;
polyn R, K;
copyPol (X1, X, X1); // сохранили Х чтобы не испортить

while (this -> Poly != NULL ) { // чистим this
// копируем хвост
R = this -> Poly;
this -> Poly = this -> Poly -> next;
delete R;
};

conv(X);

// copy in this
while (X.Poly != NULL) {
R = X.Poly;
X.Poly = X.Poly -> next;
R -> next = NULL;
K = new F;
K -> x = R -> x;
K -> y = R -> y;
K -> next = this -> Poly;
this -> Poly = K;
delete R;
};
return *this;
};

// addition of function Poly + X
void AddPol (polyn Z1, polynome X1, polynome & Y) {
polyn R;
polynome Z, Z2, X;
Y.Poly = NULL;
Z2.Poly = new F;
Z2.Poly = Z1;
copyPol(X1,X,X1);
copyPol(Z2,Z,Z2);
Z1 = Z2.Poly;

while ( (Z.Poly != NULL) & (X.Poly != NULL) ) {
if (Z.Poly -> x > X.Poly -> x) { // прикрепляем элемент Poly
R = new F;
R -> x = Z.Poly -> x;
R -> y = Z.Poly -> y;
R -> next = Y.Poly;
Y.Poly = R;
Z.Poly = Z.Poly -> next;
};
if (Z.Poly -> x < X.Poly -> x) { // прикрепляем элемент X
R = new F;
R -> x = X.Poly -> x;
R -> y = X.Poly -> y;
R -> next = Y.Poly;
Y.Poly = R;
X.Poly = X.Poly -> next;
};
if (Z.Poly -> x = X.Poly -> x) { // прикрепление элемента сложения
R = new F;
R -> x = X.Poly -> x;
R -> y = (Z.Poly -> y + X.Poly -> y);
R -> next = Y.Poly;
Y.Poly = R;
X.Poly = X.Poly -> next;
Z.Poly = Z.Poly -> next;
};
if ( (X.Poly == NULL) & (Z.Poly != NULL) ) { // прицепляем оставшиеся элементы Poly
while (Z.Poly != NULL) {
R = new F;
R -> x = Z.Poly -> x;
R -> y = Z.Poly -> y;
R -> next = Y.Poly;
Y.Poly = R;
Z.Poly = Z.Poly -> next;
};
};
if ( (Z.Poly == NULL) & (X.Poly != NULL) ) { // прицепляем оставшиеся элементы X
while (X.Poly != NULL) {
R = new F;
R -> x = X.Poly -> x;
R -> y = X.Poly -> y;
R -> next = Y.Poly;
Y.Poly = R;
X.Poly = X.Poly -> next;
};
};
};
conv(Y);
};

polynome polynome :: operator + (polynome & X) {
polynome Y;
AddPol (this -> Poly, X, Y);
polyn R; // рабочая переменная
return Y;
};

char a1[] = "in.txt"; // файл, содержащий набор многочленов
char a2[] = "out.txt"; // файл, в который выдаем
const int N = 6; // максимальное допустимое колличество многочленов для рассмотрения

int main () {
polynome M, X, Y;
X.Poly = new F;
Y.Poly = new F;

X.Poly -> x = 2;
X.Poly -> y = 1;
X.Poly -> next = NULL;
Y.Poly -> x = 2;
Y.Poly -> y = 2;
Y.Poly -> next = NULL;

M = X + Y;

return 0;
};

Добавлено через 1 минуту
причем если писать:

polynome M = X;

то М возвращается правильное значение

0

Должен быть
Добавлено через 38 секунд
Должен быть
Добавлено через 57 секунд
Это то, что видно. Когда используешь тэги форматирования кода, можно ещё почитать будет.

1