Question

Before anything, thanks for reading!

I’m developing an application in C++ and I want an advice about a design issue. Let me explain:

The main class of my application has some collections, but other classes eventually need to get a value from one of those collections. Something like this:

class MainClass { 
private:
   // Collections are internally implemented as QHash
   Collection<Type1> col1;
   Collection<Type2> col2;
};
class RosterUnit {
public:
   RosterUnit() {
      /* This method needs to get a specific value from col1 and
         initialize this class with that data */
   }
};

class ObjectAction {
public:
    virtual void doAction() = 0;
};

class Action1 : public ObjectAction {
public:
    void doAction() {
       // This needs a specific value from col2
    }
};

class Action2 : public ObjectAction {
public:
    void doAction() {
       // This needs a specific value from col1
    }
};

My first approach was passing the whole collection as parameter when needed, but it is not so good for ObjectAction subclasses, because I would have to pass the two collections and if I later create another subclass of ObjectAction and it needs to get an element from other collection (suppose col3), I would have to modify the doAction() signature of every ObjectAction subclass, and I think that is not too flexible. Also, suppose I have a Dialog and want to create a RosterUnit from there. I would have to pass the collection to the dialog just to create the RosterUnit.

Next I decided to use static variables in RosterUnit and ObjectAction that pointed to the collections, but I’m not very happy with that solution. I think it is not flexible enough.

I have been reading about design patterns and I first thought a Singleton with get functions could be a good choice, but after some more investigation I think it isn’t a proper design for my case. It would be easier and more or less the same if I use global variables, which don’t seem to be the right way.

So, could you give some advices, please?

Thank you very much!

Answer 1

As mentioned previously, Iterators are good for abstracting away the details of the Collection. But going this route implies that the objects that use the Iterators will need to know about what’s inside the Collection. Meaning they will need to know how to decide which object in the Collection they need, thus increasing the coupling. (more details below in the Factory paragraph) This is something you need to consider.

Another approach would be to create accessor methods on the MainClass that take some sort of key and return an object from the Collection (findObject(key)). Internally the MainClass methods would search through the container(s) and return the appropriate object. To use this approach, you will however need access to the MainClass, either by dependancy injection as mentioned before, or possibly making it a Singleton (not recomended in this scenario, though).

With the info provided so far, it may even be better for your ObjectAction Factory to have a reference to the MainClass, and as a part of the ObjectAction creation logic, call the appropriate MainClass accessor and pass the result into the ObjectAction, thus decoupling the ObjectAction Objects from the MainClass.