Is there a good way to combine or simplify these STL maps?

Question

I'm writing a class that needs to store a bunch of different primitives and classes. I've decided to make a map for each different data type where the key in the map would be the name of the variable, and the value in the map would be the value of the variable. My maps are defined like this:

std::unordered_map<std::string, int> myInts;
std::unordered_map<std::string, float> myFloats;
std::unordered_map<std::string, Something> mySomethings;

For each map, I have to write two methods, one which will get the value of some variable and one which will set the value of some variable like so:

void setMyInt(const std::string &varName, int newVal) {
    myInts[varName] = newVal;
}
int getMyInt(const std::string &varName) {
    return myInts[varName];
}

This is all fine and easy, however, I ended up with 8 different maps, and 16 of these get set methods. This doesn't seem very efficient or clean to me, not to mention that every time I need to store a new data type I have to define a new map and write 2 new get-set methods.

I considered getting rid of the get set methods and instead writing 2 template methods which would take in the type of the variable which the user needs to get or set, and then accessing the proper set to perform the operation, like so:

template<class Type>
void getVariable<Type>(const std::string &varName) {
    // if Type == int -> return myInts[varName];
    // else if Type == float -> return myFloats[varName];
}

This seems like a really poor approach since the user could pass in types which are not supported by the class, and the method breaks C++'s rule of not being really generic.

Another idea I had was writing some Variable class which would have all of the fields that this class should store, along with some enum that defines what Variable the class is actually being used for, and then making a map of this Variable class like this:

enum Type {
    TYPE_INT,
    TYPE_FLOAT,
    TYPE_SOMETHING

class Variable {
    Type type;

    int myInt;
    float myFloat;
    Something mySomething;
}
std::unordered_map<std::string, Variable> myVariables;

But this also seems like a really poor solution, or at least one which is difficult to understand. Is there some smart way to make this class store different types?

Answer 1

How about a template class like below:

template<typename ValueType>
class UnorderedStringMap : public std::unordered_map<std::string, ValueType> {
 public:
  ...
  void setValue(const std::string &varName, ValueType newVal) {
    std::unordered_map::operator[](varName) = newVal;
  }
  const ValueType& getValue(const std::string &varName) {
    return std::unordered_map::operator[](varName);
  }
  ...
}

UnorderedStringMap<int> myInts;
UnorderedStringMap<float> myFloats;

You can then use it as a normal std::unordered_map as well.