Newsgroup: it.comp.lang.c++
Titolo: Programmazione ad oggetti...

Vorrei un parere sui seguenti concetti:
Un oggetto è l'insieme di dati+metodi che agiscono sui dati stessi;
Un oggetto è caratterizzato da 4 attributi fondamentali:
Incapsulamento(information hiding): possibilità di nascondere all'esterno
quello che viene fatto internamente(dati+metodi), rendendo pubbliche solo le
interfacce con l'utente(menu, risultati, ecc..);
Ereditarietà: possibilità di avere un oggetto, con determinate
caratteristiche, e più oggetti suoi "parenti", aventi le stesse
caratteristiche del padre più la possibilità di definirne
altre(specializzazione);
Polimorfismo: possibilità di implementare lo stesso metodo in modo
differente a seconda delle esigenze; Es: il perimetro del quadrato è diverso
dal perimetro del cerchio, ma sempre perimetro è.
Comunicazione tra oggetti: scambi di messaggi e informazioni fra i vari
oggetti di un programma, che portano alla risoluzione del
problema(iterazione continua fra oggetti).
L'oggetto non è altro che un RECORD, ma contiene anche i metodi(procedure)
che possono agire su tale record.
CLASSE: insieme di oggetti aventi comportamenti e struttura comuni;
ISTANZA: oggetto appartenente ad una determinata classe;
CLASSE e ISTANZA possono essere paragonati a TIPO e VARIABILE visti nel
linguaggio pascal, anche se con alcune differenze(presenza dei metodi,
scambio di messaggi, ecc...).
L'ereditarietà può essere:
SINGOLA: se una classe eredita solamente da un'altra classe;
MULTIPLA: se una classe eredita da più classi contemporaneamente.
COSTRUTTORE: metodo(procedura specializzata ed automatica) interno ad una
classe che viene attivato per creare un oggetto appartenente a quella
determinata classe.
DISTRUTTORE: metodo che serve per rimuovere definitivamente un oggetto.
Per COSTRUTTORE e DISTRUTTORE possiamo pensare alle finestre di Windows
(apri-chiudi).
MESSAGGIO: richiesta inviata ad un oggetto per attivare uno dei metodi che
tale oggetto consente.
BINDING: accesso alla classe destinataria del messaggio e relativa
attivazione del metodo da utilizzare;
BINDING STATICO: sviluppo del codice in fase di compilazione;
BINDING DINAMICO: sviluppo del codice in fase di esecuzione.
Se trovate qualcosa di inesatto o sbagliato rispondetemi, per favore.
Federico.

BINDING DINAMICO: sviluppo del codice in fase di esecuzione.
ok


 ok
Non mi sembra molto chiaro. Binding dinamico non è quello dei metodi
virtuali?
EMG

virtuali?
Non credo. I metodi virtuali sono risolti in fase di compilazione nel senso
che il compilatore e' in grado di "compilare" la tabella dei metodi virtuali
associata alla classe di appartenenza dell'oggetto. Quando un metodo
virtuale e' invocato il compilatore non fa altro che accedere alla tabella,
prelevare l'indirizzo della funzione e chiamarla. E' un semplice
indirizzamento indiretto.
Il binding dinamico invece dovrebbe essere il meccanismo di utilizzo di
classi e oggetti run time la cui descrizione non e' nota durante la
compilazione. Generalmente questo meccanismo e' utilizzato dai linguaggi
interpretati ma probabilmente per COM si potrebbe parlare di binding
dinamico.
Antonio Donatiello


fatto!
Saluti,
Paolo
----------------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
----------------------------------------------------------


Infatti...



Il binding dinamico non e` una caratteristica dei soli linguaggi interpretati,
il linguaggio puo` essere compilato, ma le chiamate potrebbero essere benissimo risolte a
run time. D'altronde e` cio` che succede con le dll (mi sembra)...
Saluti,


run time. D'altronde e` cio` che succede con le dll (mi sembra)...
Infatti le DLL sono Dynamic...
Ciao
Antonio Donatiello

 dinamico.
Sei sicuro? Qualcun'altro può confermare o contraddire questa
affermazione?
EMG

 run time. D'altronde e` cio` che succede con le dll (mi sembra)...
Esatto. Vedi le API di Windows LoadLibrary(), GetProcAddress() e
FreeLibrary(). Pių run-time di cosė...
EMG

 Collegamento ai membri dell'oggetto!
Così mi sembra decisamente meglio.
EMG

 elemento della tabella;
Considera un esempio di questo tipo:
#include <iostream>
class A
{
    public:
        virtual void metodo() { cout << "metodo di A" << endl; }
};
class B: public A
{
    public:
        virtual void metodo() { cout << "metodo di B" << endl; }
};
int main()
{
    A *a = new A;
    A *b = new B;
    a -> metodo();
    b -> metodo();
    return 0;
}
Il risultato č
metodo di A
metodo di B
Per binding dinamico si intende, appunto, che l'effettivo metodo
chiamato (se quello di A o quello di B) in seguito alla chiamata
b -> metodo();
dipende dal contenuto di b il quale č noto solo in run-time.
EMG


Non conosco COM, quindi non posso dire nulla in merito. Comunque non
escludo (anzi...) che ci possano essere modelli OOP alternativi anche diversi da
quelli esposti da me e te
D'altrode il dibattito su ereditarieta` di implementazione, delegation e
ereditarieta` di interfaccia e` gia` sufficiente a dire che proposte alternative
piu` o meno valide e con vantaggi e svantaggi differenti non mancano.
Oltretutto per il poco che so di COM, mi sembra che si tratti di un modello
alternativo che ad esempio sostituisce in toto l'ereditarieta` con la
composizione... Si tratta comunque di modelli alternativi a quello fornito
dal C++
Saluti,
Paolo
P.s.
   Ho notato il xpost su it.com.lang.pascal; siccome questo linguaggio non e` OO ho
   pensato che questa discussione fosse totalmento OT su quel gruppo.
   Ho comunque deciso di postarlo anche li, ma impostando il follow-up su
   it.comp.lang.c++. Chi di quel NG fosse interessato a seguire tale discussione
   e` invitato a parteciparvi sul NG del C++...


 BINDING DINAMICO: sviluppo del codice in fase di esecuzione.
Piu` che di accesso, si puo` parlare di *collegamento*.
Per binding dinamico, nel contesto specifico, si intende il meccanismo dei
metodi virtuali, ossia il modo in cui viene normalmente ottenuto il
polimorfismo: il metodo effettivamente chiamato non e` stabilito a priori, in
fase di compilazione, ma al momento dell'esecuzione, perche` solo allora e` noto
il tipo effettivo (classe) dell'oggetto.
Saluti
Paolo