Newsgroup: it.comp.lang.c++
Titolo: Polimorfismo? Binding dinamico?

Salve a tutti.
Vi prego di dedicare la vostra attenzione a questo esempio.
class quadrilatero {
public:
quadrilatero (int a, int b) {x=a; y=b;};
int area (quadrilatero q) {.............};
private:
int x,y;
};
class quadrato:public quadrilatero {
public:
int area (quadrato q) {
return q.x*q.x;
};
quadrato (int a, int b): quadrilatero (a,b) {};
private:
int x, y;
};
void main () {
quadrato quadrato1(7, 8);
quadrato* qdr;
qdr=&quadrato1;
quadrilatero* qd=qdr;
printf("L'area vale %d\n", qd->area(quadrato1)); }
A  questo punto, secondo quello che credo di aver capito, dovrebbe
essere chiamata la funzione che calcola l'area situata nella classe
quadrato. Invece, provando a far eseguire al calcolatore il programma,
mi accorgo che la funzione chiamata è quella definita all'interno
della classe quadrilatero. Come posso fare perchè avvenga il
contrario?
Ringrazio in anticipo chiunque vorrà aiutarmi.
Ake 


Il C++ possiede una propria libreria di I/O, molto piů flessibile di quella del C.
Dovresti scrivere  std::cout << "L'area vale " << qd->area() << '\n';
Un consiglio:
Suppongo che tu intenda usare la classe quadrilatero solo come base comune per
derivare altre classi, come quadrato etc.
Un tipo di classe come questa si dice astratta, ed il C++ supporta
questo concetto tramite le funzioni virtuali pure.
Quindi:
class quadrilatero
{
   public:
      virtual int area() = 0;
};
In questo modo č piů coerente, in quanto come calcoleresti l'area per un quadrilatero
generico?
Classi che contengono funzioni virtuali pure non possono essere instanziate.
Quando derivi altre classi da quadrilatero devi specializzare la funzione area().
Il modo usuale di usare il polimorfismo č:
   quadrilatero* qdr =  new quadrato(7, 8);
   qdr->area();
   // ...
   delete qdr;
Spero di essere stato chiaro   Manlio Perillo

Allora, la soluzione non l'ho escogitata io, ma si trova su  "Thinking in
C++", cap. 15, quello sul polimorfismo.
Se lo hai scaricato puoi guardare con più calma quello che ti sto per dire.
In pratica devi fare uso della keyword virtual, cioè usare una virtual
function per forzare il compilatore ad ul Late-binding.... cioè ad una
associazione fatta run-time.
Se dichiari allora
int area (quadrilatero q) {.............};
come
virtual int area (quadrilatero q) {.............};
 ti dovrebbe funzionare.
Bye,
Sebastiano.

 Vi prego di dedicare la vostra attenzione a questo esempio.
Per fare prima, eccoti una versione migliorata e funzionante:
#include <iostream>
using namespace std;
class Quadrilatero
{
    public:
        Quadrilatero( int base, int altezza ): base( base ), altezza(
altezza ) {}
        virtual int Area() { cout << "Quadrilatero::Area()" << endl;
return base * altezza; }
    private:
        int base, altezza;
};
class Quadrato: public Quadrilatero
{
    public:
        Quadrato( int lato ): Quadrilatero( lato, lato ) {}
        int Area() { cout << "Quadrato::Area()" << endl; return
Quadrilatero::Area(); }
};
int main()
{
    Quadrilatero *p = new Quadrato( 100 );
    int area = p -> Area();
    delete p;
    cout << area << endl;
}
EMG

Spero di essere stato chiaro   
Direi chiarissimo. Grazie di tutto.