结构型模式之桥接模式

概述

桥接模式(bridge pattern) 的定义是：将抽象部分与它的实现部分分离，使它们都可以独立地变化。

桥接模式用一种巧妙的方式处理多层继承存在的问题,用抽象关联来取代传统的多层继承,将类之间的静态继承关系转变为动态的组合关系,使得系统更加灵活,并易于扩展,有效的控制了系统中类的个数 (避免了继承层次的指数级爆炸).

原理

桥接（Bridge）模式包含以下主要角色：

• 抽象化（Abstraction）角色 ：主要负责定义出该角色的行为 ,并包含一个对实现化对象的引用。
• 扩展抽象化（RefinedAbstraction）角色 ：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法。
• 实现化（Implementor）角色 ：定义实现化角色的接口，包含角色必须的行为和属性,并供扩展抽象化角色调用。
• 具体实现化（Concrete Implementor）角色 ：给出实现化角色接口的具体实现。

结构图

代码示例

来看下代码示例吧，如下图：

// Implementor.h
#ifndef IMPLEMENTOR_H
#define IMPLEMENTOR_H

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

#endif // IMPLEMENTOR_H

1
2
3
4
5
6
7
8
9
10
11
12

// ConcreteImplementorA.h
#ifndef CONCRETEIMPLEMENTORA_H
#define CONCRETEIMPLEMENTORA_H

#include "Implementor.h"

class ConcreteImplementorA : public Implementor {
public:
    void OperationImpl() override {
        // Concrete implementation A
        std::cout << "Concrete Implementor A" << std::endl;
    }
};

#endif // CONCRETEIMPLEMENTORA_H
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// ConcreteImplementorB.h
#ifndef CONCRETEIMPLEMENTORB_H
#define CONCRETEIMPLEMENTORB_H

#include "Implementor.h"

class ConcreteImplementorB : public Implementor {
public:
    void OperationImpl() override {
        // Concrete implementation B
        std::cout << "Concrete Implementor B" << std::endl;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13

// Abstraction.h
#ifndef ABSTRACTION_H
#define ABSTRACTION_H

#include "Implementor.h"

class Abstraction {
protected:
    Implementor* implementor;

public:
    Abstraction(Implementor* implementor) : implementor(implementor) {}
    virtual ~Abstraction() { delete implementor; }
    virtual void Operation() = 0;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

/ RefinedAbstraction.h
#ifndef REFINEDABSTRACTION_H
#define REFINEDABSTRACTION_H

#include "Abstraction.h"

class RefinedAbstraction : public Abstraction {
public:
    RefinedAbstraction(Implementor* implementor) : Abstraction(implementor) {}
    void Operation() override {
        // Refined operation
        std::cout << "Refined Abstraction" << std::endl;
        implementor->OperationImpl();
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

/ main.cpp
#include 
#include "Abstraction.h"
#include "ConcreteImplementorA.h"
#include "ConcreteImplementorB.h"
#include "RefinedAbstraction.h"

int main() {
    ConcreteImplementorA* implementorA = new ConcreteImplementorA();
    ConcreteImplementorB* implementorB = new ConcreteImplementorB();

    Abstraction* abstractionA = new RefinedAbstraction(implementorA);
    Abstraction* abstractionB = new RefinedAbstraction(implementorB);

    abstractionA->Operation();
    abstractionB->Operation();

    delete abstractionA;
    delete abstractionB;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

小结

上边有桥接模式的概述，原理，以及代码示例。看起来不错吧，感兴趣，可以一起学习学习。