C++11之如何实现控制反转

一个小例子
我们先写一个不使用控制反转的小例子：

#include <iostream>

using namespace std;

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

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

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

class D{
public:
    D(A* a):m_a(a){}

    void func(){m_a->func();}

    ~D(){
        if (m_a != nullptr)
        {
               delete m_a;
               m_a = nullptr;
        }
    }

private:
    A* m_a;
};

int _tmain(int argc, _TCHAR* argv[])
{
    D* active = nullptr;
    if (condtionB)
    {
        active = new D(new B());
    } 
    else
    {
        active = new D(new C());
    }
    delete active;
    return 0;
}

从上面的例子中可以看到D对象和A对象之间的耦合性就产生了。当A对象派生多个子类时，创建D对象时就不得不多加一个条件的判断，这严重影响了代码的扩展性。也违背了“开放-封闭”的原则。耦合性产生的原因在于D对象的创建直接依赖于new外部对象，也叫做“硬编码”，是的二者关系紧耦合，失去了灵活性。一种解决办法是通过工厂模式来创建对象。

struct Factory{
    static A * Create(const string & condition)
    {

        if (conditionB)
        {
            return new B();
        } 
        else
        {
            return new C();
        }
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    string condition = "B"
    D* active = new A(Factory::Create(condition))
    active->func();
    delete active;
    return 0;
}