Newsgroup: it.comp.lang.c++
Titolo: Crpt

Salve,
ho trovato questo esempio sul crpt, ma non ho capito quale possa essere 
l'effettivo vantaggio rispetto all'uso del polimorfismo classico. Forse 
quello di non dover necessariamente fare uso di puntatori dato che il tipo 
effettivo viene rilevato nel metodo interface della classe base?
Per quanto riguarda il metodo static, invece che ricorrere a questo pattern, 
non sarebbe sufficiente chiamare tutti i metodi allo stesso modo e poi 
invocarli come si fa al solito? In fondo il crpt  sembra faccia proprio 
questo.
#include <iostream>
template <class T> struct Base {
    void interface() {
        static_cast<T*>(this)->implementation();
    }
    static void static_func() {
        T::static_sub_func();
    }
};
struct Derivata : Base<Derivata> {
    void implementation() {
         std::cout << "Derivata" << std::endl;
    }
    static void static_sub_func() {
         std::cout << "Derivata_func" << std::endl;
    }
};
struct Derivata2 : Base<Derivata2> {
    void implementation() {
         std::cout << "Derivata2" << std::endl;
    }
    static void static_sub_func() {
         std::cout << "Derivata2_sub" << std::endl;
    }
};
// Forse sbaglio ad usare le istruzioni che evidenziano i vantaggi di questo 
pattern. Tra le seguenti righe quali sarebbero quelle giuste in tal senso?
int main() {
    Base <Derivata> b;
    Base <Derivata2> b2;
    b.interface();
    b2.interface();
    Base<Derivata>::static_func();
    Base<Derivata2>::static_func();
    Derivata d;
    Derivata2 d2;
    d.interface();
    d2.interface();
    Derivata::static_func();
    Derivata2::static_func();
    return 0;
}
Saluti 

 questo.
Che dire ... Alquanto crpt-ico! :)
Se cerco con Google "crpt" insieme a "pattern", non trovo proprio niente 
di appropriato!
Probabilmente intendevi il "Curiously Recurring Template Pattern", che 
tuttavia si abbrevia "CRTP", anche non nuoce citarlo per esteso almeno 
una volta.
Ma l'esempio che hai trovato non aggiunge una riga di commento e 
soprattutto una riga di codice di utilizzo delle classi definite? In tal 
caso faresti bene a cercare altrove.
Per esempio, avevo scritto il seguente testo:
http://it.wikibooks.org/wiki/Ottimizzare_C%2B%2B/Ottimizzazione_del_codice_C%2B%2B/Numero_di_istruzioni#Il_Curiously_Recurring_Template_Pattern
-- 
Carlo Milanesi
http://digilander.libero.it/carlmila

 
http://it.wikibooks.org/wiki/Ottimizzare_C%2B%2B/Ottimizzazione_del_codice_C%2B%2B/Numero_di_istruzioni#Il_Curiously_Recurring_Template_Pattern
Quindi a quanto pare il vantaggio fondamentale � quello di poter 
implementare un polimorfismo che non fa uso di metodi virtuali espandibili 
inline.
Saluti 

 inline.
Dato che il polimorfismo statico rende il codice nettamente meno 
flessibile e meno comprensibile e solo leggermente piu' efficiente, 
ritengo che tale tecnica debba essere usata solamente in fase di 
ottimizzazione della propria applicazione, oppure nello sviluppo di 
librerie di codice, per le quali si vogliono sempre offrire le massime 
prestazioni ai potenziali utilizzatori.


 prestazioni ai potenziali utilizzatori.
Infatti, il codice sembra molto meno chiaro rispetto a quando si fa uso del
polimorfismo. Anzi, in generale quando entrano in gioco i template, il
codice si offusca sempre un po'.
Piccola digressione: ho dato un'occhata alle innovazioni del C++0x e ho
l'impressione che la sintassi stia diventando sempre meno chiara. Ho aperto
un nuovo thread in merito.
Ciao