Classe ou conteneur pour stocker des éléments hétérogènes en C++

Question

Existe-t-il une structure, classe ou conteneur que je puisse utiliser pour stocker des éléments hétérogènes qui sont sérialisables? Par exemple disons que j'ai un int, un float et un autre objet de classe. Je veux les stocker tous dans un conteneur particulier au moment de l'exécution et les transmettre à travers les classes. Est-ce que C++ donne de telles options.

Answer 1

Vous pouvez utiliser un vectorof boost::variant, par ex.

#include <boost/serialization/vector.hpp> 
#include <boost/serialization/variant.hpp> 
// note: the above are serializable variants of 
// #include <vector> 
// #include <boost/variant.hpp> 
#include <fstream> 
#include <iostream> 
#include <boost/archive/text_oarchive.hpp> 
#include <boost/archive/text_iarchive.hpp> 
#include <algorithm> 
#include <iterator> 

struct Point { 
    float x, y; 
    Point(float x_, float y_) : x(x_), y(y_) {} 
    Point() : x(0), y(0) {} 

private: 
    friend class boost::serialization::access; 
    template<class Archive> 
    void serialize(Archive & ar, const unsigned int version) { 
     ar & x; 
     ar & y; 
    } 
}; 

std::ostream& operator<< (std::ostream& o, const Point& p) { 
    return o << "{x:" << p.x << ", y:" << p.y << "}"; 
} 

int main() { 
    std::vector<boost::variant<int, float, Point> > vec; 
    vec.push_back(12345); 
    vec.push_back(0.65432f); 
    vec.push_back(Point(2.5, 6.7)); 

    { 
     std::ofstream f("1.txt"); 
     { 
      boost::archive::text_oarchive serializer(f); 
      serializer << vec; 
     } 
    } 

    { 
     std::ifstream f("1.txt"); 
     { 
      std::vector<boost::variant<int, float, Point> > result; 
      boost::archive::text_iarchive deserializer(f); 
      deserializer >> result; 

      std::copy(result.begin(), result.end(), 
         std::ostream_iterator<boost::variant<int, float, Point> >(std::cout, "\n")); 

     } 
    } 

    return 0; 
}