Newsgroup: it.comp.lang.c++
Titolo: funzioni virtuali e virtuali pure, che differenza?

che differenza c'è tra
class TUno {
public:
	virtual Due();
};
e
class TUno {
public:
	virtual Due() = 0;
};
per quanto ricordo una funzione virtuale non è definita nella classe,
ma la si definisce nelle classi che derivano da questa... qual è
dunque la differenza?
]\/[ad]\/[age
"Un Maestro nell'arte della vita, non fa nessuna precisa distinzione tra lavoro
e gioco, fatica e riposo, mente e corpo, educazione e ricreazione. 
Insegue semplicemente la sua visione di Eccellenza attraverso qualunque cosa sta facendo e lascia agli altri decidere se sta lavorando o giocando. A lui sembra sempre che sta facendo entrambe le cose." - Anonimo.
.-~-.-~-. 
www.madmagelab.cjb.net
 .-~-.-~-.

ma la si definisce nelle classi che derivano da questa...
Questa che citi e' la virtuale pura.
Le funzioni virtuali normali possono essere definite anche
nella classe base.
-- 
The Follet


Considera questo esempio:
struct Interface
{
   virtual int function() = 0;
};
inline int Interface::function() { return 5; }
struct Implementation: public Interface
{
   int function() { return Interface::function() + 1; }
};
#include <iostream>
int main()
{
   Interface* i = new Implementation();
   std::cout << i->function() << '\n';
   Interface k;
}
Una funzione virtuale pura può essere definita.
Quello che comporta l'uso di funzioni virtuali pure
è che la classe che le contiene diventa un'interfaccia.
Ossia tale classe non può essere instanziata, ma serve
solo da interfaccia per le altre classi che derivano
da essa.
Saluti  Manlio Perillo

 Questa che citi e' la virtuale pura.
Le funzioni virtuali pure si possono anche implementare.
Se una classe contiene una funzione virtuale pura (implementata
o meno) non puo essere istanziata.
Ciao
Gaetano.
-- 
Posted from 
dell-01.mm.eutelsat.org
 [194.214.173.17] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 };
La presenza di una o piů funzioni virtuali pure rendono la classe
astratta (ovvero non istanziabile), ed anche le classi derivate da essa
se non ridefiniscono tali funzioni diventano astratte.
Il Ghenio
-----
ZIO : Fun and games are over with. Anyone who dares
get in my way shall perish.
DIO ci salvi dagli ocx del Viral Basic.
-----

o meno) non puo essere istanziata.
a che pro implementare una funzione che non potrà mai essere usata?


allora, vediamo se ho capito:
se in una classe ci metto una funzione virtuale pura non posso
istanziare la classe e quando faccio la sottoclasse DEVO definire
quella funzione, altrimenti non posso istanziare manco la sottoclasse
(perň la sottoclasse puň usare un eventuale implementazione contenuta
nella classe padre)
se in una classe ci metto una funzione virtuale e basta?


a che pro implementare una funzione che non potrà mai essere usata?
Può essere richiamata da una classe derivata.
-- 
Marco Barisione (ICQ 84277092)
Su it.news.gruppi si sta discutendo della creazione di it.comp.lang
dove si parlerà dei linguaggi senza un proprio newsgroup e dei
confronti fra i diversi linguaggi.
Se sei interessato unisciti alla discussione.

se in una classe ci metto una funzione virtuale e basta?
Puoi istanziarla perché non è astratta.


Puoi istanziarla perché non è astratta.
e quella funzione la posso implementare?


e quella funzione la posso implementare?
La *devi* implementare


>La *devi* implementare
e quindi che differenza c'è con una funzione non virtuale?



Puo essere chiamata esplicitamente dalle derivate:
class X
{
    ....
    virtual void foo() const = 0;
};
void X::foo() {}
class Y : public X
{
...
    virtual void foo() const {
        .....
        (void)X::foo();
        .....
    }
};


 e quella funzione la posso implementare?
Se non la implementi il linker si arrabbia



Il fatto che una funzione sia virtuale non vuol dire
che devi o meno implementarla.
Il virtual e' solo il meccanismo che ha il C++ per il supporto
del dynamic binding.


 e quindi che differenza c'č con una funzione non virtuale?
Il binding dinamico.
Ricapitolando:
Metodo statico. Devi implementarlo. Binding statico. Mancanza di this.
Metodo normale. Devi implementarlo. Binding statico.
Metodo virtuale. Devi implementarlo. Binding dinamico.
Metodo puro. Puoi implementarlo omeno. Binding dinamico. La classe č
astratta (e anche le derivate se non ridefiniscono il metodo).
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

scusate la mia insistenza, ma con le funzioni virtuali c'ho sempre
litigato... :-D
allora
IMPLEMENTAZIONE
funzione non virtuale: la DEVO implementare
funzione virtuale: la POSSO implementare, ma se la implemento la posso
utilizzare solo dalle classi figlie (o anche dalla classe stessa?)
funzione virtuale pura: come sopra
ISTANZIAZIONE
classe con funzioni virtuali: la posso istanziare
classe con funzioni virtuali pure: non la posso istanziare
DYNAMIC BINDING
funzione non virtuale: viene bindata la funzione relativa alla classe
(se ho un puntatore a Pippo viene chiamata la fuzione di Pippo, anche
se l'oggetto è realmente Pluto, che è classe derivata di Pippo)
funzione virtuale: viene bindata la funzione della classe vera
(nell'esempio precedente viene chiamata la funzione di Pluto)
ci siamo? ci sono altre differenze?
arigrazzie ancora ;-D


 (nell'esempio precedente viene chiamata la funzione di Pluto)
Yep (a meno che appunto non espliciti la chiamata all'implementazione
della base con ::).


sembra che ce l'ho fatta... finalmente ho capito le funzioni
virtuali... WOW!! :-D


 altrimenti, essendo virtuale, finisci con il chiamare il suo override).
Si puo chiamare esplicitamente "da dove vuoi " ?
Non solo dalle classi derivate? Come fai altrimenti a chiamarla
esplicitamente dall'esterno se non e' statica?


 esplicitamente dall'esterno se non e' statica?
Cosa c'entrano adesso le statiche?
#include <iostream>
struct B {
    virtual char foo()=0;
};
struct D: public B {
    virtual char foo();
};
char B::foo() { return 'B'; }
char D::foo() { return 'D'; }
int main()
{
    D d;
    std::cout << d.foo() << d.B::foo() << std::endl;
}
l'output è "DB".
