Alterando a PILHA

Fiz estas 3 implementações, mas aparece uma mensagem de erro na ultima:

acrescentando as seguintes operações na PILHA:

* Um construtor que possa receber uma pilha como parâmetro na hora de instanciar um objeto do tipo pilha. Neste construtor a pilha criada deve ter o mesmo tamanho e os mesmos elementos da pilha passada como parâmetro.
* Depois uma operação para redefinir o operador de atribuição ( CPilha& CPilha::operator=(const CPilha &p) ). Dessa forma quando for feita uma atribuição de duas pilhas, uma pilha receberá os elementos da outra.
* Depois uma operação para redefinir o operador de igualdade (bool operator==(const CPilha &p1, const CPilha &p2) ). Essa operação deve comparar os elementos das duas pilhas, se eles forem diferentes ou se as pilhas tiverem tamanhos diferentes ela deve retornar falso, caso contrário deve retornar verdadeiro.

Apresenta o seguinte erro:

Pilha.cpp(16): ´PilhaInteiros::operator ==(const PilhaInteiros &, const PilhaInteiros &)´ must be declared with one parameter.
Pilha.cpp(90): Function should return a value.
Pilha.cpp(129): ´operator==´ not implement in type ´PilhaInteiros´ for arguments of the same type

Vou deixar o codigo todo abaixo, caso alguem queira copiar e testar...
As 3 linhas em negrito é onde apresenta erro ....Agradeço quem ajudar...

//Interface
#include <iostream.h>
include <stdio.h>
include <conio.h>
include <stdlib.h>

class PilhaInteiros {
int *vet;
int maxElementos;
int topo;
public:
PilhaInteiros() ;
PilhaInteiros(int tam);
PilhaInteiros (PilhaInteiros &p);
PilhaInteiros & operator = (const PilhaInteiros &p);
[b:0eb5146c9e]bool operator==(const PilhaInteiros &p1, const PilhaInteiros &p2);[/b:0eb5146c9e]
~PilhaInteiros();
void Empilha(int elem);
void Desempilha();
int Topo();
bool Vazia();
};

PilhaInteiros::PilhaInteiros (PilhaInteiros &p) {

vet = new int[p.maxElementos];
for (int i=0; i<p.topo; i++)
vet [i] = p.vet [i];
maxElementos = p.maxElementos;
topo = p.topo;
}

PilhaInteiros::PilhaInteiros() {
vet = new int[100];
maxElementos = 100;
topo = 0;
}

PilhaInteiros::PilhaInteiros(int tam) {
if ( tam > 0 ) {
vet = new int[tam];
maxElementos = tam;
topo = 0;
} else {
std::cout << ´Erro: Tamanho inválido\n´;
}
}

PilhaInteiros::~PilhaInteiros() {
delete [] vet;
}

void PilhaInteiros::Empilha(int elem) {
if ( topo < maxElementos ) {
vet[topo++] = elem;
} else {
std::cout << ´Erro: Pilha cheia\n´;
}
}

void PilhaInteiros::Desempilha() {
if ( topo > 0 ) {
topo--;
} else {
std::cout << ´Erro: Pilha vazia\n´;
}
}

int PilhaInteiros::Topo() {
int aux=0;
if ( topo > 0 ) {
aux = vet[topo-1];
} else {
std::cout << ´Erro: Pilha vazia\n´;
}
return aux;
}

bool PilhaInteiros::Vazia() {
return topo == 0;
}

PilhaInteiros &PilhaInteiros:: operator = (const PilhaInteiros &p) {
delete [] vet;
vet = new int[p.maxElementos];
for (int i=0; i<p.topo; i++)
vet [i] = p.vet [i];
maxElementos = p.maxElementos;
topo = p.topo;
}

[b:0eb5146c9e]bool PilhaInteiros:: operator ==(const PilhaInteiros &p1, const [/b:0eb5146c9e]PilhaInteiros &p2) {
if (p1.maxElementos != p2.maxElementos)
return false;
if (p1.topo != p2.topo)
return false;
for (int i=0; i<p1.topo; i++) {
if (p1.vet [i] != p2.vet [i])
return false;
}
return true;
}

void main () {

int i, Escolha, valor;
PilhaInteiros P;
PilhaInteiros T;
i=0;
do{
clrscr();
cout<<´\n\t\tPrograma de teste da PILHA \n´;
cout<<´\t\tEscolha uma das opções\n´;
cout<<´\t\t1-Insere valor na PILHA\n´;
cout<<´\t\t2-Atribuir as PILHAS\n´;
cout<<´\t\t3-Comparar as PILHAS\n´;
cout<<´\t\t4-Sair do Menu\n´;
cin>>Escolha;
switch(Escolha){
case 1:
cout<<´Digite o valor\n´;
cin>>valor;
P.Empilha(valor);
break;
case 2:
T=P;
break;
case 3:
[b:0eb5146c9e] T==P;[/b:0eb5146c9e]
break;
case 4:
break;
}
clrscr();
cout<<´Deseja sair do programa?\n´;
cout<<´Se sim digite 0\n´;
cout<<´Se não digite 1\n´;
cin>>i;

}while(i!=0);

getch ();
}