C++ Bridge 设计模式
Bridge模式是应用最广泛也是我个人比较喜欢的一个C++设计模式之一。
Bridge模式意图：降低抽象和实现之间的耦合。
面向对象系统设计和分析中最重要的一点就是：高内聚，低耦合。Bridge模式使得抽象和实现能够相对独立。
Bridge模式结构图：
Bridge模式的关键在于Abstraction的派生类中维护了一个纸箱Implementor类的指针。
让Implentor的派生类来去实现。从而实现了抽象和实现的相对独立。
参考代码：
#pragma once
//Abstraction.h
class Abstraction
{
public:
Abstraction(void){};
virtual ~Abstraction(void){};
virtual void Operation() = 0;
};
#pragma once
//Implementor.h
class Implementor
{
public:
Implementor(void){};
virtual ~Implementor(void){};
virtual void OperationImp() = 0;
};
#pragma once
//ConcreteImplementorA.h
#include "implementor.h"
class ConcreteImplementorA :
public Implementor
{
public:
ConcreteImplementorA(void);
~ConcreteImplementorA(void);
void OperationImp();
};
#pragma once
//ConcreteImplementorB.h
#include "implementor.h"
class ConcreteImplementorB :
public Implementor
{
public:
ConcreteImplementorB(void);
~ConcreteImplementorB(void);
void OperationImp();
};
#pragma once
//RefinedAbstraction.h
#include "abstraction.h"
#include "Implementor.h"
class Implementor;
class RefinedAbstraction :
public Abstraction
{
public:
RefinedAbstraction(void);
RefinedAbstraction(Implementor *imp);
~RefinedAbstraction(void);
void Operation();
private:
Implementor *m_imp;
};
#include <iostream>
#include "ConcreteImplementorA.h"
using namespace std;
//ConcreteImplementonA.cpp
ConcreteImplementorA::ConcreteImplementorA(void)
{
}
ConcreteImplementorA::~ConcreteImplementorA(void)
{
}
void ConcreteImplementorA::OperationImp()
{
cout << "Hi, I am in ConcreteImplementorA" << endl;
}
#include <iostream>
#include "ConcreteImplementorB.h"
using namespace std;
//ConcreteImplementorB.cpp
ConcreteImplementorB::ConcreteImplementorB(void)
{
}
ConcreteImplementorB::~ConcreteImplementorB(void)
{
}
void ConcreteImplementorB::OperationImp()
{
cout << "Hi, I am in ConcreteImplementorB" << endl;
}
#include <iostream>
#include "RefinedAbstraction.h"
using namespace std;
//RefinedAbstraction.cpp
RefinedAbstraction::RefinedAbstraction(void)
{
m_imp = NULL;
}
RefinedAbstraction::~RefinedAbstraction(void)
{
}
RefinedAbstraction::RefinedAbstraction(Implementor *imp)
{
m_imp = imp;
}
void RefinedAbstraction::Operation()
{
m_imp->OperationImp();
}
#include "Abstraction.h"
#include "ConcreteImplementorA.h"
#include "ConcreteImplementorB.h"
#include "RefinedAbstraction.h"
//main.cpp
int main()
{
ConcreteImplementorA *pImpA = new ConcreteImplementorA;
ConcreteImplementorB *pImpB = new ConcreteImplementorB;
Abstraction *objA = new RefinedAbstraction(pImpA);
Abstraction *objB = new RefinedAbstraction(pImpB);
objA->Operation();
objB->Operation();
}
我个人 非常欣赏也非常推崇Bridge模式。