Переменная не инициализирована

#pragma once
#include <iostream>
 
 
 
template<typename T>
struct Tree
{
private:
    struct node {
        node *left;
        node * rigth;
        void *data;
        int key;
    };
    node *head;
public:
    Tree()
    {
        this->head = NULL;
    }
private:
    inline void pushing(node *t,int key, void *data)
    {
        if (t)
        {
            if (key > t->key)
            {
                this->pushing(t->left, key, data);
            }
            else
            {
                this->pushing(t->rigth, key, data);
            }
        }
        else
        {
            node *k = new (node);
            k->data = data;
            k->key = key;
            if (this->head == NULL)
            {
                this->head = k;
            }
        }
    }
public:
    inline bool push(int key, void *data)
    {
        this->pushing(this->head,key,data);
        return true;
    }
};

#include "Tree.h"
 
struct MS
{
 
};
 
 
void main()
{
    Tree<MS> *ms;
    ms->push(10,(void*)1243);
}

#include <iostream>
#pragma once
 
using namespace std;
 
template <typename T>
struct stek
{
public:
    typedef T value_type; // тип значения
    typedef value_type& value_ref; // ссылка на элемент
    typedef const value_type& value_cref; // константная ссылка
private:
    int size;
    struct  node
    {
        void *data;
        node *next;
    };
    node *Head;
public:
    stek()
    {
        size = 0;
        Head = NULL;
    }
    ~stek()
    {
        Clear();
    }
    inline void Push(void *q);//встроенная функция
    inline void* Pop();
    inline void Clear();
    inline int SizeS();
};
 
template <typename T>
void stek<T>::Push(void *q)
{
    node *t = new (node);
    if (!t)
    {
        cout << "Not enough memory!" << endl;
        exit(0);
    }
    t->data = q;
    if (this->Head)
    {
        t->next = this->Head;
    }
    else
    {
        t->next = NULL;
    }
    this->size++;
    this->Head = t;
}
 
template <typename T>
void *stek<T>::Pop()
{
    void *d;
    if (this->Head)
    {
        d = this->Head->data;
        node *b = this->Head;
        this->Head = this->Head->next;
        delete b;
        this->size--;
    }
    return d;
}
 
template <typename T>
void stek<T>::Clear()
{
    while (this->Head)
    {
        node *t = this->Head;
        this->Head = this->Head->next;
        delete t;
        this->size = 0;
    }
}
 
template <typename T>
int stek<T>::SizeS()
{
    return this->size;
}

#include <ctime>
 
#include "Stack.h"
 
int RANDOM(int a)
{
    return  a - 2 * (rand() % a);
}
 
 
struct MS
{
 
};
 
struct S1
{
 
};
 
struct S2
{
 
};
 
 
void main()
{
    stek<MS> ms;
    srand((unsigned)time(0));
    for (int i = 10; i > 0; i--)
    {
        int r = RANDOM(100);
        ms.Push((void*)r);
        cout << r << " ";
    }
    cout << endl;
    stek<S1> s1;
    stek<S2> s2;
    while (ms.SizeS())
    {
        int a = (int)ms.Pop();
        if (a>0)
        {
            s1.Push((void*)a);
        }
        else
        {
            s2.Push((void*)a);
        }
    }
 
 
    while (s1.SizeS())
    {
        cout << (int)s1.Pop() << " ";
    }
    cout << endl;
 
 
    while (s2.SizeS())
    {
        cout << (int)s2.Pop() << " ";
    }
    cout << endl;
 
    system("pause");
}