gestion de pile c++ !!! Aide !!!!

salut les amis, svp quelqu'un corriger mon prog de gestion de Pile File et merci beaucoup d'avance :)

---

#include<iostream.h>

                        //Class Basepile  ##############################################
class basepile{
int *p,taille;
public:
basepile(int);
basepile(basepile &);
void operator <(int);
void operator >(int &);
friend ostream & operator<<(ostream &,const basepile &);
~basepile();
};
//__________________________________________________________________________________
//Definition des objets de Class  << Base pile >> -----------------
//___________________________________________________________________________________
basepile::basepile(int n){
taille=n;
p=new int[taille];
for(int i=0;i<taille;i++)
*(p+i)=*(p.(p+i));
}
void basepile::operator >(int &x){
x=*p;
}
osrtream &operator (ostream & sortie,basepile & b){
for(int i=0;i<taille;i++){sortie<<*(p+i)<<" ";
return(sortie);
}

                      //Class LIFO  ###################################################
class lifo:public basepile{
int sommet;
lifo(int);
lifo(lifo &);
void operator<(int);
void operator>(int &);
friend ostream & operator <<(ostream &,const lifo &);

};
//___________________________________________________________________________________
//Definition des objets Class   << LIFO >> -----------------
//___________________________________________________________________________________

lifo::lifo(int n=10){
sommet=0;
taille=n;
p=new int[taille];
}
lifo::lifo(lifo & l){
sommet=l.sommet;
taille=l.taille;
for(int i=0;i<sommet;i++)
*(p+i)=*(l.p+i);
void lifo::operator>(int & x){sommet--;
x=*(p+sommet);
}
ostream & operator <<(ostream & sortie,lifo & l){
for(int i=0;i<sommet;i++)
sortie<<*(p+i)<<" ";
return(sortie);
}
                        //Class FIFO  ##################################################
class fifo:public basepile
{
     int que,tete;
     public:
     fifo(int);
     fifo(fifo&)
     void operator<(int);
     void operator>(int&);
     friend ostream &operator<<(ostream&,const fifo&);
     ~fifo();
}

//___________________________________________________________________________________
//Definition des objets Classe   << FIFO >> -----------------
//___________________________________________________________________________________
fifo::fifo(int n=10 ):basepile(n){
que=0;
tete=0;
}
fifo::fifo(fifo & f){
que=f.que;
tete=f.tete;
taille=f.taille;
for(int i=tete;i<que;i++)
 *(p+i)=*(f.p+i);
}
void fifo::operator<(int x){
*(p+que)=x;
que++;
}
void fifo::operator>(int & x){
x=*(p+tete);
tete++;
}
ostream & operator<<(ostream & sortie,fifo & l){
for(int i=tete;i<que;i++)
sortie<<*(p+i)<<" ";
return(sortie);
}

//######################################################################################
             //---------------------Programme principale-----------------
//######################################################################################

void main()
{basepile*ptpile;
fifo fifo;
lifo lifo;
ptpile=&fifo;
*ptpile<0<1;
int i;
*ptpile>i;
cout<<"Pile= "<<*ptpile<<" i= " <<i;
ptpile=&lifo;
*ptpile<0<1;
cout<<"Pile= "<<*ptpile;
*ptpile>1;
cout<<"Pile= "<<*ptpile<<" i= " <<i;
}

---

plutot ca :

---

#include<iostream.h>

                        //Class Basepile  ##############################################
class basepile
{protected:
int *p,taille;
public:
basepile(int);
basepile(const basepile&);
virtual void operator<(int);
virtual void operator>(int&);
friend ostream & operator<<(ostream &,const basepile &);
//ostream est la bib d'affichage
~basepile();
};
//__________________________________________________________________________________
//Definition des objets de Class  << Base pile >> -----------------
//___________________________________________________________________________________
basepile::basepile(int n=10)
{
     taille=n;
     p=new int[taille];
}

basepile::basepile(const basepile& bp)//constructeur par recopie
{taille=bp.taille;
     p=new int[taille];
     for (int i=0;i<taille;i++)
     *(p+i)=*(bp.p+i);
}

void basepile::operator<(int x)
{
     *p=x;
}

void basepile::operator>(int& x)
{
     x=*p;
}

ostream& operator<<(ostream & sortie,const basepile & b)
{
     for (int i=0;i<taille;i++)
      sortie<<*(p+i);
      return(sortie);
}
basepile::~basepile()
{
     delete[]p;
}

                      //Class LIFO  ###################################################
class lifo:public basepile
{
     int sommet;
     public:
     lifo(int);
     lifo(lifo&)
     void operator<(int);
     void operator>(int&);
     friend ostream &operator<<(ostream&,const lifo&);
     ~lifo();
};
//___________________________________________________________________________________
//Definition des objets Class   << LIFO >> -----------------
//___________________________________________________________________________________

lifo::lifo(int n=10) :basepile(n)
{
 sommet=0;
}

lifo::lifo(lifo& l) //constructeur par recopie
{  sommet=l.sommet;
     taille=l.taille;
     p=new int[taille];
     for (int i=0;i<sommet;i++)
     *(p+i)=*(l.p+i);
}

 void lifo::operator<(int x) //empiler
{
     *(p+sommet)=x;
     sommet++;
}

void lifo::operator>(int& x) //dépiler
{  sommet--;
     x=*(p+sommet);
}

ostream& operator<<(ostream& sortie,lifo& l)
{
     for (int i=0;i<sommet;i++)
     {sortie<<*(p+i);
      return(sortie);
}
                        //Class FIFO  ##################################################
class fifo:public basepile
{
     int que,tete;
     public:
     fifo(int);
     fifo(fifo&)
     void operator<(int);
     void operator>(int&);
     friend ostream &operator<<(ostream&,const fifo&);
     ~fifo();
};

//___________________________________________________________________________________
//Definition des objets Classe   << FIFO >> -----------------
//___________________________________________________________________________________
fifo::fifo(int n=10):basepile(n)
{
 que=0; tete=0;
}

fifo::fifo(fifo& f)//constructeur par recopie
{  que=f.que;
     tete=f.tete;
     taille=f.taille;

     for (int i=tete;i<que;i++)
     *(p+i)=*(f.p+i);
}

 void fifo::operator<(int x) //empiler
{
     *(p+que)=x;
     que++;
}

void fifo::operator>(int& x) //dépiler
{
     x=*(p+tete);
     tete++;

}

ostream& operator<<(ostream& sortie,fifo& f)
{
     for (int i=tete;i<que;i++)
     sortie<<*(p+i);
      return(sortie);
}

//######################################################################################
             //---------------------Programme principale-----------------
//######################################################################################

void main()
{basepile *ptpile;
fifo fifo;
lifo lifo;
ptpile=&fifo;
*ptpile<0<1;
int i;
*ptpile>i;
cout<<"Pile= "<<*ptpile<<" i= " <<i;
ptpile=&lifo;
*ptpile<0<1;
cout<<"Pile= "<<*ptpile;
*ptpile>1;
cout<<"Pile= "<<*ptpile<<" i= " <<i;
}

---

(Il a reposé la question dans la journée.)