Polimorfismo

[Peixoto 0]

:rolleyes:

 

Considere o fragmento de código abaixo, ele funciona perfeitamente:

 

int main()
{
//Classe base Areas_fig_planas
Areas_fig_planas *p; // Cria ponteiro para classe 
			 //Areas_fig_planas

Areas_fig_planas Area_Bse; // instancia classe base

p=&Area_Bse;  // p aponta para objeto do
		  // tipo Areas_fig_planas

p->Area(); // Acessa a função Área da classe base

//==============================================
//Classe derivada Area_Quadado
Area_Quadado Area_quadr; //Instancia Area_Quadado

p=&Area_quadr;   // p aponta para objeto do tipo
		       // Area_Quadado, que é um objeto
		    // derivado de Areas_fig_planas.

p->Area(); // Acessa a função Área da classe derivada
               //Area_Quadado.

 //===============================================          
//Classe derivada Área_Triangulo
Area_Triangulo Area_triang; //Comentários idem acima 

p=&Area_triang;
p->Area();

 

Pergunta: Se eu quiser chamar outra vez a área do quadrado, por exemplo, terei de fazer:

Area_Quadado Area_quadr;
p=&Area_quadr;
p->Area();

 

Novamente no programa ? teria uma forma alternativa para evitar a redundância de código ?

 

obrigado

[Renato Utsch 24]

Sim, você terá. Mas eu não entendi esse seu uso de referência aí não. Esse tipo de uso é inútil.

 

Referência só é útil quando for usada nos parâmetros de uma função. Qualquer outro uso é gasto de memória e linhas de código a toa.

 

 

Eu imagino que seja só um exercício ^^

 

 

 

Abraços :D

[Shurd 0]

Poderia fazer um p++ e gravar no p[1], não?

[Renato Utsch 24]

Não entendi.

 

 

Onde está essa array p?

 

 

Abraços :D

[Shurd 0]

ponteiros podem ser usados como arrays.

[Renato Utsch 24]

Não, não podem.

 

Você está fazendo confusão, arrays podem ser usadas como ponteiros, porque a variável da array em si aponta para o primeiro elemento dela, mas ponteiros não tem essa propriedade.

 

O que aconteceria quando fizesse p++;p[1];? Se o compilador deixasse compilar, o mínimo que ia acontecer é dar algum resultado absurdo no Windows. No linux, provavelmente terminaria com Core Dumped.

 

Pense, ao fazer isso que pensou, simplesmente você estaria apontando para a próxima área da memória após essa variável pela qual p aponta simplesmente. Quais garantias que você tem que é nela que estaria a outra variável que você fez p apontar pela maneira certa:

 

Area_Quadado Area_quadr;
p=&Area_quadr;

 

Nenhuma garantia.

 

 

Seu programa simplesmente não vai funcionar. ^^

Eu te digo, a única maneira de fazer isso é assim:

 

Area_Quadado Area_quadr;
p=&Area_quadr;

 

Não há outra. E é por isso (entre outros motivos) que é bem mais simples utilizar a variável Area_quadr em si, e não uma referência.

 

 

Abraços :D

[Peixoto 0]

:upset:

 

Rapaz !!!

 

Esqueci do tópico, e parece que a coisa desvirtou. A ideia não era discutir ponteiro, mas sim chamada de função polimórfica na base e derivada. É melhor esquecer tudo, e analisarmos a citação abaixo:

 

É dito que para se acessar um elemento da derivada, que não foi herdado , é preciso fazer uma coerção de tipo com o ponteiro da classe base.

Como fazer isso ?

Ao ler a citação pense em função polimorfica.

 

Por fim. Se diz que: podemos ter destrutores virtuais, mas não construtoress virtuais. DEITEL levanta essa bola, não explicabem quando é emprecado o destrutor virtual. Poderiam explicar ?

 

Obrigado