Almacenar una lista de objetos arbitrarios en C++

Question

En Java, puede tener una Lista de objetos. Puede agregar objetos de varios tipos, luego recuperarlos, verificar su tipo y realizar la acción adecuada para ese tipo.
Por ejemplo: (disculpas si el código no es exactamente correcto, voy de la memoria)

List<Object> list = new LinkedList<Object>(); 

list.add("Hello World!"); 
list.add(7); 
list.add(true); 

for (object o : list) 
{ 
    if (o instanceof int) 
     ; // Do stuff if it's an int 
    else if (o instanceof String) 
     ; // Do stuff if it's a string 
    else if (o instanceof boolean) 
     ; // Do stuff if it's a boolean 
} 

¿Cuál es la mejor manera de replicar este comportamiento en C++?

Answer 1

Su ejemplo usando Boost.Variante y un visitante:

#include <string> 
#include <list> 
#include <boost/variant.hpp> 
#include <boost/foreach.hpp> 

using namespace std; 
using namespace boost; 

typedef variant<string, int, bool> object; 

struct vis : public static_visitor<> 
{ 
    void operator() (string s) const { /* do string stuff */ } 
    void operator() (int i) const { /* do int stuff */ } 
    void operator() (bool b) const { /* do bool stuff */ }  
}; 

int main() 
{ 
    list<object> List; 

    List.push_back("Hello World!"); 
    List.push_back(7); 
    List.push_back(true); 

    BOOST_FOREACH (object& o, List) { 
     apply_visitor(vis(), o); 
    } 

    return 0; 
} 

Una cosa buena acerca del uso de esta técnica es que si, más adelante, se agrega otro tipo de la variante y se olvida de modificar un visitante a incluir ese tipo, que no se compilará. Usted tiene para admitir todos los casos posibles. Mientras que, si utiliza un cambio o una cascada en las declaraciones, es fácil olvidarse de realizar el cambio en todas partes e introducir un error.

Answer 2

C++ no admite contenedores heterogéneos.

Si no va a utilizar boost el truco es crear una clase ficticia y tener todas las clases diferentes derivadas de esta clase ficticia. Cree un contenedor de su elección para mantener los objetos de la clase ficticia y ya está listo para comenzar.

class Dummy { 
    virtual void whoami() = 0; 
}; 

class Lizard : public Dummy { 
    virtual void whoami() { std::cout << "I'm a lizard!\n"; } 
}; 


class Transporter : public Dummy { 
    virtual void whoami() { std::cout << "I'm Jason Statham!\n"; } 
}; 

int main() { 
    std::list<Dummy*> hateList; 
    hateList.insert(new Transporter()); 
    hateList.insert(new Lizard()); 

    std::for_each(hateList.begin(), hateList.end(), 
       std::mem_fun(&Dummy::whoami)); 
    // yes, I'm leaking memory, but that's besides the point 
} 

Si va a utilizar boost puede probar boost::any. Here es un ejemplo del uso de boost::any.

Puede encontrar este excelente article por dos destacados expertos en C++ de interés.

Ahora, boost::variant es otra cosa a tener en cuenta como j_random_hacker mencionado. Entonces, aquí hay un comparison para tener una idea clara de qué usar.

Con un boost::variant el código anterior sería algo como esto:

class Lizard { 
    void whoami() { std::cout << "I'm a lizard!\n"; } 
}; 

class Transporter { 
    void whoami() { std::cout << "I'm Jason Statham!\n"; } 
}; 

int main() { 

    std::vector< boost::variant<Lizard, Transporter> > hateList; 

    hateList.push_back(Lizard()); 
    hateList.push_back(Transporter()); 

    std::for_each(hateList.begin(), hateList.end(), std::mem_fun(&Dummy::whoami)); 
} 

Answer 3

Bueno, se podría crear una clase base y luego crear clases que heredan de ella. Luego, guárdelos en un std :: vector.

Answer 4

estoy bastante inexperto, pero aquí es lo que me gustaría ir con-

1. Crear una clase base para todas las clases que necesita para manipular.
2. Escribir clase contenedor clase de contenedor de reutilización. (Revisado después de ver otras respuestas -Mi punto anterior era demasiado críptico.)
3. Escriba un código similar.

Estoy seguro de que es posible una solución mucho mejor. También estoy seguro de que es posible una mejor explicación. Aprendí que tengo algunos malos hábitos de programación C++, así que traté de transmitir mi idea sin entrar en el código.

Espero que esto ayude.

Answer 5

Lamentablemente, no hay una manera fácil de hacerlo en C++. Tienes que crear una clase base y derivar todas las otras clases de esta clase. Cree un vector de punteros de clase base y luego use dynamic_cast (que viene con su propia sobrecarga de tiempo de ejecución) para encontrar el tipo real.

Answer 6

boost::variant es similar a la sugerencia de dirkgently de boost::any, pero admite el patrón Visitor, lo que significa que es más fácil agregar código específico del tipo más adelante. Además, asigna valores en la pila en lugar de utilizar la asignación dinámica, lo que lleva a un código ligeramente más eficiente.

EDIT: Como litb señala en los comentarios, usando variant en lugar de any significa que sólo puede contener valores de una lista pre-especificado de un de los tipos. Esto a menudo es una fortaleza, aunque podría ser una debilidad en el caso del asesino.

Aquí es un ejemplo (no usar el patrón del visitante sin embargo):

#include <vector> 
#include <string> 
#include <boost/variant.hpp> 

using namespace std; 
using namespace boost; 

... 

vector<variant<int, string, bool> > v; 

for (int i = 0; i < v.size(); ++i) { 
    if (int* pi = get<int>(v[i])) { 
     // Do stuff with *pi 
    } else if (string* si = get<string>(v[i])) { 
     // Do stuff with *si 
    } else if (bool* bi = get<bool>(v[i])) { 
     // Do stuff with *bi 
    } 
} 

(Y sí, se debe utilizar técnicamente vector<T>::size_type en lugar de int para i 's tipo, y se debe utilizar técnicamente vector<T>::iterator en lugar de todos modos , pero estoy tratando de mantenerlo simple.)

Answer 7

La respuesta corta es ... no se puede.

La respuesta larga es ... usted debería definir su propia nueva jerarquía de objetos que todos heredan de un objeto base. En Java, todos los objetos descienden finalmente de "Objeto", que es lo que te permite hacer esto.

Answer 8

¿Con qué frecuencia es realmente útil? He estado programando en C++ durante bastantes años, en diferentes proyectos, y en realidad nunca he querido un contenedor heterogéneo. Por alguna razón, puede ser común en Java (tengo mucha menos experiencia con Java), pero para cualquier uso dado en un proyecto Java podría haber una manera de hacer algo diferente que funcione mejor en C++.

C++ tiene un mayor énfasis en la seguridad del tipo que Java, y esto es muy inseguro.

Dicho esto, si los objetos no tienen nada en común, ¿por qué los guardan juntos?

Si tienen cosas en común, puede crear una clase para que hereden; alternativamente, use boost :: any. Si heredan, tienen funciones virtuales para llamar, o usan dynamic_cast <> si realmente tiene que hacerlo.

Answer 9

RTTI (información de tipo de tiempo de ejecución) en C++ siempre ha sido difícil, especialmente el compilador cruzado.

Eres mejor opción es utilizar STL y definir una interfaz con el fin de determinar el tipo de objeto:

public class IThing 
{ 
    virtual bool isA(const char* typeName); 
} 

void myFunc() 
{ 
    std::vector<IThing> things; 

    // ... 

    things.add(new FrogThing()); 
    things.add(new LizardThing()); 

    // ... 

    for (int i = 0; i < things.length(); i++) 
    { 
     IThing* pThing = things[i]; 

     if (pThing->isA("lizard")) 
     { 
     // do this 
     } 
     // etc 
    } 
} 

Mike

Answer 10

lado del hecho, ya que la mayoría han señalado, se puede' Hacer eso, o más importante, más que probable, realmente no quieres.

Eliminemos su ejemplo y consideremos algo más parecido a un ejemplo de la vida real. Específicamente, algún código que vi en un proyecto de código abierto real. Intentó emular una CPU en una matriz de caracteres. Por lo tanto, pondría en la matriz un "código de operación" de un byte, seguido de 0, 1 o 2 bytes que podría ser un carácter, un entero o un puntero a una cadena, en función del código de operación. Para manejar eso, implicó un montón de manipulación de bits.

Mi solución simple: 4 pilas separadas <> s: Una para la enumeración "opcode" y otra para chars, ints y string. Tome el siguiente de la pila de opcode, y le tomaría cuál de los otros tres para obtener el operando.

Hay una gran posibilidad de que su problema real se pueda manejar de manera similar.

Answer 11

Solo para completar este tema, quiero mencionar que en realidad se puede hacer esto con C pura usando nulo * y luego fundiéndolo en lo que tiene que ser (vale, mi ejemplo no es C puro ya que usa vectores, pero eso me ahorra un poco de código). Esto funcionará si sabe de qué tipo son sus objetos, o si almacena un campo en algún lugar que lo recuerda. Que sin duda NO quiere hacer esto, pero aquí es un ejemplo para mostrar que es posible:

#include <iostream> 
#include <vector> 

using namespace std; 

int main() { 

    int a = 4; 
    string str = "hello"; 

    vector<void*> list; 
    list.push_back((void*) &a); 
    list.push_back((void*) &str); 

    cout << * (int*) list[0] << "\t" << * (string*) list[1] << endl; 

    return 0; 
} 

Answer 12

Aunque no se puede almacenar tipos primitivos en contenedores, se pueden crear clases de tipo de envoltura primitivas que será similar a Java tipos primitivos autoboxados (en su ejemplo, los literales primitivos escritos se están autocapturando); las instancias de las cuales aparecen en el código C++ (y pueden (casi) usarse) al igual que las variables primitivas/miembros de datos.

Ver Object Wrappers for the Built-In Types de Data Structures and Algorithms with Object-Oriented Design Patterns in C++.

Con el objeto envuelto puede usar el operador typeid() de C++ para comparar el tipo. Estoy bastante seguro de que la siguiente comparación funcionará: if (typeid(o) == typeid(Int)) [donde Int sería la clase envuelta para el tipo de primitiva de tipo int, etc ...] (de lo contrario, simplemente agregue una función a sus envoltorios primitivos que devuelva un typeid y así: if (o.get_typeid() == typeid(Int)) ...

dicho esto, con respecto a su ejemplo, esto tiene olor código para mí. a menos que este es el único lugar donde se está comprobando el tipo del objeto, me inclinaría a usar polimorfismo (especialmente si tiene otros métodos/funciones específicas con respecto al tipo). En este caso usaría los envoltorios primitivos agregando una clase interconectada declarando el método diferido (para hacer 'cosas') que w debería ser implementado por cada una de sus clases primitivas envueltas. Con esto, usted podría usar su iterador contenedor y eliminar su declaración if (nuevamente, si solo tiene esta comparación de tipo, configurar el método diferido usando polimorfismo solo por esto sería excesivo).

Answer 13

Me gustaría señalar que el uso de fundición de tipo dinámico para derivar en función del tipo a menudo insinúa fallas en la arquitectura. La mayoría de las veces puede lograr el mismo efecto usando funciones virtuales:

class MyData 
{ 
public: 
    // base classes of polymorphic types should have a virtual destructor 
    virtual ~MyData() {} 

    // hand off to protected implementation in derived classes 
    void DoSomething() { this->OnDoSomething(); } 

protected: 
    // abstract, force implementation in derived classes 
    virtual void OnDoSomething() = 0; 
}; 

class MyIntData : public MyData 
{ 
protected: 
    // do something to int data 
    virtual void OnDoSomething() { ... } 
private: 
    int data; 
}; 

class MyComplexData : public MyData 
{ 
protected: 
    // do something to Complex data 
    virtual void OnDoSomething() { ... } 
private: 
    Complex data; 
}; 

void main() 
{ 
    // alloc data objects 
    MyData* myData[ 2 ] = 
    { 
    new MyIntData() 
    , new MyComplexData() 
    }; 

    // process data objects 
    for (int i = 0; i < 2; ++i) // for each data object 
    { 
    myData[ i ]->DoSomething(); // no type cast needed 
    } 

    // delete data objects 
    delete myData[0]; 
    delete myData[1]; 
};