How to make a string into a reference?

Question

I have looked into this, but it's not what I wanted: Convert string to variable name or variable type

I have code that reads an ini file, stores data in a QHash table, and checks the values of the hash key, (see below) if a value is "1" it's added to World.

Code Examples:

World theWorld;
AgentMove AgentMovement(&theWorld);

if(rules.value("AgentMovement") == "1")
      theWorld.addRule(&AgentMovement);

INI file:

AgentMovement=1

What I want to do is, dynamically read from the INI file and set a reference to a hard coded variable.

for(int j = 0; j < ck.size(); j++)
    if(rules.value(ck[j]) == "1")
        theWorld.addRule("&" + ck[j]);
                             ^
                             = &AgentMovement

How would you make a string into a reference as noted above?

Answer 1

This is a common theme in programming: A value which can only be one of a set (could be an enum, one of a finite set of ints, or a set of possible string values, or even a number of buttons in a GUI) is used as a criteria to perform some kind of action. The simplistic approach is to use a switch (for atomic types) or an if/else chain for complex types. That is what you are currently doing, and there is nothing wrong with it as such:

if(rules.value(ck[j]) == "1") theWorld.addRule(&AgentMovement);
else if(rules.value(ck[j]) == "2") theWorld.addRule(&AgentEat);
else if(rules.value(ck[j]) == "3") theWorld.addRule(&AgentSleep);
// etc.
else error("internal error: weird rules value %s\n", rules.value(ck[j]));

The main advantages of this pattern are in my experience that it is crystal clear: anybody, including you in a year, understands immediately what's going on and can see immediately which criteria leads to which action. It is also trivial to debug which can be a surprising advantage: You can break at a specific action, and only at that action.

The main disadvantage is maintainability. If the same criteria (enum or whatever) is used to switch between different things in various places, all these places have to be maintained, for example when a new enum value is added. An action may come with a sound, an icon, a state change, a log message, and so on. If these do not happen at the same time (in the same switch), you'll end up switching multiple times over the action enum (or if/then/else over the string values). In that case it's better to bundle all information connected to an action in a data structure and put the structures in a map/hash table with the actions as keys. All the switches collapse to single calls. The compile-time initialization of such a map could look like this:

struct ActionDataT { Rule rule; Icon icon; Sound sound; };
map<string, AcionDataT> actionMap 
  = {
        {"1", {AgentMovement, moveIcon, moveSound} }
        {"2", {AgentEat,      eatIcon,  eatSound } } ,
        //
    };

The usage would be like

for(int j = 0; j < ck.size(); j++)
    theWorld.addRule(actionMap[rules.value(ck[j])].rule);

And elsewhere, for example:

if(actionFinished(action)) removeIcon(actionMap[action].icon);

This is fairly elegant. It demonstrates two principles of software design: 1. "All problems in computer science can be solved by another level of indirection" (David Wheeler), and 2. There is often a choice between more data or more code. The simplistic approach is code-oriented, the map approach is data oriented.

The data-centrist approach is indispensable if switches occur in more than one situation, because coding them out each time would be a maintenance nightmare.

Note that with the data-centrist approach none of the places where an action is used has to be touched when a new action is added. This is essential. The mechanism resembles (in principle and implementation, actually) the call of a virtual member function. The calling code doesn't know and isn't really interested in what is actually done. Responsibility is transferred to the object. The calling code may perform actions later in the life cycle of a program which didn't exist when it was written. By contrast, compare it to a program with many explicit switches where every single use must be examined when an action is added.

The indirection involved in the data-centrist approach is its disadvantage though, and the only problem which cannot be solved by another level of indirection, as Wheeler remarked. The code becomes more abstract and hence less obvious and harder to debug.

Answer 2

You have to provide the mapping from the names to the object by yourself. I would wrap it into a class, something like this:

template <typename T>
struct ObjectMap {
    void addObject(std::string name,T* obj){
        m[name] = obj;
    }
    T& getRef(std::string name) const {
        auto x = m.find(name);
        if (x != m.end() ) { return *(x->second);}
        else { return dummy; }
    }
    private:
        std::map<std::string,T*> m;
        T dummy;
}

The problem with this approach is that you have to decide what to do if an object is requested that is actually not in the map. A reference always has to reference something (in contrast to a pointer that can be 0). I decided to return the reference to a dummy object. However, you might want to consider to use pointers instead of references. Another option might be to throw an error in case the object is not in the map.