Come posso passare "Qualsiasi tipo di dati" a una funzione in C++

Question

Diciamo che ho un gestore di classe con alcune sottoclassi come lo Stringhandler, SomeTypeHandler, AnotherTypeHandler. Il class handler definisce un metodo "handle" come un'interfaccia comune per tutte le sottoclassi. La logica di "gestire" è naturalmente completamente diversa per i diversi gestori.

Quindi quello che devo fare è passare un valore di qualsiasi cosa al metodo handle. Le classi specifiche possono quindi trasmettere il "qualcosa" al tipo che si aspettano.

Fondamentalmente quello che serve è qualcosa di simile alla classe Object Java: D

La prima cosa che ho provato è stato un void*, ma a quanto pare non si può fare B* someB = dynamic_cast<B*>(theVoidPointer), quindi senza fortuna lì.

La mia seconda idea era usare boost::any. tuttavia, il requisito per utilizzare boost :: any è che il valore deve essere cunstructable, che non è il caso dei miei dati.

Qualche idea per far funzionare tutto questo?

Grazie

EDIT: Si noti che io so che potrei utilizzare una classe SomeData senza membri a tutti, e lasciare che i miei dati siano sottoclassi di questo, ma sto cercando un approccio più generico che non necessita di me per creare la mia classe di wrapper.

Answer 1

Va bene, ecco un approccio semplice utilizzando boost :: un altro per tenere i puntatori ai vostri tipi di dati. Tuttavia, fai attenzione a questo boost :: any aggiunge un po 'di codice di overhead che riduce leggermente le prestazioni (nella maggior parte dei casi trascurabili) .. considera l'uso di boost :: spirit :: hold_any o * void * se non hai bisogno di sicurezza del tipo.

class Handler { 
public: 
    void handle(boost::any value) { 
     do_handle(value); 
    } 
private: 
    virtual void do_handle(boost::any& value) = 0; 
}; 

template<class T> 
class HandlerBase : public Handler { 
private: 
    void do_handle(boost::any& value) { 
     // here you should check if value holds type T*... 
     handle_type(*(boost::any_cast<T*>(value))); 
    } 

    void handle_type(const T& value) = 0; 
}; 

class StringHandler : HandlerBase<std::string> { 
private: 
    void handle_type(const std::string& value) { 
     // do stuff 
    } 
}; 

Ora è possibile scrivere un sacco di classi handler, derivante da HandlerBase, senza assumere che i tipi trattati hanno una classe base comune.

Answer 2

Si può fare

B* someB = static_cast<B*>(theVoidPointer); 

Answer 3

È necessario disporre di una classe base denominata DataObject o qualcosa del genere. Tutti i tipi di dati (stringa, numero, quant'altro) sono sottoclassi di DataObject. Definisci Gestisci in questo modo:

void Handle(DataObject *dataObject); 

Questo è un modo molto più sicuro di fare ciò che vuoi. Per renderlo ancora migliore, DataObject può persino sapere che tipo di dati contiene. Quindi i gestori possono verificare di aver ricevuto il giusto tipo di dati.

Answer 4

È possibile ad esempio definire una classe base:

class BaseHandlerData { 
    ... 
}; 

Poi derivare la classi di dati specifici, che si prevede per i gestori:

class StringData: public BaseHandlerData { 
    ... 
}; 

class SomeData: public BaseHandlerData { 
    ... 
}; 

Poi si dovrebbe essere in grado di passare un BaseHandlerData * argomento del metodo handle e usa qualcosa del tipo:

void handle(BaseHandlerData *data) { 
    StringData* stringData = dynamic_cast<StringData*>(...); 
    // handle your string data here ... 
} 

per sicurezza cast per il tipo di dati previsti.

Gerald

Answer 5

Un'altra alternativa, ottenere di più verso il mondo C, sarebbe un tipo union (http://en.wikipedia.org/wiki/Union_(computer_science)#C.2FC.2B.2B). Questo ti permetterebbe solo di passare i tipi che specifichi, non qualsiasi tipo, ma ha il tipo di comportamento che descrivi.