C++ - Non mi è chiara una cosa sulle funzioni virtuali

[jewelz]

perchè questo codice

#include <iostream> 
using namespace std; 
 
class B { 
protected:    int b; 
public: 
    void f1() {cout << 'B' << endl;} 
} ; 
 
class D: public B { 
public: 
   virtual void f1(){ cout << 'D' << endl;} 
  
};

int main(){ 
    D* pd = new D; 
    pd->f1(); 
    system("PAUSE");
    return 0; 
 
}

mi dà D in uscita??? cioè se nella classe base ho una funzione non virtuale e nella derivata ho una ridefinizione della stessa però come virtuale, dato un puntatore del tipo della classe derivata, viene scelta quest'ultima dal compilatore? se sì, perchè???? scusate ma è da 2 mesi che imparo il c e sta cosa proprio non mi è chiara... quasi dimenticavo: grazie a chi sarà così gentile da rispondermi...

[kk3z]

#include <iostream> 
using namespace std; 
 
class B { 
protected:    int b; 
public: 
    virtual void f1() {cout << 'B' << endl;} 
} ; 
 
class D: public B { 
public: 
   virtual void f1(){ cout << 'D' << endl;} 
  
};

int main(){ 
    B* pd = new D; 
    pd->f1(); 
    system("PAUSE");
    return 0; 
 
}

(come sempre se mi ricordo bene ):

1) la parola virtual deve essere usata nella classe base! Nella classe derivata puoi anche ometterla.
2) Perchè tutto l'ambaradan funzioni devi usare un puntatore o riferimento alla classe derivata e "memorizzarla" in un puntatore o riferimento della classe base:

B* pd = new D;

stamattina le parole proprio non mi vengono spero di non aver detto castronerie

[BountyKiller]

stampa D perchè stai chiamando un metodo della classe D che stampa appunto D ; oltretutto la funzione virtuale in classe derivata potrebbe anche starci, ma così facendo stai impicitamente affermando che esistono (o esisteranno) altra classi che derivano da D e che specializzeranno il comportamento della funzione f1: in ogni caso anche se D fosse una classe base epr altre classi le funzioni virtuali non vengono generalmente implementate in classe base (nel senso che non fanno nulla).
sono stato chiaro?

[jappilas]

Originariamente inviato da jewelz

perchè questo codice

....

mi dà D in uscita??? cioè se nella classe base ho una funzione non virtuale e nella derivata ho una ridefinizione della stessa però come virtuale, dato un puntatore del tipo della classe derivata, viene scelta quest'ultima dal compilatore? se sì, perchè???? scusate ma è da 2 mesi che imparo il c e sta cosa proprio non mi è chiara... quasi dimenticavo: grazie a chi sarà così gentile da rispondermi...

è giusto, il tuo codice istanzia un' oggetto di tipo D e chiama il metodo f1() implementato in D
dichiarare il metodo nella classe D (la tua derivata) come virtual, non informa il compilatore che ne esiste un' altra implementazione nella classe da cui D deriva, e di usare quella
lo informa che la classe D verrà molto probabilmente ereditata a sua volta in una terza classe, molto probabilmente dotata di una propria (re)implementazione di f1() che offuscherà (si parla di override) quella presente in D

in effetti, anche se avessi usato la stesura (corretta ) suggerita da kk3z avrest ottenuto in uscita D, perchè la classe istanziata è quella derivata e perchè l' implementazione del metodo nella classe derivata offusca quella nella classe base

EDIT: ho notato dopo che BountyKiller si è spiegato in termini più chiari di me

forse ai fini dell' assimilazione del polimorfismo si potrebbe scrivere un esempio leggermente migliore

#include <iostream> 
using namespace std; 
 
class B { 
protected:    int b; 
public: 
    virtual void f1(); 
} ; 
 
class D1: public B { 
public: 
   virtual void f1(){ cout << 'D1' << endl;} 
  
}; 

class D2: public B { 
public: 
   virtual void f1();{ cout << 'D2' << endl;} 
  
};

int main(){ 
    B* pd1 = new D1; 
    B* pd2 = new D2; 
    pd1->f1(); 
    pd2->f1(); 
    system("PAUSE");
    return 0;  
}

[vizzz]

aggiugo a scopo didattico che se dichiari:

class B { 
protected:    int b; 
public: 
    virtual void f1() = 0; 
} ;

dichiari una funzione virtuale pura, forzi la classe derivata a implemetare la funzione virtuale, utile ogni tanto per evitare errori imho.

[jewelz]

grazie mille, siete stati molto esaurienti, però vorrei capire un'ultima cosa: nel caso che dico io la funzione viene scelta a tempo di compilazione? insomma al compilatore non gliene frega nulla che sia virtuale o no, prende la classe D nella quale la funzione f1 della classe derivata "sovrascrive" quella della classe base e tranquillamente esegue senza vtable e roba del genere, giusto? Insomma i vantaggi concreti delle virtuali sono che posso usare un puntatore del tipo della classe base inizializzato con classi derivate per richiamare funzioni delle classi derivate, per il resto non cambia nulla...
a proposito, jappilas, il codice tuo non va perchè la funz nella classe base o la definisci o la metti virtuale pura (vero vizzz?).

[vizzz]

Originariamente inviato da jewelz

a proposito, jappilas, il codice tuo non va perchè la funz nella classe base o la definisci o la metti virtuale pura (vero vizzz?).

esatto, altrimenti il linker si incazza

[jappilas]

Originariamente inviato da jewelz

grazie mille, siete stati molto esaurienti, però vorrei capire un'ultima cosa: nel caso che dico io la funzione viene scelta a tempo di compilazione? insomma al compilatore non gliene frega nulla che sia virtuale o no, prende la classe D nella quale la funzione f1 della classe derivata "sovrascrive" quella della classe base e tranquillamente esegue senza vtable e roba del genere, giusto?

Generalmente, i compilatori cercano di non utilizzare la vtable se una chiamata a metodo può essere risolta e disambiguata in fase di compilazione (come può accadere se -ad esempio - nella gerarchia delle classi non esiste nessuna sottoclasse che ridefinisce metodi virtuali della classe base, o se l' oggetto in uso può con certezza essere ricondotto a una classe che non ridefinisce metodi virtuali della classe base )
In questo caso è possibile che il compilatore abbia bisogno sia del lookup alla vtable, sia del cosiddetto fixup del puntatore this

Insomma i vantaggi concreti delle virtuali sono che posso usare un puntatore del tipo della classe base inizializzato con classi derivate per richiamare funzioni delle classi derivate, per il resto non cambia nulla...

piccola precisazione: funzioni ereditate virtuali e definite o ridefinite nelle derivate (tieni conto che subclassare, cioè ereditare, da una classe base, serve per specificizzarla e/o estenderla, quindi la derivata può contenere, e spesso accadrà, metodi propri non dichiarati dalla classe base, che quindi non sono accessibili referenziando quest' ultima)
comunque sì, è il polimorfismo ed è una delle caratteristiche fondanti della programmazione object oriented (per come mi fu insegnata almeno)

a proposito, jappilas, il codice tuo non va perchè la funz nella classe base o la definisci o la metti virtuale pura (vero vizzz?).

esattamente,
l' idea era di ottenere un esempio leggermente migliore sull' ereditarietà modificando poco il codice originale (tuo) ... e spronarti alla ricerca degli errori, ma vedo che hai già risposto

[jewelz]

grazie, scusa per il ritardo della risposta ma ero impegnato con gli esami... che sono andati bene grazie anche a questo chiarimento...