• Bridge模式

Bridge模式

在面向對象的開發過程中，要做到2點：1、高內聚（cohesion）。2、松耦合（coupling）。可是在實際開發過程中難以把握，比如會遇到這種問題：

1）客戶給了一個需求，之後我們用一個類A來實現。

2）客戶的需求有了變化，要用到2個算法來實現。於是我們通過定義一個抽象基類A，在用兩個詳細類A1和A2實現這兩個算法。

3）客戶需求又有了變化，要求在2個操作系統上實現。我們再抽象一個層次，不同操作系統抽象為A0和A1，每一個操作系統上有2個算法，在實現為A00、A01和A10、A11，總共同擁有4個類。

4）客戶需求假設再有變化，那麽我們又要又一次設計。

Bridge模式正是解決問題的。

Bridge模式的核心在於將抽象部分和實現分離，它們兩者能夠獨立的變化。

它的類結構圖例如以下：

以下是實現的代碼

//Abstraction.h

//Abstraction.h

#ifndef _ABSTRACTION_H_
#define _ABSTRACTION_H_

class AbstractionImp;

class Abstraction
{
public:
    virtual ~Abstraction();
    virtual void Operation() = 0 ;
protected:
    Abstraction();
};

class RefinedAbstraction :public
 
 Abstraction
{
public:
    RefinedAbstraction(AbstractionImp* imp);
    ~RefinedAbstraction();
    void Operation() ;
private:
    AbstractionImp* _imp;
};

#endif

//Abstraction.cpp

#include"Abstraction.h"
#include"AbstractionImp.h"

Abstraction::Abstraction()
{

}
Abstraction::~Abstraction()
{

}
 


RefinedAbstraction::RefinedAbstraction(AbstractionImp* imp)
{
    _imp = imp;
}
RefinedAbstraction::~RefinedAbstraction()
{

}
void RefinedAbstraction::Operation() 
{
    _imp->Operation();

}

//AbstractionImp.h

//AbstractionImp.h

#ifndef _ABSTRACTIONIMP_H_
#define _ABSTRACTIONIMP_H_
class AbstractionImp
{
public:
    virtual ~AbstractionImp();
    virtual void Operation() = 0;
protected:
    AbstractionImp();
};

class ConcreteAbstractionImpA :public AbstractionImp
{
public:
    ConcreteAbstractionImpA();
    ~ConcreteAbstractionImpA();
    virtual void Operation();
};

class ConcreteAbstractionImpB :public AbstractionImp
{
public:
    ConcreteAbstractionImpB();
    ~ConcreteAbstractionImpB();
    virtual void Operation();
};
#endif

//AbstractionImp.cpp

#include"AbstractionImp.h"
#include<iostream>
using namespace std;
AbstractionImp::AbstractionImp()
{

}
AbstractionImp::~AbstractionImp()
{

}

ConcreteAbstractionImpA::ConcreteAbstractionImpA()
{

}
ConcreteAbstractionImpA::~ConcreteAbstractionImpA()
{

}

void ConcreteAbstractionImpA::Operation()
{
    cout << "ConcreteAbstractionImpA Operation" << endl;
}

ConcreteAbstractionImpB::ConcreteAbstractionImpB()
{

}
ConcreteAbstractionImpB::~ConcreteAbstractionImpB()
{

}

void ConcreteAbstractionImpB::Operation()
{
    cout << "ConcreteAbstractionImpB Operation" << endl;
}

//main.cpp

#include"Abstraction.h"
#include"AbstractionImp.h"

int main()
{
    AbstractionImp* impA = new ConcreteAbstractionImpA();
    AbstractionImp* impB = new ConcreteAbstractionImpB();

    Abstraction* absA = new RefinedAbstraction(impA);
    Abstraction* absB = new RefinedAbstraction(impB);

    absA->Operation();
    absB->Operation();

    return 0;


}

Bridge模式