C++ 15 接口类型(组合)设计模式总结

最新推荐文章于 2024-05-13 23:55:07 发布

502203305

最新推荐文章于 2024-05-13 23:55:07 发布

阅读量812

点赞数

分类专栏：设计模式C++实现文章标签： c++ 设计模式开发语言

本文链接：https://blog.csdn.net/rubikchen/article/details/124978110

版权

设计模式C++实现专栏收录该内容

17 篇文章 0 订阅

订阅专栏

                    
                        
                    
                     总览 
   
    核心 
      
      组合。
 
      
 说明 
      
      适配器：将成员a类,转化为b类.
桥接: 自由组合,各自变化.
过滤器: 组合成员a类,用于过滤a类一般是某种条件.
组合模式: B+树,层次结构.不过是树的函数加多态形态.
装饰器模式: 自己组合自己,链表的形式.
外观模式: 组合其他类,任意组合都需要对外提供集中简单的功能,不直接对外,getter,setter都是。
享元模式: 组合其他类,以key:value的形式缓存.
代理模式: 组合,自己组合自己,和装饰器相似,不过这个是增加处理步骤,装饰器是增加功能或元素。侧重不一样。
 
      
 
   
 分析 
   
    适配器 
      
      A->B需要借助辅助.适配器就是辅助.
 拓展坞,电脑只有typec,拓展坞提供了网线转type c输入,usb转typec输入,hmmi转typec. 
 拓展坞就是,拓展坞就是适配器类,拓展坞实现了type c接口,支持usb->c. 
 
      #include<vector>
#include<iostream>

class Typec {
public:
 virtual void Input() = 0;
};

class Interface {
public:
 virtual void Standard() = 0;
};

class USB : public Interface {
public:
 void Standard() {
   std::cout << "usb xie yi" << std::endl;
 }
};

class HDMI : public Interface {
public:
 void Standard() {
   std::cout << "hdmi xie yi" << std::endl;
 }
};



class TuoZhanWu : public Typec {
public:
 void ChaRu(Interface* jiekou) {
   interfaces.push_back(jiekou);
 }
 void Input() {
   for(auto jiekou:interfaces) {
     std::cout << "-----------------------" << std::endl;
     jiekou->Standard();
     std::cout << "zhuan typec" << std::endl;
   }
 }
private:
 std::vector<Interface*> interfaces;
};

int main() {
 TuoZhanWu tuozhanwu;
 USB usb;
 HDMI hdmi;
 tuozhanwu.ChaRu(&usb);
 tuozhanwu.ChaRu(&hdmi);
 tuozhanwu.Input();
}

 
      上面实现了拓展坞案例。将任意接口转typec输入.
 
      
 桥接 
      
       就是将独立变化的组合起来。一般有从属关系。比如人，按照职业分很多种，按照性别分，年龄分。而另一种变化就是衣服，衣服可以品牌分，面料分。 
 组合: 各自变化. 
 
      #include<iostream>


class Clothes {
public:
 virtual void What() = 0;
};

class Dress : public Clothes {
public:
 void What() {
   std::cout << "qun zi" << std::endl;
 }
};

class Jacket : public Clothes {
public:
 void What() {
   std::cout << "jia ke" << std::endl;
 }
};


class Person {
public:
 virtual void show() = 0;
protected:
 Clothes* clothes_;
};

class Teacher : public Person {
public:
 Teacher(Clothes* clothes){
   this->clothes_ = clothes;
 }
 void show() {
   std::cout << "laoshi chuan le yishen" << std::endl;
   clothes_->What();
 }
};

class Doctor : public Person {
public:
 Doctor(Clothes* clothes){
   this->clothes_ = clothes;
 }
 void show() {
   std::cout << "yisheng chuan le yi shen" << std::endl;
   clothes_->What();
 }
};


int main() {
 Person* laoshi = new Teacher(new Dress());
 Person* yisheng = new Doctor(new Jacket());
 laoshi->show();
 yisheng->show();
}
 
       人是主体，衣服是从属关系，衣服和人可以形成组合，各自独立变化。 
 没有限制的扩展，灵活。 
 
      
 过滤器模式 
      
       组合的类是一个拥有赛选功能的类。即类内部是一套标准。可以当成是面试筛选简历一样。 
 
      #include<vector>
#include<iostream>

enum Size {
 SL = 0,
 L,
 XL,
 XXL,
 XXXL
};

class Clothes {
public:
 virtual void What() = 0;
 virtual int Size() = 0;
};

class Dress : public Clothes {
public:
 void What() {
   std::cout << "qun zi" << std::endl;
 }
 int Size() {return XL;}
};

class Jacket : public Clothes {
public:
 void What() {
   std::cout << "jia ke" << std::endl;
 }
 int Size() {return XXL;}
};

class Child : public Clothes {
public:
 void What() {
   std::cout << "tong zhuang" << std::endl;
 }
 int Size() {return SL;}
};

class Filter {
public:
 virtual std::vector<Clothes*> filter(std::vector<Clothes*>) = 0;
};

class XL_XXL : public Filter {
public:
 std::vector<Clothes*> filter(std::vector<Clothes*> clothes){
   std::vector<Clothes*> temp;
   for(auto data:clothes) {
     if(XL == data->Size() ||
        XXL == data->Size()) {
       temp.push_back(data);
     }
   }
   return temp;
 }
};

class XLFilter : public Filter {
public:
 std::vector<Clothes*> filter(std::vector<Clothes*> clothes){
   std::vector<Clothes*> temp;
   for(auto data:clothes) {
     if(XL == data->Size()) {
       temp.push_back(data);
     }
   }
   return temp;
 }
};

class MyFilter : public Filter {
public:
 MyFilter(Filter* a,Filter* b):a(a),b(b){}
 std::vector<Clothes*> filter(std::vector<Clothes*> clothes) {
   auto ret = a->filter(clothes);
   return b->filter(ret);
 }
private:
 Filter *a,*b;
};


int main() {
 std::vector<Clothes*> clothes;
 clothes.push_back(new Dress());
 clothes.push_back(new Jacket());
 clothes.push_back(new Child());
 Filter* filter1 = new XL_XXL();
 Filter* filter2 = new XLFilter();


 auto ret = filter1->filter(clothes);
 for(auto i:ret) {
   i->What();
 }
 std::cout << "------------" << std::endl;
 auto ret2 = filter2->filter(ret);
 for(auto i:ret2) {
   i->What();
 }

 std::cout << "------------" << std::endl;
 Filter * combine = new MyFilter(filter1,filter2);
 auto ret3 = combine->filter(clothes);
 for(auto i:ret3) {
   i->What();
 }

}
 
       单个筛选器和组合筛选器。 
 过滤器就是由若干过滤规则组成的整体。 
 比如sql里面的where a==b,group having. 
 
      
 组合模式 
      
       就是个B+树,一般是树形结构可以使用.即leader,others这种层次分明的结构。 
 使用场景,UI,比如html,xml,json之类的.即容器. 
 
      #include<vector>
#include<iostream>

class Tree {
public:
 Tree(bool add_ten = false) {
   if(add_ten) {
     for(int i = 0 ; i < 10; i++) {
       AddNode(new Tree());
     }
   }
 }
 void AddNode(Tree* node) {
   nodes.push_back(node);
 }
 void show() {
   for(auto i: nodes) {
     std::cout << i << ":" << i->nodes.size() << std::endl;
     i->show();
   }
 }
private:
 std::vector<Tree*> nodes;
};

int main() {
 Tree a;
 Tree b(true);
 Tree c(true);
 a.AddNode(&b);
 a.AddNode(&c);
 a.show();
}

 
       一个非常简单的层次模型。 
 和学习C的时候的赋值不一样。读(get)和写(set)可能会多一些中间过程，比如检查修改等。所以C++不推荐直接对数据的读写。面向对象也推荐使用get,set. 
 这里就是容器类,自己可以包含自己的模式.组合n个自己. 
 
      
 装饰器 
      
       链表的形式组合自己,链表不仅仅是单链表可以是双向,可以是树或B+树之类的. 
 核心在于动态的添加. 
 比如造句,核心是一个基本物体,然后一个装饰类.核心是多态。 
 代表末尾的本体和可以带链的装饰。甚至本体可以是带链的装饰，不过起始是没有链的。 
 继承了相同的接口，但是侧重点不一样。 
 
      #include<vector>
#include<iostream>

class Animal {
public:
 virtual void Name() = 0;
};

class Elephant : public Animal {
public:
 void Name() override {
   std::cout << "da xiang" << std::endl;
 }
};


class MiaoShu : public Animal {
public:
 MiaoShu(Animal* miao_shu) : miao_shu_(miao_shu) {
 }
 void Name() override = 0;
protected:
 Animal* miao_shu_;
};

class ChiBang : public MiaoShu {
public:
 ChiBang(Animal* miao_shu) : MiaoShu(miao_shu) {
 }
 void Name() override {
   std::cout << "hui fei," << std::endl;
   miao_shu_->Name();
 }
};

class KuiJia : public MiaoShu {
public:
 KuiJia(Animal* miao_shu) : MiaoShu(miao_shu) {
 }
 void Name() override {
   std::cout << "kai jia," << std::endl;
   miao_shu_->Name();
 }
};

int main() {
 Animal* da_xiang = new Elephant();
 MiaoShu * chi_bang = new ChiBang(da_xiang);
 MiaoShu * kui_jia = new KuiJia(chi_bang);
 kui_jia->Name();
}


 
       这里就是都是Animal,不过实现的时候,描述类用于描述.第一个必然有描述对象,毕竟是有参构造. 
 这里的动物是末尾,即空指针,一层层的包围.头插法.尾插法也可以实现. 
 
      
 外观模式 
      
       成员类不直接对外,而是以函数的形式访问。 
 最简单的是get,set. 
 
      #include<iostream>

class Button {
public:
 virtual void push() = 0;
};


class PinDaoJia : public Button {
public:
 void push() override {
   std::cout << "xia yi ge pin dao." << std::endl;
 }
};

class PinDaoJian : public Button {
public:
 void push() override {
   std::cout << "shang yi ge pin dao." << std::endl;
 }
};

class CaiDan : public Button {
public:
 void push() override {
   std::cout << "cai dan." << std::endl;
 }
};

class YaoKongQi {
public:
 void Jia() {
   pin_dao_jia->push();
 }
 void Jian() {
   pin_dao_jian->push();
 }
 void Menu() {
   cai_dan->push();
 }
 
private:
 Button* pin_dao_jia = new PinDaoJia();
 Button* pin_dao_jian = new PinDaoJian();
 Button* cai_dan = new CaiDan();

};


int main() {
 YaoKongQi  yaokong;
 yaokong.Jia();
 yaokong.Jian();
 yaokong.Menu();
}
 
       不直接访问,而是采用成员函数的方式对外，具体的细节隐藏。 
 组合成员，简化行为。 
 
      
 享元模式 
      
       智能指针类似. 
 key:value的形式,缓存. 
 组合:map的形式. 
 
      
 代理模式 
      
       组合其他,添加额外的操作. 
 比如中介代理房子买卖,中介会帮房主进行房子的买卖操作，不过会收取一定的中介费。 
 
      #include<iostream>

class Sale {
public:
 virtual void Sign() = 0;
};

class Owner : public Sale {
public:
 void Sign(){
   std::cout << "[qian he tong.]" << std::endl;
 }
};

class Saler : public Sale {
public:
 Saler(Sale* ownder):owner_(ownder){}
 void Sign(){
   std::cout << "zhao maijia,kan fang,qian he tong,jian cha he tong." << std::endl;
   std::cout << "he tong mei wen ti." << std::endl;
   owner_->Sign();
   std::cout << "shou qu zhong jie fei." << std::endl;
 }
private:
 Sale* owner_;
};

int main() {
 Sale * fang_dong = new Owner();
 Saler * zhong_jie = new Saler(fang_dong);
 zhong_jie->Sign();
}
 
       抽象都是卖房，但是中介有新的责任。 
 添加新的步骤。 
 
      
 
   
 总结 
   
    组合与多态的结合 
      
      适配器: A->B的转化.B有A的成员.
桥接: A*B的变化.
过滤器: 过滤规则的组合.
组合: 树型模式的函数方式。
装饰器: 链表的函数形式,节点和尾指针.
外观: get,set对外简化步骤.
享元: key,value的缓存。
代理: 链表形式新增步骤.
 
      
 数据结构 
      
      链表: 代理,装饰器,组合.
多态成员: 适配器,桥接,过滤器(可定长,可变长).
其他: 享元,外观.
 
      
 
   

                

502203305

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C++ 15 接口类型(组合)设计模式总结

总览核心组合。说明适配器：将成员a类,转化为b类.桥接: 自由组合,各自变化.过滤器: 组合成员a类,用于过滤a类一般是某种条件.组合模式: B+树,层次结构.不过是树的函数加多态形态.装饰器模式: 自己组合自己,链表的形式.外观模式: 组合其他类,任意组合都需要对外提供集中简单的功能,不直接对外,getter,setter都是。享元模式: 组合其他类,以key:value的形式缓存.代理模式: 组合,自己组合自己,和装饰器相似,不过这个是增加处理步骤,装饰器..
复制链接

扫一扫