【设计模式】桥

bridge模式据说是比较复杂的一个模式，从类图看其实一点都不复杂。我想复杂的部分应该就是怎么防止滥用吧。

其主要思想是将一些经常变的化实现部分与其表述分开。这样就表述和实现都可以独立变化了。

这里想起了鸵鸟是不是鸟的一个问题。也不知道举得合不合适。主要还是写一些代码吧。仅供参考就好。现在对这块还没有更深入的理解。

另外一个说bridge模式复杂的原因，我觉得主要是因为他应用的场景本身就复杂。比如抽象(表述)也要变化，实现也要变化，这比起很多其他模式，两者都变化已经够复杂了。但实际中似乎这种情况并不少。

/**
 * @file bridge.h
 * @author itegel
 * @date 2014/03/26 15:26:58
 * @brief 
 *  
 **/

#ifndef  __BRIDGE_H_
#define  __BRIDGE_H_

#include <iostream>
#include <string>

//飞行接口
class Flyable{
    public:
        Flyable(){}
        virtual void fly(){
            std::cout<<"nomal fly!"<<std::endl;
        }
        
};

//鸟....
class Bird{
    public:
        Bird(const char * name){
            name_ = name;
            fly_imp_ = NULL;
        }
        void set_fly_imp(Flyable * fly_imp){
            fly_imp_ = fly_imp;
        }
        void fly(){
            if (fly_imp_){
                fly_imp_->fly();
            } else {
                std::cout<<"can not fly!"<<std::endl;
            }
        }

        std::string get_name(){
            return name_;
        }
    protected:
        //飞行方式实现
        Flyable *fly_imp_;
    private:
        std::string  name_;
};

//老鹰算鸟
class Eagle : public Bird{
    public:
        Eagle() : Bird("eagle"){
        }
};

//鸵鸟算不算鸟呢，我觉得他是鸟，只是飞行跟别人不一样，而且一直在退化中，或许哪一天他的飞行方式变了，比如现在是跑步过程中扇几下翅膀，后面可能变成爬行了也不一定....
class Ostrich : public Bird{
    public:
        Ostrich():Bird("ostrich"){}
};

//翱翔
class EagleFly : public Flyable{
    public:
        virtual void fly(){
            std::cout<<"I am soaring ..."<<std::endl;
        }
};

//贴地飞行.....
class OstrichFly : public Flyable{
    public:
        virtual void fly(){
            std::cout<<"I am flying on my feet!"<<std::endl;
        }
};


#endif  //__BRIDGE_H_

 
/**
 * @file bridge.cpp
 * @author itegel
 * @date 2014/03/26 15:45:48
 * @brief 
 *  
 **/

#include "bridge.h"

int main(){
    OstrichFly ostrich_fly;
    EagleFly eagle_fly;

    Eagle eagle;
    std::cout<<eagle.get_name()<<"(no fly imp):"<<std::endl;
    eagle.fly();
    std::cout<<eagle.get_name()<<"(with fly imp):"<<std::endl;
    eagle.set_fly_imp(&eagle_fly);
    eagle.fly();

    Ostrich ostrich;
    ostrich.set_fly_imp(&ostrich_fly);
    std::cout<<std::endl<<ostrich.get_name()<<"(with fly imp):"<<std::endl;
    ostrich.fly();
    
    return 0;
}

输出：

eagle(no fly imp):
can not fly!
eagle(with fly imp):
I am soaring ...

ostrich(with fly imp):
I am flying on my feet!

例子比较简单，鸟可以有很多种，飞行是一种动作，每个鸟的飞行动作可能都不一样。

对于单个鸟，他的飞行方式可能也会变化。我想鸵鸟原来应该是鸟，他的祖先可能能飞，只是发现飞起来太累就进化成跑了。

哪天他或许还能飞了也不一定（逃离雾霾区，跑明显不靠谱）。人平时不能飞，但是鸟人就可以飞。哪天兄台变成鸟人了，其实就需要有一个flyable的接口。但是不一定要继承自鸟...除非真的是鸟变的人....

bridge主要思想还是用组合代替继承。很灵活的一个模式。