大话设计模式--桥接模式 Bridge -- C++实现实例

1. 桥接模式： 将抽象部分与它的实现部分分离，使它们都可以独立的变化。

分离是指 抽象类和它的派生类用来实现自己的对象分离。



实现系统可以有多角度分类，每一种分类都有可能变化，那么把这种多角度分离出来让他们独立变化，减少他们之间的耦合。



实例：

implementor.h implementor.cpp 实现接口

#ifndef IMPLEMENTOR_H
#define IMPLEMENTOR_H

class Implementor
{
public:
Implementor();
void virtual operation()=0;
};

#endif // IMPLEMENTOR_H

#include "implementor.h"

Implementor::Implementor()
{
}

concreteimplementora.h concreteimplementora.cpp 具体实现功能A

#ifndef CONCRETEIMPLEMENTORA_H
#define CONCRETEIMPLEMENTORA_H

#include "implementor.h"

class ConcreteImplementorA : public Implementor
{
public:
ConcreteImplementorA();
void operation();
};

#endif // CONCRETEIMPLEMENTORA_H

#include "concreteimplementora.h"
#include <stdio.h>

ConcreteImplementorA::ConcreteImplementorA()
{
}

void ConcreteImplementorA::operation()
{
printf("ConcreteImplementorA operation\n");
}

concreteimplementorb concreteimplementorb 具体实现功能B

#ifndef CONCRETEIMPLEMENTORB_H
#define CONCRETEIMPLEMENTORB_H

#include "implementor.h"

class ConcreteImplementorB : public Implementor
{
public:
ConcreteImplementorB();
void operation();
};

#endif // CONCRETEIMPLEMENTORB_H

#include "concreteimplementorb.h"
#include <stdio.h>

ConcreteImplementorB::ConcreteImplementorB()
{
}

void ConcreteImplementorB::operation()
{
printf("ConcreteImplementorB operation\n");
}

abstraction.h abstraction.cpp 抽象

#ifndef ABSTRACTION_H
#define ABSTRACTION_H

#include "implementor.h"

class Abstraction
{
public:
Abstraction();
void setImplementor(Implementor *implementor);
void virtual operation();

protected:
Implementor *implementor;
};

#endif // ABSTRACTION_H

#include "abstraction.h"

Abstraction::Abstraction()
{
implementor = 0;
}

void Abstraction::setImplementor(Implementor *implementor)
{
this->implementor = implementor;
}

void Abstraction::operation()
{
implementor->operation();
}

refinedabstraction.h refinedabstraction.cpp 精确抽象

#ifndef REFINEDABSTRACTION_H
#define REFINEDABSTRACTION_H

#include "abstraction.h"

class RefinedAbstraction : public Abstraction
{
public:
RefinedAbstraction();
void operation();
};

#endif // REFINEDABSTRACTION_H

#include "refinedabstraction.h"

RefinedAbstraction::RefinedAbstraction()
{
}

void RefinedAbstraction::operation()
{
implementor->operation();
}

main.cpp

#include <iostream>
#include "refinedabstraction.h"
#include "concreteimplementora.h"
#include "concreteimplementorb.h"

using namespace std;

int main()
{
cout << "Bridge test!" << endl;

Abstraction *ab = new RefinedAbstraction();
ab->setImplementor(new ConcreteImplementorA());
ab->operation();

ab->setImplementor(new ConcreteImplementorB());
ab->operation();

return 0;
}