Ottenere tipo di variabile

Question

Se ho capito bene, typeid in grado di determinare il tipo effettivo di polimorfismo, mentre typeof non possono.

E 'anche vero che i loro rendimenti sono utilizzati per scopi diversi: il ritorno di typeof viene utilizzato come tipo di parola chiave che può definire variabili, ma il ritorno di typeid non possono

?

C'è un modo per ottenere sia il tipo effettivo per il polimorfismo e utilizzare il ritorno come tipo di parola chiave per definire un'altra variabile? Spero di ottenere il tipo di classe derivata da un puntatore che punta alla classe di base e definire una variabile o un puntatore alla classe derivata. Qualcosa di simile:

baseclass *p = new derivedclass  
typexxx(*p) *pp = dynamic_cast<typexxx(*p) *> (p); 
// would like to convert the pointer from pointing to a base class 
// to its derived class

Grazie mille!

Answer 1

C ++ 0x avrà decltype che può essere utilizzato come questo :

int someInt;
decltype(someInt) otherIntegerVariable = 5;

ma per semplice vecchia C ++, purtroppo, no.

Suppongo che decltype non sarà davvero di grande aiuto sia però dato che si desidera che il tipo polimorfico, non il tipo dichiarato. La via da seguire più direttamente a fare quello che vuoi è quello di tentare di fusione dinamica per un tipo particolare, e verificare la presenza di NULL.

struct A {
    virtual ~A() {}
};
struct B : public A {};
struct C : public A {};

int main() {
    A* x = new C;
    if(B* b_ptr = dynamic_cast<B*>(x)) {
        // it's a B
    } else if(C* c_ptr = dynamic_cast<C*>(x)) {
        // it's a C
    }
}

Answer 2

Supponendo una gerarchia A <- B <- C

A * p = new AorBorC;   // create new object of some sort

if ( dynamic_cast <C*>(p) ) {
  C * c = dynamic_cast <C*>(p);
  c->CFunc();
}
else if ( dynamic_cast <B*>(p) ) {
  B * b = dynamic_cast <B*>(p);
  b->BFunc();
}
else if ( dynamic_cast <A*>(p) ) {
  A * a = dynamic_cast <A*>(p);
  a->AFunc();
}

Dove AFunc, BFunc, CFunc sono specifiche per le rispettive classi, e non virtuale. Ovviamente, questo può essere ottimizzato piuttosto.