Newsgroup: it.comp.lang.c++
Titolo: variabili tipo

Che voi sappiate è possibile in C++ cattuarare un qualche valore da un tipo
( per esempio dal tipo int o da un tipo utente ) e poi utilizzare questo
valore per stanziare un dato di quel tipo....
mi spiego
se esiste una funzione del tipo
            METATIPO ptipo = cattura_tipo( int);
...   e quindi una funzione:
     crea_tipo( ptipo ) a;
    qui "a" verrebbe fuori come un int..
  Sapete se esiste qualcosa del genere nel C++ standard....??
grazie.
marcello

 Che voi sappiate č possibile in C++ cattuarare un qualche valore da un


 ha scritto nel messaggio
news:adqduu$1buli$1...@ID-114675.news.dfncis.de...


marcello wrote:

In C++ puoi utilizzare i template per avere una parametrizzazione rispetto 
ai tipi di dato, ma questi non ti consentono di "catturare" (non so se ho 
capito bene) un tipo di dato, ma di definire un tipo di dato (con una 
classe ad esempio) che utilizzi un tipo per i suoi campi che verrà 
specificato al momento dell'istanziazione di un'oggetto:
template <class Tipo>
struct mio_tipo {
Tipo campo1;
mio_tipo* next;
};  //per una lista ad es.
quando lo usi fai:
mio_tipo<int> tipo_intero;
mio_tipo<char> caratteri;
e via dicendo. Non so se fa al caso tuo.
S.

     qui "a" verrebbe fuori come un int..
da quello che dici non si riesce a capire se tu voglia sfruttare questa 
funzionalita` a compile-time o a run-time.
Nel primo caso non esiste una soluzione universale: sarebbe necessario 
utilizzare un ipotetico operatore typeof (che restituisce il tipo di una 
espressione - un po' come sizeof restituisce la dimensione del tipo di 
una espressione) che pero` non e` previsto dallo standard.
Per risolvere il tuo esempio e` cmq sufficiente un typedef:
        typedef int ptipo
        ...
        ptipo a; // a "viene fuori" come un int
Ovviamente questo approccio non e` applicabile a casi piu` complessi. In 
realta` esiste un modo per simulare in maniera piu` o meno buona 
l'operatore typeof: cerca in rete l'articolo "A Portable "typeof" 
Operator" di Bill Gibbons, apparso nel novembre 2000 sul C/C++ Users 
Journal.
Viceversa se ti interessa sfruttare un simile comportamento a run-time 
(un po' come il Class.forName di Java) possiamo riuscire a combinare 
qualcosa di buono; in questo caso pero` e` assolutamente necessario 
avere una classe base dalla quale derivano tutte le classi che vuoi 
clonare; ad esempio:
class Widget { ... };
class Button: public Widget { ... };
class TextBox: public Widget { ... };
In genere in questi casi si dichiara una funzione virtuale (magari pura) 
Clone in Widget e la si definisce opportunamente nelle classi derivate:
class Widget {
public:
        virtual Widget* Clone() =0;
        ...
};
class Button: public Widget {
public:
        Button* Clone() { return new Button; }
};
ecc...
Usandola poi in questo modo:
void foo(Widget* w)
{
        Widget* x = w->Clone(); // x e` dello stesso tipo di w
        ...
}
volendo si puo` anche disaccopiare ulteriormente la funzione Clone 
dall'oggetto Widget*, in modo da creare una specie di "metatipo" da 
usarsi in modo simile al tuo esempio.
ciao Anto
-- 
Antonio Cuni, 20 anni, studente
Brainbench C++ Master: 4.73, higher than 99% of all previous test takers.
C Language: 3.79, higher than 92% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it