¿Cómo puedo pasar "Cualquier tipo de datos" a una función en C++

Question

Digamos que tengo un Handler de clase con algunas subclases como stringhandler, SomeTypeHandler, AnotherTypeHandler. El Handler de clase define un método "handle" como una interfaz común para todas las subclases. La lógica para "manejar" es por supuesto completamente diferente para los diferentes controladores.

Entonces, lo que tengo que hacer es pasar un valor de cualquier cosa al método de manejo. Las clases específicas pueden lanzar el "cualquier cosa" al tipo que esperan.

Básicamente lo que necesito es algo así como el objeto de clase Java: D

Lo primero que probé fue una void*, pero al parecer no se puede hacer B* someB = dynamic_cast<B*>(theVoidPointer), por lo que no hay suerte.

Mi segunda idea fue utilizar boost::any. sin embargo, el requisito de usar boost :: any es que el valor debe ser copiable como cunstructable, que no es el caso para mis datos.

¿Alguna idea para que esto funcione?

Gracias

EDIT: Tenga en cuenta que sé que podría utilizar una clase somedata sin miembros en absoluto, y que mis datos sean subclases de eso, pero estoy en busca de un enfoque más genérico que no requiere de mí para hacer mi propia clase de contenedor.

Answer 1

bien, aquí es un enfoque simple usando cualquier impulso :: punteros para sostener a sus tipos de datos. Sin embargo, tenga en cuenta que boost :: any agrega un poco de disminución del rendimiento de los códigos generales (en la mayoría de los casos, negligencia). Considere usar boost :: spirit :: hold_any en su lugar, o anular * si no necesita seguridad 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 
    } 
}; 

Ahora se puede escribir un montón de clases de controlador, que deriva de HandlerBase, sin suponer que los tipos manejados tienen una clase base común.

Answer 2

Usted puede hacer

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

Answer 3

Usted necesita tener una clase base llamada DataObject o algo así. Todos sus tipos de datos (cadena, número, etc.) son sub clases de DataObject. La manija se define así:

void Handle(DataObject *dataObject); 

Esta es una manera mucho más segura de hacer lo que quiera. Para hacerlo aún mejor, DataObject incluso puede saber qué tipo de datos contiene. Luego, los manejadores pueden verificar que se les haya enviado el tipo correcto de datos.

Answer 4

Por ejemplo, puede definir una clase base:

class BaseHandlerData { 
    ... 
}; 

Entonces derivan sus clases de datos específicos, que se espera por sus manipuladores:

class StringData: public BaseHandlerData { 
    ... 
}; 

class SomeData: public BaseHandlerData { 
    ... 
}; 

Entonces usted debe ser capaz de pasar una BaseHandlerData * argumento para el método de manejo, y utiliza algo como:

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

a caja fuerte eche a su tipo de datos esperado.

Gerald

Answer 5

Otra alternativa, conseguir más hacia el mundo C, sería un tipo union (http://en.wikipedia.org/wiki/Union_(computer_science)#C.2FC.2B.2B). Esto solo le permitirá pasar los tipos que especifique, no cualquier tipo, pero tiene el tipo de comportamiento que describe.