Wie kann ich "Jede Art von Daten" an eine Funktion in C++ übergeben

Question

Lets sagen, ich habe eine Klasse Handler mit einigen Unterklassen wie stringhandler, SomeTypeHandler, AnotherTypeHandler. Der Klassenhandler definiert eine Methode "handle" als eine gemeinsame Schnittstelle für alle Unterklassen. Die Logik zum "Handhaben" ist natürlich für die verschiedenen Handler völlig unterschiedlich.

Also was ich tun muss, ist einen Wert von irgendetwas an die Handle-Methode übergeben. Die spezifischen Klassen können dann das "alles" auf den erwarteten Typ umwandeln.

Im Grunde, was ich brauche, ist so etwas wie das Java-Klasse Objekt: D

Das erste, was ich versuchte, war ein void*, aber anscheinend kann man nicht B* someB = dynamic_cast<B*>(theVoidPointer) tun, so dass es kein Glück.

Meine zweite Idee war, boost::any zu verwenden. Voraussetzung für die Verwendung von boost :: any ist jedoch, dass der Wert cunstructable kopiert werden muss, was bei meinen Daten nicht der Fall ist.

Irgendwelche Ideen, um das zum Laufen zu bringen?

Dank

EDIT: Beachten Sie, dass ich weiß, dass ich eine some Klasse ohne Mitglieder überhaupt nutzen könnte, und meine Daten Subklassen davon sein lassen, aber ich bin für einen allgemeineren Ansatz suchen, die mich nicht erfordern um meine eigene Wrapperklasse zu erstellen.

Answer 1

Okay, hier ist ein einfacher Ansatz boost :: any Zeiger auf Ihre Datentypen zu halten. Achten Sie jedoch darauf, dass boost :: any etwas Overhead-Code hinzufügt, was die Leistung leicht mindert (in den meisten Fällen vernachlässigbar). Ziehen Sie stattdessen boost :: spirit :: hold_any in Betracht oder void *, wenn Sie keine Typensicherheit benötigen.

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 
    } 
}; 

Jetzt können Sie viele Handler-Klassen schreiben, von HandlerBase abzuleiten, ohne davon aus, dass die Handhabung Typen eine gemeinsame Basisklasse haben.

Answer 2

können Sie

tun

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

Answer 3

Sie benötigen eine Basisklasse haben Datenobjekt oder etwas genannt. Alle Ihre Datentypen (string, number, whatnot) sind Unterklassen von DataObject. Sie definieren Handle wie folgt:

void Handle(DataObject *dataObject); 

Dies ist eine viel sicherere Möglichkeit zu tun, was Sie wollen. Um es noch besser zu machen, kann das DataObject sogar wissen, welche Art von Daten es enthält. Dann können die Handler überprüfen, ob ihnen die richtigen Daten gesendet wurden.

Answer 4

Sie können zum Beispiel eine Basisklasse definieren:

class BaseHandlerData { 
    ... 
}; 

Dann spezifische Datenklassen ableiten, die von Ihrem Handler erwartet:

class StringData: public BaseHandlerData { 
    ... 
}; 

class SomeData: public BaseHandlerData { 
    ... 
}; 

Dann sollten Sie BaseHandlerData passieren können, * Argument mit dem Griff Methode, und verwenden Sie so etwas wie:

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

zu sicher Stellen Sie den erwarteten Datentyp ein.

Gerald

Answer 5

Eine andere Alternative, mehr in Richtung der C Welt zu bekommen, wäre ein Typ (http://en.wikipedia.org/wiki/Union_(computer_science)#C.2FC.2B.2B). Dies würde Ihnen nur erlauben, die Typen zu übergeben, die Sie angeben, nicht irgendein Typ, aber hat den Typ von Verhalten, das Sie beschreiben.