Newsgroup: it.comp.lang.c++
Titolo: Alternative alla RTTI

Ciao a tutti!
Provengo da Java, linguaggio in cui è sempre attivo il corrispondente della RTTI del C++.
In C++ questa feature è disabilitabile (fortunatamente) a causa dell'overhead che impone.
RTTI resta, tuttavia, uno strumento potente che se ben usato rende, IMHO, il codice più chiaro.
 
In un contesto in cui l'overhead di RTTI non sia tollerabile ma tuttavia si voglia poter disporre di
operatori che (almeno) permettano di determinare la classe di un'istanza e se tale classe e
sottoclasse di un'altra classe, voi cosa consigliate?
Una prima cosa che ho pensato è poter compilare le parti del progetto più critiche con la RTTI
disabilitata, mentre quelle più ad alto livello con la RTTI abilitata. E' possibile ?
Esistono sostituti alla RTTI standard di C++ che siano ottimizzati per le prestazioni magari a
scapito di qualche capacità tipo il cross-casting ?
Vorrei evitare soluzioni ad hoc classe per classe tipo 
A::SubClassesIDEnum A::GetClassID() {...}
Ringrazio in anticipo per ogni risposta o anche semplici link a documentazione!
#######################################################################
email:     remove "NoNoNo"
           rimuovi "NoNoNo"
#######################################################################

 cross-casting ?
non so se ho capito bene, stai cercando un sostituto al 
forName/newInstance di java?
se cosi' fosse, lo puoi trovare sul nr. 2 di C++ informer di Carlo 
Pescio.
se invece vuoi utilizzare gli operatori di cast, devi usare la RTTI 
standard, a meno di non possedere un compilatore che separa il casting 
dalla RTTI e ti permetta di ridefinire le regole di quest'ultima. ma 
non credo esistano...

Se ho capito bene cerchi un meccanismo di RTTI con un nome diverso e con
prestazioni diverse... Questo mi ricorda la storia a proposito di alcuni
esperti che ritenevano che l'Iliade e l'Odissea non fossero state
scritte da Omero, bensi' da un altro greco vissuto nello stesso periodo
e che portava lo stesso nome...
Il punto fondamentale e' questo: se *davvero* devi risalire al tipo
effettivo di un oggetto a runtime, non puoi che usare RTTI. D'altra
parte moltissimi dei casi in cui in Java sei costretto ad (ab)usare
(del)l'RTTI, sono di fatto risolvibili a compile time, ed in C++ si
possono esprimere in modo decisamente piu' efficiente per mezzo di
template.
Ciao,
Nicola

RTTI resta, tuttavia, uno strumento potente che se ben usato rende, IMHO, il codice più chiaro.
personalmente credo che in C++ siano pochi i casi in cui è realmente
necessaria la RTTI: probabilmente sei ancora portato a mensare in modo
Java, dove spesso non c'è altra possibilità. Ma in C++ se fai un
design più accurato dovresti riuscire a cavartela anche con le sole
funzioni virtuali e polimorfismo.
Anto
--
Antonio Cuni, 18 anni, studente
Brainbench Certification: 
Master C++: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
http://www.brainbench.com/transcript.jsp?pid=1301688

 funzioni virtuali e polimorfismo.
Purtroppo questo approccio porta, troppo spesso, a sacrificare altre
caratteristiche del codice, importantissime soprattutto per grandi
sistemi; la piu` importante e` il _controllo delle dipendenze_ fra
sottosistemi.
Ti raccomando tutto quello che ha mai scritto Robert Martin, editor
del C++ Report, il cui sito, a 
www.objectmentor.com
, e` davvero
eccellente.  In particolare, suggerisco di analizzare la Design Pattern
da lui proposta, Acyclic Visitor, che modifica la classica Visitor della
Gang of 4 per eliminare l'orrendo grafo di dipendenze tipico appunto
di Visitor... dipendenze cicliche fra classi base e derivate, il bacio
della morte in qualsiasi sistema di grandi dimensioni (e spesso
anche in sistemi non tanto grossi!).
Acyclic Visitor e` un ottimo esempio di uso irrinunciabile di
dynamic_cast<> (certo l'aspetto di gran lunga piu` usato di
tutta l'RTTI!-).
E` inoltre importante capire che quello che, in C++, permette
non di rado di evitare dynamic_cast (benche` restino _non
pochi_ i casi in cui l'RTTI e` veramente indispensabile, anche
col design piu` accurato:-) e` il generic programming, ovvero
i template.  In particolare, la "Pattern Without a Name" di
Coplien, nella forma primaria:
template <class Base>
class Derivata: public Base {
    // ecc ecc
};
e nella forma duale, di uso non meno importante:
template <class Derivata>
class Base: {
    // ecc ecc
};
ove l'uso tipico e` poi
class Derivata: public Base<Derivata> {
    // ecc ecc
};
Queste "Curiously Recurring Template Patterns", identificate
da Coplien nella prima meta` degli anni '80, permettono, in
svariati casi, di ottenere un riuso/condivisione di codice
_senza_ introdurre "male dipendenze" (e, in particolare,
dipendenze cicliche).  Ad esempio, la prima forma (piu`
semplice, anche se di uso forse piu` raro) permette di
evitare la dipendenza Derivata -> Base, altrimenti del tutto
connaturata al concetto di eredita`, quando e` applicabile.
Alex (MVP di Brainbench per il C++)

col design piu` accurato:-) e` il generic programming, ovvero
mi puoi fare qualche esempio di casi in cui l'RTTI è indispensabile?


 da Coplien 
solo una curiosita': pattern e' femminile in inglese?

 wrote in message news:3120238.g...@tin.it...

hmmm. L'inglese ha il neutro per tutto cio' che non e' umano (o umanizzato, tipo
animale domestico).
--
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

 mi puoi fare qualche esempio di casi in cui l'RTTI è indispensabile?
Rileggiti il post e dai un'occhiata all'Aciclic Visitor, che e' una delle
varianti piu' conosciute del visitor della GoF di Vlissides et Al.
L'uso di RTTI e' indispensabile per ottenere il "disaccoppiamento" fra le classi
(vedi lo scopo del pattern).
Acyclic Visitor lo trovi anche su "Pattern Languages of Program Design 3",
Addison Wesley. Il terzo di una lunga sequenza di volumi che "continuano" il
discorso sui pattern aperto dalla GoF.


eccellente.  In particolare, suggerisco di analizzare la Design Pattern
Ti ringrazio Alex per il sito, ho iniziato a leggere qualcosina e la qualità
mi sembra notevole.
Grazie ancora.


Dopo un po di ragionamento e di ricerche non è stato difficile scrivere una RTTI custom che
implementasse gli operatori IsA, IsKindOf e il dinamic_cast.
Ringrazio tutti quelli che hanno risposto + o - in merito alla mia domanda.
