Sto provando a lavorare su un progetto che richiederà di determinare un tipo di oggetto polimorfico in fase di esecuzione, in modo che possa eseguire il cast. Un esempio di ciò che intendo:C++ Determina il tipo di un oggetto polimorfico in fase di esecuzione
class A{
};
class B: public A{
public:
void foo(){
printf("B::foo()\n");
}
};
tardi, avrò un gruppo di oggetti B che sono essenzialmente memorizzati come tale:
std::vector<A*> v;
v.push_back(new B());
E certamente necessario chiamare alcuni metodi di overload definite :
void bar(B* b){
b->foo();
}
Dopo passando oggetti memorizzati in v
. Il problema che sto avendo è che nel mio attuale caso d'uso, non so il tipo di B
a tempo di compilazione, quindi non posso chiamare bar
dicendo bar((B*)v.get(0));
La soluzione che ho pensato Potrei aver bisogno di determinare in qualche modo il tipo che ogni oggetto è in fase di runtime, in modo che possa lanciarlo prima di passarlo a bar
.
La soluzione che ho provato finora è stato quello di utilizzare decltype
, ma non ha funzionato per me perché solo restituisce il tipo statico del valore passato, non il tipo in fase di esecuzione.
Inoltre, non voglio utilizzare librerie di terze parti per questo progetto, poiché mi piacerebbe renderlo il più piccolo possibile.
Grazie per il vostro aiuto.
Edit:
Io non credo di essere stato abbastanza chiaro in quello che intendevo quando ho descritto il mio problema. Nel mio caso d'uso reale (che è un po 'lungo per provare a postare qui, anche se posso postarne alcune parti se necessario), sto provando a scrivere una libreria in cui c'è una classe base (qui rappresentata come A
) che può essere esteso dall'utente nelle proprie classi personalizzate (qui rappresentato come B
). Nel mio esempio, si suppone che B::foo()
rappresenti il modo in cui ciascuna sottoclasse di A
può avere i propri membri dati che vengono gestiti successivamente da un metodo (rappresentato nel mio esempio come bar
). Questo è anche il motivo per cui A
non può semplicemente avere un qualche metodo virtuale foo
.
Il problema principale che sto avendo è, dal momento che B
si suppone sia definito dall'utente, non so cosa sia in fase di compilazione, ma lo faccio al momento del collegamento (poiché il collegamento viene dopo). Questo è il motivo per cui l'uso di dynamic_cast
(come suggerito da Sam e Remy) non funzionerà, perché da quello che ho capito, richiede che io conosca tutte le possibilità di ciò che potrebbe essere B
, che io non conosco. Anche se sembrava molto vicino a quello che poteva funzionare per me. Se ci fosse un modo per ottenere tutte le sottoclassi possibili (ad esempio, con macro o modelli di preprocessore), penso che questo potrebbe essere in grado di funzionare.
Spero di averlo spiegato meglio questa volta. Grazie ancora per il tuo aiuto.
Edit 2: Un altro punto chiarifica: Nel progetto attuale sto lavorando, voglio solo che l'utente è tenuto a scrivere le proprie B
classi e sovraccarico bar
a lavorare con le loro classi personalizzate. Tuttavia, non desidero che all'utente venga richiesto di chiamare bar
. Piuttosto, mi piacerebbe avere bar
essere chiamato da una classe base (che io definisco).Questa è la ragione principale per cui provo a farlo anche nel modo in cui sono. Quello, e per vedere se posso.
La speranza che cancella tutto. Grazie ancora.
Eventuali duplicati di [Perché abbiamo bisogno di metodi virtuali in C++?] (Http://stackoverflow.com/questions/2391679/why-do-we-need-virtual-methods-in-c) –
Dalle tue modifiche, sembra che il modo corretto sia ancora membri 'virtuali' in' classe A', che forniscono pieno accesso ai membri dei dati per essere presenti in qualsiasi classe derivata. Tale accesso può includere informazioni sul tipo di runtime, ecc. – Walter