Не компилируется проект

#include <iostream>
 
int main(){
    std::cout << "Hello, world!\n";
    return(0);
}

#ifndef _STACK
#define _STACK
 
template <class T>
class stack
{
private:
    int top;                //Вершина стека
    int SZ;                 //Размер стека
    T *elems;               //Массив элементов стека
public:
    stack (int size=10);    //Конструктор
    ~stack ();              //Деструктор
    void push (T);          //Включение нового элемента
    T pop ();               //Извлечение элемента
    T &read ();             //Чтение вершины стека
    T &write ();            //Запись в вершину стека
    bool empty ();          //Проверка на пустоту
    void clean ();          //Очистка стека
    int size () const;      //Опрос числа элементов в стеке
};
 
//Конструктор
template <class T>
stack<T>::stack(int size = 10)
{
    SZ=size;
    elems=static_cast<T *>(malloc (sizeof(T)*size));
    top=-1;
}
 
//Деструктор
template <class T>
stack<T>::~stack()
{
    free (elems);
}
 
//Очистка стека
template <class T>
void stack<T>::clean()
{
    SZ=10;
    free (elems);
    elems=static_cast<T *>(malloc (sizeof(T)*10));
    top=-1;
}
 
//Проверка на пустоту
template <class T>
bool stack<T>::empty()
{
    return top==(-1) ? 1 : 0;
}
 
//Включение нового элемента
template <class T>
void stack<T>::push (T elem)
{
    top++;
    if (top==SZ) {
        SZ*=2;
        elems=static_cast<T *> (realloc (elems, sizeof (T)*SZ));
    }   
    elems[top]=elem;    
}
 
//Извлечение элемента
template <class T>
T stack<T>::pop()
{
    if (empty ()) throw "stack is empty";
    if (top==SZ/2-1) {
        SZ/=2;
        elems=static_cast<T *> (realloc (elems, sizeof (T)*SZ));
    }
    top--;
    return elems[top+1];
}
 
//Чтение вершины стека
template <class T>
T &stack<T>::read()
{
    if (empty ()) throw "stack is empty";
    return elems[top];
}
 
//Запись в вершину стека
template <class T>
T &stack<T>::write()
{
    if (empty ()) throw "stack is empty";
    return elems[top];
}
 
//Опрос числа элементов в стеке
template <class T>
int stack<T>::size() const
{
    return top+1;
}
 
#endif

#ifndef _BST
#define _BST
 
#include "stack.h"
enum deleted {FALSE,TRUE,DELETED};
 
template <class T>
class BST 
{
private:
    friend class Iterator;
    struct elem                 //Узел дерева
    {
        T *data;                //Данные узла
        int key;                //Ключ узла
        elem *left;             //Левый сын
        elem *right;            //Правый сын
        int visit;              //Признак посещения узла
        elem (int, T *);        //Конструктор узла
        ~elem();                //Деструктор узла
    };
    elem *root;                 //Корень дерева
    int QN;                     //Число просмотренных узлов
    int SZ;                     //Размер дерева
    
    //methods
    void L_R_tr (elem *, void (BST::*point)(elem *));   //Рекурсивный обход дерева
    elem *insertkr (int, T *, elem *);                  //Рекурсивное включение данных по ключу
    void showr (elem *, int);                           //Рекурсивный вывод структуры дерева на экран
    void delnode (elem *);                              //Удаление узла
    void cleanvisit (elem *);                           //Сброс признака посещения узла
    T &getdatakr (int, elem *);                         //Рекурсивный доступ к данным по ключу
    elem *del (elem *, elem *);                         //Вспомогательная функция для рекурсивного удаления
    elem *deldatakr (int, elem *, deleted &);           //Рекурсивное удаление по ключу   
    elem *max (elem *);                                 //Поиск максимального по ключу узла
    elem *r_parent (elem *, elem *);                    //Поиск правого родителя узла
    elem *predecessor (elem *, elem *);                 //Поиск предыдущего по значению ключа узла
    elem *min (elem *);                                 //Поиск минимального по ключу узла
    elem *l_parent (elem *, elem *);                    //Поиск левого родителя узла
    elem *successor (elem *, elem *);                   //Поиск следующего по значению ключа узла
    //elem *find (int, elem *);                           //Поиск заданного значения по ключу
    
public:
    BST ();                     //Конструктор
    BST (const BST<T> &);       //Конструктор копирования
    ~BST (void);                //Деструктор
    int size () const;          //Опрос размера дерева
    void clean ();              //Очистка дерева
    bool empty () const;        //Проверка дерева на пустоту
    T &getdatak (int);          //Доступ к данным по ключу
    bool insertk (int, T *);    //Включение данных по ключу
    bool deldatak (int);        //Удаление данных по ключу
    int longpath (void);        //Определение длины внутреннего пути дерева
    
    //++
    void show ();               //Вывод структуры дерева на экран
    int quantnode () const;     //Опрос числа просмотренных операций узлов дерева
    //Iterator
    class Iterator
    {
    private:
        BST *tree;              //Указатель на BST дерево
        elem *current;          //Указатель на текущий элемент
    public:
        Iterator (BST *);
        ~Iterator ();
        void first ();
        void end ();
        bool valid () const;
        T &read () const;
        T &write ();
        void next ();
        void prev ();
    };
};
 
//Конструктор узла
template <class T>
BST<T>::elem::elem(int keyU, T *dataU)
{
    key=keyU;
    data=dataU;
    left=right=NULL;
}
 
//Деструктор узла
template <class T>
BST<T>::elem::~elem()
{
    delete data;
}
 
//Рекурсивный обход дерева
template <class T>
void BST<T>::L_R_tr(elem *tree, void (BST<T>::*point)(elem *))
{
    if (tree==NULL) return;
    L_R_tr (tree->left,point);
    L_R_tr (tree->right,point);
    (this->*point) (tree);
    QN++;
}
 
//Рекурсивное включение данных по ключу
template <class T>
typename BST<T>::elem *BST<T>::insertkr (int key, T *data, elem *tree)
{
    QN++;
    if (key<tree->key) 
        if (tree->left!=NULL) tree->left=insertkr (key, data, tree->left);
        else {tree->left=new elem (key, data); SZ++;}
    else
        if (key>tree->key) 
            if (tree->right!=NULL) tree->right=insertkr (key,data,tree->right);
            else {tree->right=new elem (key, data); SZ++;}
        else throw "key is exist";
    return tree;        
}
 
//Рекурсивный вывод структуры дерева на экран
template <class T>
void BST<T>::showr(typename BST<T>::elem *tree, int deep)
{
    if (tree==NULL) return;
    showr (tree->right, deep+1);
    int k=deep;
    while (k) {
        cout << "   ";
        k--;
    }
    QN++;
    cout << (tree->key) << endl;
    showr (tree->left, deep+1);
}
 
//Удаление узла
template <class T>
void BST<T>::delnode(typename BST<T>::elem *node)
{
    if (node==NULL) throw "node is not exist";
    SZ--;
    delete node;
}
 
//Сброс признака посещения узла
template <class T>
void BST<T>::cleanvisit(typename BST<T>::elem *node)
{
    if (node==NULL) throw "node is not exist";
    node->visit=0;
}
 
//Рекурсивный доступ к данным по ключу
template <class T>
T &BST<T>::getdatakr(int key, typename BST<T>::elem *tree)
{
    if (tree==NULL) throw "element does not exist";
    QN++;
    if (tree->key==key) return *(tree->data);
    if (tree->key>key) return getdatakr (key, tree->left);
    else return getdatakr (key, tree->right);
}
 
//Вспомогательная функция для рекурсивного удаления
template <class T>
typename BST<T>::elem *BST<T>::del(typename BST<T>::elem *tree, typename BST<T>::elem *tree0)
{
    QN++;
    if (tree->left!=NULL) {
        tree->left=del (tree->left, tree0);
        return tree;
    }
    tree0->key=tree->key;
    *(tree0->data)=*(tree->data);
    elem *x=tree->right;
    delete tree;
    return x;
}
 
//Рекурсивное удаление данных по ключу
template <class T>
typename BST<T>::elem *BST<T>::deldatakr(int key, typename BST<T>::elem *tree, deleted &D)
{
    if (tree==NULL) {
        D=FALSE;
        return tree;
    }
    if (key<tree->key) {
        QN++;
        tree->left=deldatakr (key, tree->left, D);
        return tree;
    }
    if (key>tree->key) {
        QN++;
        tree->right=deldatakr (key, tree->right, D);
        return tree;
    }
    D=TRUE;
    if (tree->left==NULL&&tree->right==NULL) {
        QN++;
        delete tree;
        return NULL;
    }
    if (tree->left==NULL) {
        QN++;
        elem *x=tree->right;
        delete tree;
        return x;
    }
    if (tree->right==NULL) {
        QN++;
        elem *x=tree->left;
        delete tree;
        return x;
    }
    tree->right=del (tree->right,tree);
    return tree;
}
 
//Поиска максимального по ключу узла
template <class T>
typename BST<T>::elem *BST<T>::max(typename BST<T>::elem *tree)
{
    if (tree==NULL) return NULL;
    while (tree->right) {QN++; tree=tree->right;}
    return tree;
}
 
//Поиск правого родителя узла
template <class T>
typename BST<T>::elem *BST<T>::r_parent(typename BST<T>::elem *tree, typename BST<T>::elem *x)
{
    QN++;
    if (tree==x) return NULL;
    if (x->key>tree->key) {
        elem *rp=r_parent (tree->right,x);
        if (rp) return rp;
        else return tree;
    }
    else return r_parent (tree->left,x);
}
 
//Поиск предыдущего по значению ключа узла
template <class T>
typename BST<T>::elem *BST<T>::predecessor(typename BST<T>::elem *tree, typename BST<T>::elem *tree0)
{
    QN=0;
    if (tree0->left!=NULL) return max (tree0->left);
    else return r_parent (tree, tree0);
}
 
//Поиск минимального по значению ключа узла
template <class T>
typename BST<T>::elem *BST<T>::min(typename BST<T>::elem *tree)
{
    if (tree==NULL) return NULL;
    while (tree->left) {QN++;tree=tree->left;}
    return tree;
}
 
//Поиск левого родителя узла
template <class T>
typename BST<T>::elem *BST<T>::l_parent(typename BST<T>::elem *tree, typename BST<T>::elem *x)
{
    QN++;
    if (tree==x) return NULL;
    if (x->key<tree->key) {
        elem *lp=l_parent (tree->left,x);
        if (lp) return lp;
        else return tree;
    }
    else return l_parent (tree->right,x);
}
 
//Поиск следующего по значению ключа узла
template <class T>
typename BST<T>::elem *BST<T>::successor(typename BST<T>::elem *tree, typename BST<T>::elem *tree0)
{
    QN=0;
    if (tree0->right!=NULL) return min (tree0->right);
    else return l_parent (tree, tree0);
}
/*/Поиск значения узла по ключу
template <class T>
typename BST<T>::elem *BST::find(int key, typename BST<T>::elem *tree)
{
    if (tree==NULL) return NULL;
    cout << (tree->key) << endl;
}*/
 
//Конструктор
template <class T>
BST<T>::BST()
{
    root=0;
    QN=0;
    SZ=0;
}
 
//Деструктор
template <class T>
BST<T>::~BST()
{
    clean ();
}
 
//Проверка дерева на пустоту
template <class T>
bool BST<T>::empty() const
{
    return SZ ? 0 : 1;
}
 
//Доступ к данным по ключу
template <class T>
T &BST<T>::getdatak(int key)
{
    if (root==NULL) throw "BST is empty";
    QN=0;
    return getdatakr (key, root);
}
 
//Определение размера дерева
template <class T>
int BST<T>::size() const
{
    return SZ;
}
 
//Очистка дерева
template <class T>
void BST<T>::clean()
{
    if (root==NULL) return;
    QN=0;
    L_R_tr (root,&BST<T>::delnode);
    SZ=0;
    root=NULL;
}
 
//Вставка в дерево по ключу
template <class T>
bool BST<T>::insertk(int key, T *data)
{
    QN=0;
    if (root==NULL) {
        root=new elem (key,data);
        SZ++;
        return true;
    }
    try {
    root=insertkr (key, data, root);
    }
    catch (char *)
    {
        return false;
    }
    return true;
}
 
//Удаление данных по ключу
template <class T>
bool BST<T>::deldatak(int key)
{
    deleted D;
    QN=0;
    root=deldatakr (key, root, D);
    SZ--;
    return D ? 1 : 0;
}
 
//Определение длины внутреннего пути дерева
template <class T>
int BST<T>::longpath()
{
    QN=0;
    if (root==NULL) return 0;
    L_R_tr (root, &BST<T>::cleanvisit);
    stack<elem *> ST;
    ST.push (root);
    root->visit=1;
    int max=0, SZ;
    while (!ST.empty ())
    {
        while (ST.read()->left&&!ST.read()->left->visit)
        {
            ST.read()->left->visit=1;
            ST.push (ST.read()->left);
        }
        SZ=ST.size ();
        if (max<SZ) max=SZ;
        if (ST.read()->right&&!ST.read()->right->visit) {
            ST.read()->right->visit=1;
            ST.push (ST.read()->right);
            continue;
        }
        ST.pop ();
        QN++;
    }
    return max;
}
 
//Вывод дерева на экран
template <class T>
void BST<T>::show()
{
    if (root==NULL) throw "BST is empty";
    QN=0;
    showr (root, 0);
}
 
//Опрос числа просмотренных узлов
template <class T>
int BST<T>::quantnode() const
{
    return QN;
}
 
//Конструктор итератора
template <class T>
BST<T>::Iterator::Iterator (BST<T> *datatree) 
{
    tree=datatree;
    current=NULL;
}
 
//Деструктор итератора
template <class T>
BST<T>::Iterator::~Iterator()
{
}
 
//Установка на первый элемент коллекции
template <class T>
void BST<T>::Iterator::first()
{
    current=tree->root;
    if (current==NULL) throw "Collection is empty";
    while (current->left!=NULL) current=current->left; 
}
 
//Установка на последний элемент коллекции
template <class T>
void BST<T>::Iterator::end()
{
    current=tree->root;
    if (current==NULL) throw "Collection is empty";
    while (current->right!=NULL) current=current->right;
}
 
//Чтение данных текущего объекта
template <class T>
T &BST<T>::Iterator::read() const
{
    if (valid ()) return *(current->data);
    else throw "Iterator does not set";
}
 
//Запись данных в текущий объект
template <class T>
T &BST<T>::Iterator::write()
{
    if (valid ()) return *(current->data);
    else throw "Iterator does not set";
}
 
//Проверка состояния итератора
template <class T>
bool BST<T>::Iterator::valid() const
{
    if (current) return true;
    else return false;
}
 
//Переход к следующему по ключу элементу
template <class T>
void BST<T>::Iterator::next()
{
    if (!valid ()) throw "Iterator does not set";
    current=tree->successor (tree->root, current);
}
 
//Переход к предыдущему по ключу элементу
template <class T>
void BST<T>::Iterator::prev()
{
    if (!valid ()) throw "Iterator does not set";
    current=tree->predecessor (tree->root, current);
}
 
#endif

#include <iostream>
#include <conio.h>
#include "BST.h"
 
using namespace std;
 
#define type    int
 
BST<type> tree;
int num;
BST<int>::Iterator iter (&tree);
int numi;
 
void main ()
{
    setlocale (LC_ALL,"rus");
    int f=0, fl;
    int *data;
    int key,n;
    int data1;
    while (1)
    {
        cout << "\t\tМеню программы\n";
        cout << "1 - Включение данных по ключу\n";
        cout << "2 - Вывод структуры дерева на экран\n";
        cout << "3 - Опрос размера дерева\n";
        cout << "4 - Проверка дерева на пустоту\n";
        cout << "5 - Очистка дерева\n";
        cout << "6 - Запись данных по ключу\n";
        cout << "7 - Чтение данных по ключу\n";
        cout << "8 - Удаление данных по ключу\n";
        cout << "9 - Определение длины внутреннего пути дерева\n";
        cout << "10 - Опрос числа просмотренных узлов\n";
        cout << "11 - Тест\n";
        cout << "0 - Работа с итератором\n";
        cout << "Введите номер пункта меню: ";
        cin >> num;
        
            int i=0;
        switch (num)
        {
        case 1 : 
            data=new int;
            cout << "Введите данные: ";
            cin >> *data;
            cout << "Введите ключ: ";
            cin >> key;
            if (tree.insertk (key, data)) cout << "Данные успешно включены\n";
            else cout << "Данные не включены\n";
            break;
        case 2 :
            try {
                tree.show ();
            }
            catch (char *) {
                cout << "Дерево пусто\n";
            }
            break;
        case 3 :
            cout << "Размер дерева: " << tree.size () << endl;
            break;
        case 4 :
            if (tree.empty ()) cout << "Дерево пусто\n";
            else cout << "Дерево не пусто\n";
            break;
        case 5 :
            tree.clean ();
            cout << "Дерево очищено\n";
            break;
        case 6 :
            cout << "Введите новые данные: ";
            cin >> data1;
            cout << "Введите ключ по которому будет произведена запись: ";
            cin >> key;
            try {
                tree.getdatak (key)=data1;
            }
            catch (char *ss) {
                cout << ss << endl;
                break;
            }
            cout << "Запись произведена успешно";
            break;
        case 7 :
            cout << "Введите ключ по которому будет произведено чтение: ";
            cin >> key;
            try {
                cout << "По ключу " << key << " находятся данные " << tree.getdatak (key) << endl;
            }
            catch (char *ss)
            {
                cout << ss << endl;
                break;
            }
            break;
        case 8 :
            cout << "Введите ключ по которому будет произведено удаление: ";
            cin >> key;
            if (tree.deldatak (key)) cout << "Удаление по ключу " << key << " произведено успешно\n";
            else cout << "Удаления не произошло\n";
            break;
        case 9 :
            cout << "Длина внутреннего пути дерева составляет " << tree.longpath () << endl;
            break;
        case 10 :
            cout << "Последняя операция просмотрела " << tree.quantnode () << " узлов\n";
            break;
 
            //////////////////////////////////////////////////////////////////////////////
 
        case 11 :
            cout << "Bведите размер дерева: ";
            cin >> n;
            //int k;
            int* m;
            m = new int [n];
            do 
            {
                int k = rand();
                tree.insertk(k,&k);
                m[i]=k;
                i++;
            }
            while (i<n);
 
            /*int a=0, b=0, c=0;
            for (i=0; i<n/2 ; i++)
            {
            
            if(i%10 == 0)
            {
                int v;
                v = (rand()+ rand());
                a.deldatakr(v);
                C5 = C5 + C.count;
                b.find(v);
                C6 = C6 + C.count;  
                c.insertk(m[rand()%n],m[rand()%n]);
                C4 = C4 + C.count;  
                                            
            }
            else
            {
                int id;
                id = rand()%n;
                int key;
                a.deldeldatakr(m[id]);
                C5 = C5 + C.count;
                b.find(m[id]);
                C6 = C6 + C.count;
                c.insertk(m[id],m[id]);
                C4 = C4 + C.count;
        }*/
        }
                break;
        case 0:
            fl=0;
            while (1)
            {
                cout << "\t\tМеню итератора\n";
                cout << "1 - установка итератора на начало коллекции\n";
                cout << "2 - установка итератора на конец коллекции\n";
                cout << "3 - проверка состояния итератора\n";
                cout << "4 - чтение данных\n";
                cout << "5 - установка итератора на предыдущий по значению ключа элемент\n";
                cout << "6 - установка итератора на следующий по значению ключа элемент\n";
                cout << "7 - запись данных в текущую позицию\n";
                
                cout << "Введите номер пункта меню: ";
                
                cin >> numi;
                switch (numi)
                {
                case 1 :
                    try {
                        iter.first ();
                    }
                    catch (char *ss) {
                        cout << ss << endl;
                        break;
                    }
                    cout << "Итератор установлен в начало коллекции\n";
                    break;
                case 2 :
                    try {
                        iter.end ();
                    }
                    catch (char *ss) {
                        cout << ss << endl;
                        break;
                    }
                    cout << "Итератор установлен в конец коллекции\n";
                    break;
                case 3 :
                    if (iter.valid ()) cout << "Итератор установлен\n";
                    else cout << "Итератор не установлен\n";
                    break;
                case 4 :
                    try {
                        cout << "Данные текущего объекта: " << iter.read () << endl;
                    }
                    catch (char *ss) {
                        cout << ss << endl;
                        break;
                    }
                    break;
                case 5 :
                    try {
                        iter.prev ();
                    }
                    catch (char *ss) {
                        cout << ss << endl;
                        break;
                    }
                    cout << "Переход осуществлен\n";
                    break;
                case 6 :
                    try {
                        iter.next ();
                    }
                    catch (char *ss) {
                        cout << ss << endl;
                        break;
                    }
                    cout << "Переход осуществлен\n";
                    break;
                case 7 :
                    cout << "Введите новые данные: ";
                    cin >> data1;
                    try {
                        iter.write ()=data1;
                    }
                    catch (char *ss) {
                        cout << ss << endl;
                        break;
                    }
                    cout << "Новые данные успешно записаны";
                    break;
 
                default:
                    cout << "Завершение работы с итератором\n";
                    fl=1;
                }
                _getch();
                if (fl) break;
            }
            break;
        default:            
            cout << "Выход из программы\n";
            f=1;
        }
        _getch();
        if (f) break;
    }
}