C++控制反转(IOC)

项目开发中，会经常遇到这样的问题：最开始，需求简单，所有用户统一使用程序proxy对外提供的一种功能。但随着用户需求增多，程序proxy想要满足不同用户需求，就要连接后端多种不同的服务。此时，proxy典型的一种架构就是用一个基类对前端提供一个统一的接口，再从这个基类派生出不同的派生类，连接后端不同的服务。然后将某些用户的一类需求和某个派生类的服务关联起来(可以使用配置文件，记录用户id和类名key)。

一个小例子：

#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <string>

using namespace std;

struct A { 
    virtual void func(){}
    virtual ~A(){}

};

struct B : public A { 
    void func() {cout << "B" << endl;}

};

struct C : public A { 
    void func() {cout << "C" << endl;}
};

#include "ioc.h"

template <class T>
class IocContainer{
public:
    IocContainer(){}
    ~IocContainer(){}

    //注册需要创建对象的构造函数，需要传入一个唯一的标识
    template<class Drived>
    void RegisterType(string key){
       std::function<T* ()> func = []{return new Drived();};//lambda表达式
       RegisterType(key, func);
    }   

    //根据唯一的标识去查找对应的构造器，并创建指针对象
    //std::function<T*()> Resolve(string key){
    T* Resolve(string key){
       if (m_creator.find(key) == m_creator.end())
       {   
          return nullptr;
       }   
       std::function<T*()> func= m_creator[key];
       return func();
    }   

    std::shared_ptr<T> ResolveShared(string key){
       T* ptr = Resolve(key);
       return std::shared_ptr<T>(ptr);
    }

private:
    void RegisterType(string key, std::function<T*()> creator){
       if(m_creator.find(key) != m_creator.end()){
          throw std::invalid_argument("this key has already exist!");
       }
       m_creator.emplace(key,creator);
    }

    map<string, std::function<T*()>> m_creator;
};

int main(int argc, char* argv[])
{
    IocContainer<A> ioc;
    ioc.RegisterType<B>("B");
    ioc.RegisterType<C>("C");

    std::shared_ptr<A> deriveB = ioc.ResolveShared("B");
    deriveB->func();

    std::shared_ptr<A> deriveC = ioc.ResolveShared("C");
    deriveC->func();
    return 0;
}

g++ ioc.cpp -std=c++11