Newsgroup: it.comp.lang.c++
Titolo: Problema con virtual

Il mio dubbio:
Da una classe A ne ho derivata un'altra B.
I metodi di A che intendevo ridefinire in B li ho indicati come VIRTUAL nei
loro protipi.
Dalla classe B voglio derivarne un'altra ancora C, che a sua volta
ridefinisce alcuni metodi di B.
Devo ancora usare la parola VIRTUAL nelle dichiarazioni dei metodi di B
oppure no?
(Oppure e' lo stesso come penso?)
Ringrazio chiunque mi rispondera'
Valerio

(Oppure e' lo stesso come penso?)
Non e' lo stesso. La parola chiave "virtual" non serve per indicare
quali metodi saranno ridefinibili, ma solo per indicare quali di essi
saranno dipendenti *solo* dalla classe derivata.
C'e' differenza tra scrivere (perdonerai la sintassi legata al C++
Builder) :
class A
{
      public:
      void metodo() ;
} ;
void A::metodo()
{
     ShowMessage( "Sono il metodo di A" ) ;
}
class B : public A
{
      public:
      void metodo() ;
} ;
void B::metodo()
{
     ShowMessage( "Sono il metodo di B" ) ;
}
void funzione( A* pClasse )
{
     pClasse->metodo() ;
}
void __fastcall TForm1::Button1Click(TObject *Sender)
{
     A* ptrMadre = new A ;
     B* ptrFiglia = new B ;
     funzione( ptrMadre ) ;
     funzione( ptrFiglia ) ;
}
e invece :
class A
{
      public:
      virtual void metodo() ;
} ;
void A::metodo()
{
     ShowMessage( "Sono il metodo di A" ) ;
}
class B : public A
{
      public:
      void metodo() ;
} ;
void B::metodo()
{
     ShowMessage( "Sono il metodo di B" ) ;
}
void funzione( A* pClasse )
{
     pClasse->metodo() ;
}
void __fastcall TForm1::Button1Click(TObject *Sender)
{
     A* ptrMadre = new A ;
     B* ptrFiglia = new B ;
     funzione( ptrMadre ) ;
     funzione( ptrFiglia ) ;
}
Perche' nel secondo caso stai consentendo a B di slegarsi dalla classe
madre e di assumere un comportamento proprio.
--
Andrea Laforgia (UIN 87230455)
----------------------------------------------------------
Non scrivetemi per e-mail, se non richiesto espressamente.
No replies in private e-mail, unless explicitly requested.
----------------------------------------------------------

 (Oppure e' lo stesso come penso?)
E' lo stesso.
EMG

 Non e' lo stesso.
Invece, come dimostra il seguente esempio, č lo stesso:
#include <iostream>
using namespace std;
class A
{
    public:
        virtual UnMetodo() { cout << "A::UnMetodo()" << endl; }
};
class B: public A
{
    public:
        UnMetodo() { cout << "B::UnMetodo()" << endl; }
};
class C: public B
{
    public:
        UnMetodo() { cout << "C::UnMetodo()" << endl; }
};
int main()
{
    A *a = new A;
    A *b = new B;
    A *c = new C;
    a -> UnMetodo();
    b -> UnMetodo();
    c -> UnMetodo();
}
Non c'č quindi bisogno di ripetere la keyword virtual anche nei metodi
di B.
EMG

Invece, come dimostra il seguente esempio, č lo stesso:
Hai ragione, per quanto riguarda le tre classi in gerarchia.
Io mi ero fermato al caso di due classi soltanto.



Non c'entra il numero di classi in gerarchia.
Una volta dichiarato virtuale in una base class, il metodo e' virtuale
in tutte le classi derivate.

in tutte le classi derivate.
Si, d'accordo, ma io avevo inteso un'altro senso e cioe' la differenza
tra un metodo dichiarato "virtual" ed uno non "virtual".


[CUT]
Manlio Perillo

 Ho inserito anche -wall
Anch'io, eppure quel warning non me lo dà... ???
EMG

 Con il BCC 5.5 ottengo il Warning: "Missing return statement"
Strano. Anch'io uso il BCC 5.5 eppure non mi dava alcun warning
(altrimenti me ne sarei accorto). Mi dici come hai impostato gli switch
di compilazione nel BCC32.CFG?
EMG


Ho inserito anche -wall
Manlio Perillo