Runtime interfaces and object composition in C++

Question

I am searching for a simple, light-weight solution for interface-based runtime object composition in C++. I want to be able to specify interfaces (methods declarations), and objects (creatable through factory pattern) implementing these. At runtime I want mechanisms to instantiate these objects and interconnect these based on interface-connectors. The method calls at runtime should remain fairly cheap, i.e. only several more instructions per call, comparable to functor patterns.

The whole thing needs to be platform independent (at least MS Windows and Linux). And the solution needs to be licensed liberally, like open source LGPL or (even better) BSD or something, especially allowing use commercial products.

What I do not want are heavy things like networking, inter-process-communication, extra compiler steps (one-time code generation is ok though), or dependencies to some heavy libraries (like Qt).

The concrete scenario is: I have such a mechanism in a larger software, but the mechanism is not very well implemented. Interfaces are realized by base classes exported by Dlls. These Dlls also export factory functions to instantiate the implementing objects, based on hand-written class ids.

Before I now start to redesign and implement something better myself, I want to know if there is something out there which would be even better.

Edit: The solution also needs to support multi-threading environments. Additionally, as everything will happen inside the same process, I do not need data serialization mechanisms of any kind.

Edit: I know how such mechanisms work, and I know that several teaching books contain corresponding examples. I do not want to write it myself. The aim of my question is: Is there some sort of "industry standard" lib for this? It is a small problem (within a single process) and I am really only searching for a small solution.

Edit: I got the suggestion to add a pseudo-code example of what I really want to do. So here it is:

Somewhere I want to define interfaces. I do not care if it's C-Headers or some language and code generation.

class interface1 {
public:
    virtual void do_stuff(void) = 0;
};

class interface2 {
public:
    virtual void do_more_stuff(void) = 0;
};

Then I want to provide (multiple) implementations. These may even be placed in Dll-based plugins. Especially, these two classes my be implemented in two different Dlls not knowing each other at compile time.

class A : public interface1 {
public:
    virtual void do_stuff(void) {
        // I even need to call further interfaces here
        // This call should, however, not require anything heavy, like data serialization or something.
        this->con->do_more_stuff();
    }
    // Interface connectors of some kind. Here I use something like a template
    some_connector<interface2> con;
};

class B : public interface2 {
public:
    virtual void do_more_stuff() {
        // finally doing some stuff
    }
};

Finally, I may application main code I want to be able to compose my application logic at runtime (e.g. based on user input):

void main(void) {
    // first I create my objects through a factory
    some_object a = some_factory::create(some_guid<A>);
    some_object b = some_factory::create(some_guid<B>);

    // Then I want to connect the interface-connector 'con' of object 'a' to the instance of object 'b'
    some_thing::connect(a, some_guid<A::con>, b);

    // finally I want to call an interface-method.
    interface1 *ia = a.some_cast<interface1>();
    ia->do_stuff();
}

I am perfectly able to write such a solution myself (including all pitfalls). What I am searching for is a solution (e.g. a library) which is used and maintained by a wide user base.

Answer 1

While not widely used, I wrote a library several years ago that does this.

You can see it on GitHub zen-core library, and it's also available on Google Code

The GitHub version only contains the core libraries, which is really all the you need. The Google Code version contains a LOT of extra libraries, primarily for game development, but it does provide a lot of good examples on how to use it.

The implementation was inspired by Eclipse's plugin system, using a plugin.xml file that indicates a list of available plugins, and a config.xml file that indicates which plugins you would like to load. I'd also like to change it so that it doesn't depend on libxml2 and allow you to be able to specify plugins using other methods.

The documentation has been destroyed thanks to some hackers, but if you think this would be useful then I can write enough documentation to get you started.