设计模式之桥接模式

抽象对象类

#pragma once
class Abstraction
{
public:
    virtual ~Abstraction();

    virtual void Operation() = 0;

protected:
    Abstraction();
};

#include "Abstraction.h"


Abstraction::Abstraction()
{
}


Abstraction::~Abstraction()
{
}

 

抽象实现类

#pragma once
class AbstractionImp
{
public:
    virtual ~AbstractionImp();

    virtual void Operation() = 0;

protected:
    AbstractionImp();
};

#include "AbstractionImp.h"
#include <iostream>


AbstractionImp::AbstractionImp()
{
}


AbstractionImp::~AbstractionImp()
{
}

 

派生的抽象对象类

#pragma once
#include "Abstraction.h"
#include "ConcreateAbstractionImpA.h"
#include "ConcreateAbstractionImpB.h"

class RedfinedAbstraction :
    public Abstraction
{
public:
    RedfinedAbstraction(AbstractionImp *imp);
    ~RedfinedAbstraction();

    void Operation();

private:
    AbstractionImp *m_imp;
};

#include "RedfinedAbstraction.h"


RedfinedAbstraction::RedfinedAbstraction(AbstractionImp *imp)
{
    m_imp = imp;
}


RedfinedAbstraction::~RedfinedAbstraction()
{
}

void RedfinedAbstraction::Operation()
{
    m_imp->Operation();
}

 

派生的实现类A

#pragma once
#include "AbstractionImp.h"
class ConcreateAbstractionImpA :
    public AbstractionImp
{
public:
    ConcreateAbstractionImpA();
    ~ConcreateAbstractionImpA();

    virtual void Operation();
};

#include "ConcreateAbstractionImpA.h"
#include <iostream>


ConcreateAbstractionImpA::ConcreateAbstractionImpA()
{
}


ConcreateAbstractionImpA::~ConcreateAbstractionImpA()
{
}

void ConcreateAbstractionImpA::Operation()
{
    std::cout << "ConcreateAbstractionImpA..." << std::endl;
}

 

派生的实现类B

#pragma once
#include "AbstractionImp.h"
class ConcreateAbstractionImpB :
    public AbstractionImp
{
public:
    ConcreateAbstractionImpB();
    ~ConcreateAbstractionImpB();

    virtual void Operation();
};

#include "ConcreateAbstractionImpB.h"
#include <iostream>


ConcreateAbstractionImpB::ConcreateAbstractionImpB()
{
}


ConcreateAbstractionImpB::~ConcreateAbstractionImpB()
{
}

void ConcreateAbstractionImpB::Operation()
{
    std::cout << "ConcreateAbstractionImpB..." << std::endl;
}

 

测试

#include <iostream>
#include "RedfinedAbstraction.h"

int main()
{
    AbstractionImp *imp = new ConcreateAbstractionImpA();
    Abstraction *abs = new RedfinedAbstraction(imp);

    abs->Operation();
　　 // 内存释放

    if (imp)
    {
        delete imp;
        imp = NULL;
    }

    if (abs)
    {
        delete abs;
        abs = NULL;
    }

    std::cout << "Hello World!\n"; 
}