Стек с объектами

//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
 
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{      }
 
//----Базовый класс "Осветительные приборы"----//
class osv_prib
{
public:
       virtual void print(TMemo* M)const = 0;
       osv_prib():cena(0),imya("nope"),CCBETA(0){};
       osv_prib( double cena1 ,AnsiString imya1,double CCBETA1):
       cena(cena1),imya(imya1),CCBETA(CCBETA1){};
protected:
       double cena;//цена
       AnsiString imya;//имя
       double   CCBETA;//сила света
};
 
 
 
 //---- класс "Светильники"----//
class svetilniki: public osv_prib
{public:
        svetilniki():dalnost(0){};
        svetilniki(double cena1 ,AnsiString imya1,double   CCBETA1, double dalnost1):
        osv_prib(cena1,imya1, CCBETA1),dalnost(dalnost1){};
        virtual void print (TMemo* M) const;
        svetilniki& operator= (const svetilniki &a);
protected:
        double dalnost;//Дальность освещения
};
void svetilniki :: print(TMemo* M) const{
M->Lines->Add("Светильники:");
M->Lines->Add("Цена: "+FloatToStr(cena));
M->Lines->Add("Имя: "+imya);
M->Lines->Add("Сила света: "+FloatToStr(CCBETA));
M->Lines->Add("Дальность: "+FloatToStr(dalnost));
}
svetilniki& svetilniki::operator=(const svetilniki &a){
cena = a.cena;
imya = a.imya;
CCBETA = a.CCBETA;
dalnost = a.dalnost;
return (*this);
}
 
 
 
 //----класс"Прожекторы"----//
class proj: public osv_prib {
public:
        proj():ploshad(0){};
        proj(double cena1 ,AnsiString imya1,double   CCBETA1, int ploshad1):
        osv_prib(cena1,imya1,CCBETA1),ploshad(ploshad1){};
        virtual void print(TMemo* M) const;
        proj& operator= (const proj &a);
protected:
        int ploshad; //площадь освещения
};
void proj::print(TMemo* M) const{
        M->Lines->Add("Прожекторы:");
        M->Lines->Add("Цена: "+FloatToStr(cena));
        M->Lines->Add("Имя: "+imya);
        M->Lines->Add("Сила света: "+FloatToStr(CCBETA));
        M->Lines->Add("Площадь освещения: "+IntToStr(ploshad));
}
proj& proj::operator=(const proj &a){
        cena = a.cena;
        imya = a.imya;
        CCBETA = a.CCBETA;
        ploshad = a.ploshad;
return (*this);
}
 
 
 
 
 //----класс "Ночники"----//
class nochniki: public svetilniki{
public:
        nochniki():vid(""){};
        nochniki(double cena1 ,AnsiString imya1,double CCBETA1,double dalnost,AnsiString vid1):
        svetilniki(cena1 ,imya1, CCBETA1,dalnost),
        vid(vid1){};
        virtual void print (TMemo* M) const;
        nochniki& operator= (const nochniki &a);
protected:
        AnsiString vid;// вид
};
void nochniki::print(TMemo* M) const {
        M->Lines->Add("Ночники:");
        M->Lines->Add("Цена: "+FloatToStr(cena));
        M->Lines->Add("Имя: "+imya);
        M->Lines->Add("Сила света: "+FloatToStr(CCBETA));
        M->Lines->Add("Разновидность: "+(vid));
}
nochniki& nochniki::operator= (const nochniki &a){
        cena = a.cena;
        imya = a.imya;
        CCBETA = a.CCBETA;
        vid = a.vid;
return (*this);
}
 
 
//----Класс Стек----//
template <class Type1>
class Stack
{private:
        enum {MAX = 10};
        int st [MAX]; //стек в виде массива
        int top;    //вершина стека
 
public:
        Stack(Type1 st1,Type1 st2,Type1 st3);
        Stack(){top = 0;} // конструктор
        ~Stack(){};
        void push(int var)//поместить в стек
        {st [ ++top ] = var;}
        int pop (){return st [top--];} //взяьть из стека
        void print(TMemo* MM);
        Stack& operator=(const Stack& T);
};

#pragma once
 
#define NULL 0
 
template <class T>
class Stack                     
{
    struct node                 
    {
        T item;
        node* next;
    };
 
private:
    node* tail;                 
    int anz_intems;             
 
public:
 
 
 
Stack(void) : anz_intems(0)
{
    tail=NULL;
}
 
 
virtual ~Stack(void)
{
}
 
 
template <class T> bool push(T &r)
{
     node* topNode = new node;
 
     if(!topNode) return 0;
    
     topNode->item = r;
     topNode->next = tail;
     tail = topNode;
 
     return 1;
}
 
 
template <class T> void pop()
{
    if(!tail) 
    {
        std::cout << "Steck ist leer";
    }
    else
    {
        node* Temp = tail;
        tail = tail->next;
        delete Temp;
    }
}
 
 
template <class T> T top()
{
    if(!tail) return 0;
    else return tail->item;
}
 
 
template <class T> int length()
{
    return anz_intems;
}
 
 
template <class T> bool empty()
{
    if(!anz_intems) return 1;
    else return 0;
}
};