associative std::tuple container

Question

Is it possible to define (in a simple way, possibly re-using std container) an "associative std::tuple", or said in other words a "variadiac std::map".

Something like this (this interface is just to explain, other possible interfaces are welcome):

AssociativeTuple<std::string> at;    // std:string is the key type
at.insert<float>("my_float", 3.14);  // 1.
at.insert<int>("my_int", 42);
at.insert<bool>("my_bool", true);
at.insert<int>("xyz", 0);
at.insert<std::string>("my_string", "hello world!");

assert(get(at, "my_float") == 3.14);  // 2.
assert(get(at, "my_int") == 42);
assert(at["my_string"] == "hello world!");  // 3.

assert(std::is_same<at.type_of("my_float")::type, float>)  // 4.

for (auto it : at) { std::cout << it.first << " = " << it.second; }  // 5.

Other desirable constraints:

1. The set of values/keys are known only at running time. But at compile time the user know the relation between (the type of the values) and keys. For example the user know at compiling time that "my_float" will be a float. To say in another way the set possible of keys is fixed and the type of the value corresponding to a key is known at compile time. What is not known at compiling time is "if" a key will be inserted inside the container. Of course the value of the map value is not known at compiling time.
2. Access performance, get should be fast
3. The user don't have to remember the type associated to a key

My real problem is just with value of float/int/bool type (and what I am doing is to store in everything in a std::map<std::string, float> and converting to int when necessary), but a general solution is desirable. In my real case the keys are always std::string.

Answer 1

You probably mean a map with polymorphic values. For polymorphic values you can use boost::any or, better, boost::variant<>. E.g.:

typedef boost::variant<int, double, std::string> MyVariant;
typedef std::map<std::string, MyVariant> MyPolymorphicMap;

Answer 2

How about this? (note: the values are not tuples; you have one value per key).

template<class K> using AnyMap = std::map<K, boost::any>;

AnyMap map;
map["test1"] = 124;
map["test2"] = std::string{ "some text" };

auto value = boost::any_cast<int>(map["test1"]);

Answer 3

Yes, this is possible using a variant (plenty of implementations out there) or in general some kind of wrapper, either based on a union (preferred way in your case) or derived from a common base class.

For things like get(at, "my_int") == 42 you would have to overload the equality operator bool operator==(Variant&, int) but that should also not be a problem.

You cannot do stuff like std::is_same<at.type_of("my_float")::type, float> , as is_same is a compile time expression, but the type (you are looking for) is only known at runtime. You can, however, still define a runtime function that performs that check.

However: If - in your specific case - you need only int and float and you are not hard pressed for memory (using strings as keys seem to indicate this), then I'd just used a double as it can represent any number you possibly want to store.

The other possibility would be to use two separate data structures (one for int and one for float). If necessary, you could also build a rwarpper around those in order to make them appear like a single one. Using multiple datastructures might be especially meaningfull, if your programlogic always knows the type associated with a key before performing the lookup anyway.