一个小例子
我们先写一个不使用控制反转的小例子:
#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;
}