C++ de tableau associatif avec des types arbitraires pour les valeurs

Question

Quelle est la meilleure façon d'avoir un tableau associatif avec les types de valeurs arbitraires pour chaque touche en C++?

Actuellement, mon plan est de créer une classe « valeur » avec des variables membres des types j'attendrai. Par exemple:

class Value { 

    int iValue; 
    Value(int v) { iValue = v; } 

    std::string sValue; 
    Value(std::string v) { sValue = v; } 

    SomeClass *cValue; 
    Value(SomeClass *v) { cValue = c; } 

}; 

std::map<std::string, Value> table; 

Un inconvénient avec c'est que vous devez connaître le type lors de l'accès à la « valeur ». i.e .:

table["something"] = Value(5); 
SomeClass *s = table["something"].cValue; // broken pointer 

De même, plus le nombre de types mis en Valeur est élevé, plus le tableau sera boursouflé.

De meilleures suggestions?

Answer 1

boost::variant semble exactement ce que vous cherchez.

Answer 2

Sous-classe Value avec IntValue, StringValue et ainsi de suite.

Answer 3

Votre approche est fondamentalement dans la bonne direction. Vous devez connaître le type dans lequel vous mettez. Vous pouvez utiliser boost::any et vous serez en mesure de mettre à peu près tout dans la carte, aussi longtemps que vous savez ce que vous mettez dans:

std::map<std::string, boost::any> table; 
table["hello"] = 10; 
std::cout << boost::any_cast<int>(table["hello"]); // outputs 10 

Quelques réponses ont recommandé l'utilisation de boost::variant pour résoudre ce problème. Mais il ne vous laissera pas stocker des valeurs typées arbitraires dans la carte (comme vous le vouliez). Vous devez connaître l'ensemble des types possibles à l'avance. Étant donné que, vous pouvez le faire ci-dessus plus facilement:

typedef boost::variant<int, std::string, void*> variant_type; 
std::map<std::string, variant_type> table; 
table["hello"] = 10; 
// outputs 10. we don't have to know the type last assigned to the variant 
// but the variant keeps track of it internally. 
std::cout << table["hello"]; 

Cela fonctionne parce que boost::variantoperator<< à cette surcharge fin. Il est important de comprendre que si vous voulez enregistrer ce qui est actuellement contenue dans la variante, vous devez toujours connaître le type, comme dans le boost::any cas:

typedef boost::variant<int, std::string, void*> variant_type; 
std::map<std::string, variant_type> table; 
table["hello"] = "bar"; 
std::string value = boost::get<std::string>(table["hello"]); 

L'ordre des affectations à une variante est un moteur d'exécution propriété du flux de contrôle de votre code, mais le type utilisé de n'importe quelle variable est déterminé au moment de la compilation. Donc, si vous voulez obtenir la valeur de la variante, vous devez connaître son type. Une alternative consiste à utiliser les visites, comme indiqué dans la documentation de la variante. Cela fonctionne car la variante stocke un code qui lui indique quel type lui a été assigné en dernier. Sur cette base, il décide lors de l'exécution qui surcharge du visiteur qu'il utilise. boost::variant est assez grand et ne se conforme pas tout à fait standard, tout en boost::any est conforme à la norme, mais utilise la mémoire dynamique, même pour les petits types (donc il est variante plus lente. Peut utiliser la pile pour les petits types). Donc, vous devez échanger ce que vous utilisez.

Si vous voulez vraiment mettre des objets dans ce qui ne diffèrent que par la façon dont ils font quelque chose, le polymorphisme est une meilleure façon d'aller. Vous pouvez avoir une classe de base qui vous dérivez de:

std::map< std::string, boost::shared_ptr<Base> > table; 
table["hello"] = boost::shared_ptr<Base>(new Apple(...)); 
table["hello"]->print(); 

Ce qui serait essentiellement besoin de cette mise en page de classe:

class Base { 
public: 
    virtual ~Base() { } 
    // derived classes implement this: 
    virtual void print() = 0; 
}; 

class Apple : public Base { 
public: 
    virtual void print() { 
     // print us out. 
    } 
}; 

Le boost::shared_ptr est un pointeur intelligent que l'on appelle. Il supprimera automatiquement vos objets si vous les supprimez de votre carte et rien d'autre ne les référencera plus. En théorie, vous auriez pu travailler avec un pointeur neutre, mais en utilisant un pointeur intelligent augmentera considérablement la sécurité.Lisez le manuel shared_ptr auquel je suis lié.

Answer 4

Pouvez-vous utiliser une union avec std :: map?

Boost :: variant fournit des variables sans type. Altrnativement, vous pouvez rendre privés tous vos membres de données de la valeur et fournir des accesseurs qui renvoient une erreur (ou un jet) si elle n'est pas définie.

Answer 5

Une optimisation simple serait d'utiliser un union, puisque vous aurez toujours seulement une des valeurs comme clé.

Une solution plus complète encapsulerait certaines informations de type temps d'exécution dans une interface. Principalement "Quel type est-ce?" et "Comment comparer les valeurs pour l'égalité?" Ensuite, utilisez les implémentations de cela comme clé.