Добавление переменной как данного в Форму

    private: MyList<double>* List;

Form1(void)
    {
        InitializeComponent();
        //
        //TODO: Add the constructor code here
        //
        List = new MyList<double>;
    }

template <class T>
struct node {
   int deg;
   T data;
   node *next;
   node (T d = 0);
 };
template <class T>
class MyList  {
public:
    MyList();
    MyList(T, double );
    MyList(const MyList<T>&);
    ~MyList();
    
    void ins_end(T, int);
    void ins_before (T, T, int);
    void ins_after (T, T, int);
    void clear ();
    void remove(T);
    void remove_as_ptr(node<T>*);
    void sort(bool pol = false);
    void indexation();
    void delete_nulls();
    void set_begin (){curr = first;};
    void set_end (){curr = last};
    void print_list();/////////////////
    node<T>* next (){curr = curr->next; return curr; };
 
    int Get_maxDeg() {
        if(first) {
            if (sort_Flag == NO) sort();
            else if(sort_Flag == INCREASE) return first->deg;
            return first->deg; 
        }
        return -1;
    };
 
    const int get_size() {return size;};
    const T get_cval() {return curr->data;}
 
    node<T>* operator [] (int i) /*const*/; 
    void operator = (MyList<T>& L);
 
 
 
private:
    int size;
    int dim_size;
    node<T>* first;
    node<T>* curr;
    node<T>* last;
    node<T>** dim_of_list;
    is_sort sort_Flag;
 
 
template <class T>
friend MYcomplex find_x(MyList<T>& ,MYcomplex);
 
template <class T>
friend void random_init(MyList<T>&, int = 5);
 
template <class T>
friend void multiply( MyList<T>& List1,  MyList<T>& List2, MyList<T>&);
 
template <class T>
friend  void summing( MyList<T>& List1,  MyList<T>& List2, MyList<T>& Sum_list, a_factor = PLUS);
 
template <class T>
friend void divide( MyList<T> List1, MyList<T> List2, MyList<T>& Quot, MyList<T>& Rest );
 
template <class T>
friend void inter_init(array<T>^, array<T>^,  MyList<T>&, int );
 
};
 
 
 
////////////////////////////////////////////////////////////////////////////////////////////////
 
template <class T>
node<T>::node(T d = 0): next(0), data(d), deg(-1) {};
 
//////////////////////////////////////////////////////////
 
template <class T>
MyList<T>::MyList() 
:curr(0), last(0),first(0),
size(0),dim_size(0),
dim_of_list(0),
sort_Flag(NO)
{};
 
template <class T>
MyList<T>::MyList(T data, double deg ) {
    curr = last = first = 0;
    size = dim_size = 0;
    dim_of_list = 0;
    sort_Flag = NO; 
    ins_end(data, deg);
};
 
template <class T>
MyList<T>::MyList(const MyList<T>& List) {
    first = last = curr = 0;
    size = dim_size = 0;
    dim_of_list = 0;
    sort_Flag = NO;
    node<T>* tmp = List.first;
    for(int i=0; i < List.size; i++) {
        ins_end(tmp->data, tmp->deg);
        tmp = tmp->next;
    }
    size = List.size;
    sort_Flag = NO;;
};
 
 
template <class T>
MyList<T>::~MyList() { clear(); };
 
 
template <class T>
void MyList<T>::sort( bool pol ) {
    if(sort_Flag == NO) {
        curr = first;
        array<int>^ deg = gcnew array<int>(size);
        array<int>^ ncoef = gcnew array<int>(size);
        T* coef = new T[size];
 
        for(int i=0; i<size; i++) {
            deg[i] = curr->deg;
            ncoef[i] = i;
            coef[i] = curr->data;
            next();
        }
        curr = first;
        System::Array::Sort(deg, ncoef);    
        for(int i=size-1; i>=0; i--) {
            curr->data = coef[abs(pol * (size - 1) - ncoef[i])];
            curr->deg = deg[abs(pol * (size - 1) - i)];
            next();
        }
        curr = first;
        if(!pol) sort_Flag = DECREASE;
        else sort_Flag = INCREASE;
        delete [] coef;
    }
 
};
 
template <class T>
void MyList<T>:: operator = (MyList<T>& L) {
    clear();
    first = last = curr = 0;
    size = dim_size = 0;
    dim_of_list = 0;
    sort_Flag = NO;
    L.set_begin();
    while(L.curr){
        ins_end(L.curr->data, L.curr->deg);
        L.next();
    }
    indexation();
    
};
 
template <class T>
void MyList<T>::ins_end (T data, int deg) {
   node<T> *n_ptr = new node<T> (data);
   n_ptr->deg = deg;
   if (!first) 
       first = last = curr = n_ptr;
   else {
       last->next = n_ptr;
       last = n_ptr;
   }
   size++;
   sort_Flag = NO;
 };
 
template <class T>
void MyList<T>::ins_before(T finding_d, T data, int deg) {
 
    node<T>* n_elem = new node<T>(data);
    n_elem->deg = deg;
 
    node<T>* temp_ptr = first;
    node<T>* find_ptr = 0;
    if (!first) {
        last = first = n_elem;
        return;
    }
 
    while( temp_ptr && temp_ptr->data != finding_d ){
        find_ptr = temp_ptr;
        temp_ptr = temp_ptr->next;
    }
    if(temp_ptr == first) {
        n_elem->next = first;
        first = n_elem;
    }
    else {
        find_ptr->next = n_elem;
        n_elem->next = temp_ptr;
    }
    if(!temp_ptr) ins_end(data, deg);
    size++;
    sort_Flag = NO;
    temp_ptr = find_ptr = 0;
};
    
template <class T>
void MyList<T>::ins_after(T finding_d, T data, int deg) {
    node<T>* n_elem = new node<T>(data);
    n_elem->deg = deg;
    node<T>* find_ptr = first;
    
    if ( !first ) 
        first = last = n_elem;
    else {
        while(find_ptr->next && find_ptr->data != finding_d )
            find_ptr = find_ptr->next;
        if( !find_ptr ) ins_end(data, deg);
        else {
            n_elem->next = find_ptr->next;
            find_ptr->next = n_elem;
        }
    }
    size++;
    sort_Flag = NO;
    find_ptr = 0;
};
 
 
 
 
 
template <class T>
void MyList<T>::remove(T data) {
    set_begin();
    node<T>* tmp = curr;
    
    while(curr)  {
        if( curr->data == data ) break;
        tmp = curr;
        next();
    }
 
    if(curr) {
        if(size - 1) {
            sort_Flag = NO;
            if( curr != first && curr != last){
                tmp->next = curr->next;
                delete curr;
            }
 
            if(curr == first) {
                first = curr->next;
                delete curr;
            }
            if(curr == last) {
                last = tmp;
                last->next = 0;
                delete curr;
            }
            size--;
        }
        else first->deg = -1;
    }
    
    curr = first;
};
 
template <class T>
void MyList<T>::remove_as_ptr(node<T> * delptr) {
    set_begin();
    node<T>* tmp = curr;
    
    while(curr)  {
        if( curr == delptr ) break;
        tmp = curr;
        next();
    }
 
    if(curr) {
        if(size - 1) {
            sort_Flag = NO;
            if( curr != first && curr != last){
                tmp->next = curr->next;
                delete curr;
            }
 
            if(curr == first) {
                first = curr->next;
                delete curr;
            }
            if(curr == last) {
                last = tmp;
                last->next = 0;
                delete curr;
            }
            size--;
        }
        else first->deg = -1;
    }
    
    curr = first;
};
 
 
 
template <class T> 
void MyList<T>::delete_nulls() {
    sort();
    int rsize = size;
    for(int i=0; i<rsize; i++) {
        remove(0);
        if (sort_Flag != NO) break;
    }
}
 
 
 
template <class T>
void MyList<T>::clear() {
    node<T>* temp_ptr;
    curr = first;
 
    while(curr) {
        temp_ptr = curr;
        next();
        delete temp_ptr;
    }
    first = curr = last = 0;
    size = 0;
    if(dim_size) delete [] dim_of_list;
    sort_Flag = NO;
    dim_size = 0;
    dim_of_list = 0;
 
};
 
 
template <class T>
void MyList<T>::indexation() {
    if(dim_size) delete [] dim_of_list;
 
    dim_of_list = new node<T>* [size];
    node<T>* tmp = first;
    for(int i=0;(tmp);i++) {
        dim_of_list[i] = tmp;
        tmp = tmp->next;
    }
    dim_size = size;
};
 
 
template <class T>
node<T>* MyList<T>::operator [](int index)  {
    indexation();
    if(index <= dim_size - 1 && index >= 0)
        return dim_of_list[index];
 
    exit(-1); // при выходе за границу массива
};
 
template <class T>
void MyList<T>::print_list() {
    cout<<endl;
    curr = first;
    int i = 0;
    while(curr) {
        cout<<curr->data<<" "<<curr->deg<<" \\ ";
        next();
        i++;
        if ( i%9 == 0) cout<<endl;
    }
    cout<<endl<<endl;
};
 
 
////// friend - функции //////
 
template <class T>
void inter_init(array<T>^ X, array<T>^ Fx, MyList<T>& List ) {
    int msize = X->GetLength(0);
    if ( msize > 1 ) { 
        T pol;
        array<T>^ coef = gcnew array<T>(msize);
        for(int l=0; l<msize; l++) coef[l] = 0; 
        MyList<T> polL1, polL2, srezL;
    
 
        for(int i=0; i<msize; i++) {
 
            pol = 1;
            polL1.clear();
            polL1.ins_end(1,1);
 
            if (i == 0) polL1.ins_end(-X[1], 0);
            else polL1.ins_end(-X[0], 0);
            
            for(int j=0; j<msize; j++) {
                polL2.clear();
                if( j != i ){
                    pol *= (X[i] - X[j]);
                    if (msize == 2) {
                        polL1.first->data = polL1.first->data / pol * Fx[i];    
                        polL1.last->data = polL1.last->data / pol * Fx[i];  
                    }
 
                    if( (i == 0 && j == 1) || j == 0 ) continue;
                    polL2.ins_end(1,1);
                    polL2.ins_end(-X[j], 0);
                    
                    if( (j == msize - 1) || (i == msize - 1 && j == msize - 2) ){
                        polL2.first->data = polL2.first->data / pol * Fx[i];    
                        polL2.last->data = polL2.last->data / pol * Fx[i];  
                    }
 
                    multiply(polL1, polL2, srezL);
                    polL1 = srezL;
                    polL2.clear();
                    srezL.clear();  
                }
            }
            for(int l = msize - 1; l>=0; l--) {
                if( !polL1.curr ) break;
                if( l == polL1.curr->deg) {
                    coef[l] += polL1.curr->data;
                    polL1.next();
                }
            }
        }
        for(int k=0; k<msize; k++) 
            List.ins_end(Round(coef[k], 2), k);
 
    }
    
    else {
        if( X[0] == 0 )
            List.ins_end(Round(Fx[0], 2), 0);
        else 
            List.ins_end(Round(Fx[0] / X[0], 2), 1);
    }
    List.delete_nulls();
}
 
 
 
 
template <class T>
void divide( MyList<T> List1,  MyList<T> List2, MyList<T>& Quot, MyList<T>& Rest ){
    List1.sort();
    List2.sort();
 
    int Q_size = List1.Get_maxDeg() - List2.Get_maxDeg() + 1;
 
    if(Q_size <= 0) Rest = List1;
 
    MyList<T> L1copy, L2copy; // понять, почему сюда постоянно заходит
    int deg;
    T coef;
    
    while( List1.Get_maxDeg() >= List2.Get_maxDeg() ) {
        L2copy = List2;
        List1.set_begin();
        List2.set_begin();
        
        deg = List1.Get_maxDeg() - List2.Get_maxDeg();
        coef = List1.get_cval() / List2.get_cval();
 
        Quot.ins_end(coef, deg);
 
        L2copy.set_begin();
        while(L2copy.curr) {
            L2copy.curr->deg += deg;
            L2copy.curr->data *= coef;
            L2copy.next();
        }
        summing(List1, L2copy, L1copy, MINUS);  
        List1 = L1copy;
        L1copy.clear();
    }
    Rest = List1;   
}
 
 
 
template <class T>
void multiply( MyList<T>& List1,  MyList<T>& List2, MyList<T>& mList){
    List1.sort();
    List2.sort();
    
    int mulSize = List1.Get_maxDeg() + List2.Get_maxDeg() + 2;
    double  two = 2;
    int p = 0;
    for(; mulSize > pow(two, p); p++) ;
    mulSize = pow(two, p);
    
    MYcomplex* Fc1 = new MYcomplex[mulSize];
 
    MYcomplex* Fc2 = new MYcomplex[mulSize];
    
    MYcomplex* mulFa = new MYcomplex[mulSize];
 
    MYcomplex* temp_coef = new MYcomplex[mulSize];
 
    MYcomplex* L1 = new MYcomplex[mulSize];
    MYcomplex* L2 = new MYcomplex[mulSize];
 
    List1.set_begin(), List2.set_begin();
 
    for(int i=mulSize - 1; i>=0; i--) {
        if( List1.curr  && i ==  List1.curr->deg ){
            L1[i] = List1.get_cval();
            List1.next();
        }
        else L1[i] = 0;
 
        if( List2.curr && i ==  List2.curr->deg ){
            L2[i] = List2.get_cval();
            List2.next();
        }
        else L2[i] = 0;
    }
        Get_Fa(L1, Fc1, mulSize);
        Get_Fa(L2, Fc2, mulSize);
 
        delete [] L1;
        delete [] L2;
 
        for (int i=0; i<mulSize; i++) mulFa[i] = Fc1[i] * Fc2[i];
 
        delete [] Fc1;
        delete [] Fc2;
        
        Get_Fa(mulFa, temp_coef, mulSize, -1);
 
        delete [] mulFa;
 
 
        for (int i=0; i<mulSize; i++){
                if (i == 0)  mList.ins_end(/*System::Math::*/Round(temp_coef[i]/*.real*/, 3) / mulSize, 0);
                else mList.ins_end(/*System::Math::*/Round(temp_coef[mulSize - i]/*.real*/, 3) / mulSize,  i);
        }
        delete [] temp_coef;
        mList.delete_nulls();
 
}
 
 
 
template <class T>
MYcomplex find_x(MyList<T>& List, MYcomplex X) {
    List.sort();
    List.set_begin();
    int new_size = List.Get_maxDeg() + 1;
 
    if (List.curr) {
        T* a = new T[new_size];
        for(int i=new_size-1; i>=0; i--) {
            if( List.curr && i ==  List.curr->deg ) {
                a[i] = List.curr->data;
                List.next();
            }
            else a[i] = 0;
 
        }
        MYcomplex result;
        result = gorner(X, a[new_size-1], a, new_size - 2);
        delete [] a; 
        return result;
    }
    //напечатать, что список пустой 
    
};
 
template <class T> 
void random_init(MyList<T>& List, int size) {
 
    array<double>^ deg_dim = gcnew array<double>(size);
    for(int i=0; i<size; deg_dim[i] = -1, i++);
    node<T>* temp_curr = List.first;
    int val, deg, coef;
    int k, m;
    int flag;
    srand(time(NULL));
 
    for(int i=0;i<size;i++) {
        deg = 0;
        coef = -1;
        while(coef<0){
            val = rand() % 11;
            coef = int (pow(9.0,(val))) % 100;
        }
 
        while(255){
            flag = 1;
            k = rand() % 5 + 1;
            for(int j=0; j<k; j++) {
                m = rand() % 10;
                deg += ((7*m) % 10);
            }
            for(int l=0; (l<size && deg_dim[l]>=0); l++) {
                if (deg == deg_dim[l]) {
                    flag = 0;
                    break;
                }
            }
            if(flag) {
                deg_dim[i] = deg;
                break;
            }
 
        }
            
        List.ins_end(coef, deg);
        
    }
 
};
 
template <class T>
void summing( MyList<T>& List1,  MyList<T>& List2,MyList<T>& Sum_List, a_factor abs_one) {
    List1.sort();
    List2.sort();
 
    int new_size = int((List1.Get_maxDeg() > List2.Get_maxDeg())? List1.Get_maxDeg() : List2.Get_maxDeg());
    new_size++;
 
    node<T>* t1ptr = List1.first;
    node<T>* t2ptr = List2.first;
 
    T* d_list1 = new T[new_size];
    T* d_list2 = new T[new_size];
    
 
    for(int i=0; i<new_size; i++) {
        if( t1ptr && i == new_size - (t1ptr->deg + 1)){
            d_list1[i] = t1ptr->data;
            t1ptr = t1ptr->next;
        }
        else d_list1[i] = 0;
 
        if( t2ptr && i == new_size - (t2ptr->deg + 1) ) {
            d_list2[i] = t2ptr->data;
            t2ptr = t2ptr->next;
        }
        else d_list2[i] = 0;
    }
    for(int i=0; i<new_size; i++) {
        if( d_list1[i] != 0 || d_list2[i] != 0) {
            Sum_List.ins_end(
            d_list1[i] + abs_one*d_list2[i], new_size - 1 - i);
        }
    }
    Sum_List.delete_nulls();    
    delete [] d_list1;
    delete [] d_list2;
};