This is a simple dependency resolver for C++, which allows you to use the inversion of control (IoC) pattern in your applications. The project started as a blog entry.

The resolver requires no installation, just include the "resolver.hpp" file in your source code.

There is also an example test application resolver_test.cpp which you can run with "make test".

Inversion of control (IoC) is about decoupling the class from its dependencies. Suppose you have a class that does some logging:

class Foo {
private:
    Logger *logger;
public:
    Foo() {
        logger = new Logger();
    }
    void doSomethig() {
        /* does something */
        this->logger->log("done");
    }
}

This class is strongly tied to specific logger instance, which means that:

• it will require refactoring in case of using a different logger,
• writng unit tests for this class will be very hard, if not impossible.

Much more sane implementation would look as follows:

class ILogger() {
    virtual void log(std::string s) = 0;
};

class Logger : public ILogger() {
    void log(std::string s) {
        /* implementation goes here */
    }
};

class Foo {
private:
    ILogger *logger;
public:
    Foo(ILogger *l) {
        logger = l;
    }
    void doSomethig() {
        /* does something */
        this->logger->log("done");
    }
}

Now, you can create an instance of a class inheriting from ILogger (FileLogger, NetworkLogger, etc.) and inject it (hence term "dependency injection") into Foo through a constructor. Also, writing unit tests is now possible, because you can create another class, like FakeLogger, which has an empty log(std::string) method or does some assertions inside, and use it with Foo without modification.

However, if you have a lot of classes, it is tedious to instantiate all of them with proper dependencies:

Foo *foo1 = new Foo(new FileLogger());
...
Foo *foo2 = new Foo(new FileLogger());

So you can use the resolver to keep them for you:

/* Bootstrap code */
ioc::Resolver::Register<ILogger>(new FileLogger());
/* Application code */
Foo *foo1 = new Foo(ioc::Resolver::Resolve<ILogger>());
...
Foo *foo2 = new Foo(ioc::Resolver::Resolve<ILogger>());

You can also use it as a service locator, which means that a class uses a resolver instance to retrieve the dependencies itself:

class Foo {
private:
    ILogger *logger;
public:
    Foo() {
        logger = ioc::Resolver::Resolve<ILogger>();
    }
    void doSomethig() {
        /* does something */
        this->logger->log("done");
    }
}

/* Bootstrap code */
ioc::Resolver::Register<ILogger>(new FileLogger());
/* Application code */
Foo *foo1 = new Foo();
...
Foo *foo2 = new Foo();

Check out the resolver_test.cpp for a complete example implementation of the two use cases.