Работа с файлом классов

//head.cpp
#include <iostream>
#include <conio.h>
#include "head.h"

using namespace std;
Multinominal::Multinominal(usi _n, double* _dMN)
{
    this->n = _n+1; //перебелываем степень многочлена в кол-во элементов в нем
    this->dMN = new double [n]; //динамически создаем массив
    if (!_dMN)//если указатель на массив не указывает на массив:)
        //то соответственно заполнить его нулями, чтобы не было лишних неудобств
        for (int i = 0; i<n; i++)
            dMN = 0;
    else
        //иначе заполнить его значениями переданного массива
        //причем заполняем задом наперед, для удобства работы с многочленами
        for (int i = n-1; i>=0; i--)
            dMN = _dMN;
}
Multinominal::~Multinominal()
{  
    delete [] this->dMN; //удалеям из памяти наш созданный массив
}

void Multinominal:: SetMN (void)
    {
        cout<<"Vvedite znachenija mnogochlena: ";
        //вводим значения многочлена задом наперед для удобства
        for (int i = n-1; i>=0; i--)
            cin>>this->dMN;
    }
void Multinominal:: GetMN (void)
    {
        //выводим наш многочлен, соответственно тоже задом наперед,
        //так как вводили тоже задом наперед
        for (int i = n-1; i>=1; i--)
        {
            cout.flags(ios::showpos);
            cout<<dMN<<"*x"<<"^";
            cout.unsetf(cout.flags());
            cout<<i;
        }
        cout.flags(ios::showpos);
        cout<<dMN[0];
        cout.unsetf(cout.flags());
    }
Multinominal& Multinominal::operator =(const Multinominal &MN)
{
    if (&MN == this) //проверка на самокопирование
        return *this;
    delete [] dMN; //уничтожить ранее существовавший массив
    this->n = MN.n; //задаем новому массиву новую размерность
    this->dMN = new double [this->n]; //динамически создаем новый массив
    //заполняем массив значениями копируемого объекта
    for (int i = n-1; i>=0; i--)
        this->dMN = MN.dMN;
    return *this; //возвращаем указатель на данный объект
}
Multinominal Multinominal::operator +(Multinominal& MN)
{  
    usi s,n1; //s - кол-во елементов в меньшем многочлене
              //n1 - кол-во элементов в большем массиве
    double * dmn; //массив элементов
    if (this->n < MN.n) //если кол-во элементов текущего класса больше передаваемого, то
    {
        n1 = MN.n; //n1- кол-во элементов передаваемого объекта
        s = this->n-1; //s - кол-во элементов текущего многочлена - 1
    }
    else //иначе наоборот
    {
        n1 = this->n;
        s = MN.n-1;
    }
    dmn = new double [n1]; //создаем массив временных элементов
    //складываем элементы первого мнгогочлена с элементами второго
    for (int i = 0; i<n1; i++)
    {
        if (i>s)
        {
            dmn = this->n > MN.n ? this->dMN : MN.dMN;
        }
        else
        {
            dmn = this->dMN + MN.dMN;
        }
    }
    return Multinominal(n1-1,dmn);//возвращаем новый объект
}
//все тоже самое, только вместо операции '+' используется операция '-'
Multinominal Multinominal::operator -(Multinominal & MN)
{
    usi s,n1;
    double * dmn;
    if (this->n <= MN.n)
    {
        n1 = MN.n;
        s = this->n-1;
    }
    else
    {
        n1 = this->n;
        s = MN.n-1;
    }
    dmn = new double [n1];
    for (int i = 0; i<n1; i++)
    {
        if (i>s)
        {
            dmn = this->n > MN.n ? this->dMN : MN.dMN;
        }
        else
        {
            dmn = this->dMN - MN.dMN;
        }
    }
    return Multinominal(n1-1,dmn);
}
//все тоже самое, только вместо операций '+' или '-' используется операция '*'
Multinominal Multinominal::operator *(Multinominal & MN)
{
    usi s,n1;
    double * dmn;
    if (this->n < MN.n)
    {
        n1 = MN.n;
        s = this->n-1;
    }
    else
    {
        n1 = this->n;
        s = MN.n-1;
    }
    dmn = new double [n1];
    for (int i = 0; i<n; i++)
    {
        if (i>s)
        {
            dmn = this->n > MN.n ? this->dMN : MN.dMN;
        }
        else
        {
            dmn = this->dMN * MN.dMN;
        }
    }
    return Multinominal(n1-1,dmn);
}
double Multinominal::value (double _x)
{
        double value = 0, x;
        //вычисляем значение мнггочлена от аргуменита х
        for( int i = n-1; i>=1; i-- )
        {
            x = _x;
            //для этого вычисляем степенные значения аргумента х
            for ( int j = i; j>1; j--)
                x *= x;
            value+=(this->dMN)*x;//умножаем его на коэффицент многочлена и прибавляем к основной сумме
        }
        return value+=this->dMN[0]; //прибавляем к основной сумме последний элемент и возвращаем значение
    }

//main.cpp
#include <iostream>
using namespace std;
#include <conio.h>
#include "head.h"

int main()
{
   
    usi n = 0;  //степерь многочлена
    int menu;  
    do
    {
    cout<<"Vvedite stepen' pervogo mnogochlena (y1): ";
    cin>>n;
    }while(n<1);
    Multinominal MN1 = Multinominal(n); //объявляем объект
    do
    {
        cout<<"Vvedite stepen' vtorogo mnogochlena (y2): ";
        cin>>n;
    }while(n<1);
    Multinominal MN2 = Multinominal(n); //объявляем объект
    Multinominal MN3 = Multinominal();  //объявляем обект с параметрами по умолчинию
    MN1.SetMN(); //задаем параметры первого многочлена
    MN2.SetMN(); //задаем параметры второго многочлена
    do
    {
        system("cls");
        cout<<"1. Summa mnogochlenov"<<endl;
        cout<<"2. Raznost' mnogoclenov"<<endl;
        cout<<"3. Proizvedenie mnogochlenov"<<endl;
        cout<<"4. Vicheslenie znachenija"<<endl;
        cout<<"0. Exit"<<endl;
        cout<<"Vvedite punkt menu: ";
        cin>>menu;
        switch (menu)
        {
        case 1:
            /**********************сложение многочленов*********************/
            system("cls");
            cout<<"mn1: "; MN1.GetMN(); //выводим первый многочлен
            cout<<endl<<"    +"<<endl;
            cout<<"mn2: "; MN2.GetMN(); //выводим второй многочлен
            MN3 = MN1+MN2; //складываем первый многочлен со всторым (работает перегруженная операция присваивания),
            //а также перегруженная операция сложения
            cout<<endl<<"    ="<<endl;
            cout<<"mn3: "; MN3.GetMN();//выводим третий многочлен
            getch();
            break;
        case 2:
            /********************разность многочленов*********************/
            system("cls");
            cout<<"mn1: "; MN1.GetMN();
            cout<<endl<<"    -"<<endl;
            cout<<"mn2: "; MN2.GetMN();
            MN3 = MN1 - MN2; //вычитаем из первого многочлена второй (работает перегруженная операция присваивания),
            //а также перегруженная операция вычитания
            cout<<endl<<"    ="<<endl;
            cout<<"mn3: "; MN3.GetMN();
            getch();
            break;
        case 3:
            /*********************произведение многочленов*********************/
            system("cls");
            cout<<"mn1: "; MN1.GetMN();
            cout<<endl<<"    *"<<endl;
            cout<<"mn2: "; MN2.GetMN();
            MN3 = MN2 * MN1;//умножаем первый многочлен на второй (работает перегруженная операция присваивания),
            //а также перегруженная операция умножения
            cout<<endl<<"    ="<<endl;
            cout<<"mn3: "; MN3.GetMN();
            getch();
            break;
        case 4:
            double x,value1, value2;
            system("cls");
            cout<<"Vvedite argument: ";
            cin>>x;
            value1 = MN1.value(x); //вычисление значения первого многочлена при х
            value2 = MN2.value(x); //вычисление значения второго многочлена при х
            cout<<"MN1: "<<value1<<endl;
            cout<<"MN2: "<<value2<<endl;
            getch();
            break;
        case 0: return 0;
        }
    }while(menu!=0);
}