Question

For one of my current projects I have an interface defined for which I have a large number of implementations. You could think of it as a plugin interface with many plugins.

These “plugins” each handle a different message type in a network protocol.
So when I get a new message, I loop through a list of my plugins, see who can handle it, and call into them via the interface.

The issue I am struggling with is how to allocate, initialize, and “load” all the implementations into my array/vector/whatever.

Currently I am declaring all of the “plugins” in main(), then calling an “plugin_manager.add_plugin(&plugin);” for each one. This seems less than ideal.

So, the actual questions:
1. Is there a standardized approach to this sort of thing?
2. Is there any way to define an array (global?) pre-loaded with the plugins?
3. Am I going about this the wrong way entirely? Are there other (better?) architecture options for this sort of problem?

Thanks.

EDIT:

This compiles (please excuse the ugly code)… but it kind of seems like a hack.
On the other hand, it solves the issue of allocation, and cleans up main()… Is this a valid solution?

class intf
{
public:
    virtual void t() = 0;
};

class test : public intf
{
public:
    test(){}
    static test* inst(){ if(!_inst) _inst = new test; return _inst; }
    static test* _inst;
    void t(){}
};
test* test::_inst = NULL;

intf* ints[] =
{
    test::inst(),
    NULL
};

Answer 1

Store some form of smart pointer in a container. Dynamically allocate the plugins and register them in the container so that they can be used later.

One possible approach for your solution would be, if you have some form of message id that the plugin can decode, to use a map from that id to the plugin that handles that. This approach allows you to have fast lookup of the plugin given the input message.