十天学会网站建设,哈尔滨网站建设制作费用,怎么创建网站链接,网站开发好公司文章目录 代理模式场景示例 门面模式场景示例 桥接模式场景示例 适配器模式场景示例 外观模式场景示例 享元模式场景示例 装饰器模式场景示例 组合模式场景示例 代理模式
C语言中#xff0c;代理模式通常用于实现对象的间接访问。代理模式是一种结构型设计模式#xff0c;它… 文章目录 代理模式场景示例 门面模式场景示例 桥接模式场景示例 适配器模式场景示例 外观模式场景示例 享元模式场景示例 装饰器模式场景示例 组合模式场景示例 代理模式
C语言中代理模式通常用于实现对象的间接访问。代理模式是一种结构型设计模式它允许你提供一个代理对象来控制对另一个对象的访问。这种类型的设计模式属于结构型模式因为它创建了对象的代理以控制对它们的访问。
抽象主题Subject定义了真实主题和代理主题的共同接口这样代理就可以用来代替真实主题。
2。 真实主题Real Subject定义了实际对象代理对象是对它的一个引用。代理模式中的大部分工作都由真实主题完成而代理主要负责将请求传递给真实主题。
代理主题Proxy保存一个引用使得代理可以访问真实主题并提供与真实主题相同的接口这样客户端就无需知道代理和真实主题的区别。
代理模式通常被用来解决以下一些问题 远程代理Remote Proxy在不同的地址空间中代表一个对象。这种情况下代理对象负责将请求和参数进行编码并向远程对象发送请求。 虚拟代理Virtual Proxy用于按需创建昂贵对象这样只有在真正需要时才会实例化真实对象。例如一个图像浏览器可能只在需要显示图像时才会加载真正的图像数据。 保护代理Protection Proxy用于控制对对象的访问可以根据访问权限拒绝调用者的请求。
场景 文件访问控制在一个需要对文件进行访问控制的系统中可以使用代理模式来创建一个文件访问代理以控制对文件的读取和写入操作实现对文件访问的安全管理。 网络通信在网络通信中可以使用代理模式来创建网络通信代理以控制对网络资源的访问实现网络通信的安全验证、加密解密等功能。 资源管理在需要管理共享资源的系统中可以使用代理模式来创建资源管理代理以控制对资源的访问实现资源的共享和保护。 缓存管理在需要缓存数据以提高性能的系统中可以使用代理模式来创建缓存代理以控制对数据的访问实现数据的缓存和更新策略。 权限管理在需要对用户权限进行管理的系统中可以使用代理模式来创建权限管理代理以控制对资源的访问实现对用户权限的控制和管理。
示例
#include stdio.h
#include stdlib.h
#include string.h// 定义抽象主题接口
struct File {void (*read)(struct File *);void (*write)(struct File *, const char *);
};// 定义真实主题
struct RealFile {struct File file; // 继承自抽象主题char *name;
};// 真实主题的读操作实现
void real_read(struct File *file) {struct RealFile *realFile (struct RealFile *)file;printf(读取文件%s\n, realFile-name);
}// 真实主题的写操作实现
void real_write(struct File *file, const char *data) {struct RealFile *realFile (struct RealFile *)file;printf(写入文件%s\n, realFile-name);printf(数据%s\n, data);
}// 定义代理主题
struct ProxyFile {struct File file; // 继承自抽象主题struct RealFile *realFile;
};// 代理主题的读操作实现
void proxy_read(struct File *file) {struct ProxyFile *proxyFile (struct ProxyFile *)file;printf(代理请求读取...\n);proxyFile-realFile-file.read((proxyFile-realFile-file));
}// 代理主题的写操作实现
void proxy_write(struct File *file, const char *data) {struct ProxyFile *proxyFile (struct ProxyFile *)file;printf(代理请求写入...\n);proxyFile-realFile-file.write((proxyFile-realFile-file), data);
}int main() {// 创建真实文件对象struct RealFile *realFile malloc(sizeof(struct RealFile));realFile-name strdup(example.txt);realFile-file.read real_read;realFile-file.write real_write;// 创建文件代理对象struct ProxyFile *proxyFile malloc(sizeof(struct ProxyFile));proxyFile-realFile realFile;proxyFile-file.read proxy_read;proxyFile-file.write proxy_write;// 使用代理对象读写文件proxyFile-file.read((proxyFile-file));proxyFile-file.write((proxyFile-file), Hello, Proxy Pattern!);// 释放内存free(realFile-name);free(realFile);free(proxyFile);return 0;
}输出结果
代理请求读取...
读取文件example.txt
代理请求写入...
写入文件example.txt
数据Hello, Proxy Pattern!门面模式
C语言中门面模式Facade Pattern是一种常见的设计模式用于提供一个统一的接口以简化一组复杂系统的使用。门面模式隐藏了系统的复杂性为客户端提供了一个更简单的接口从而使客户端不需要了解系统的内部实现细节。 门面Facade提供了一个简单的接口用于将客户端的请求委派给系统内部的各个子系统。 子系统Subsystems实现了系统的各个功能但是这些功能对客户端来说可能过于复杂。门面模式通过封装这些子系统提供了一个更简单的接口供客户端使用。
场景 复杂系统的简化接口当一个系统由多个子系统组成而客户端需要使用的功能较少或者不需要了解系统内部的复杂结构时门面模式可以提供一个简化的接口隐藏系统的复杂性使得客户端更容易使用。 库或框架的封装当开发一个库或框架时为了提供更加友好的接口给用户使用可以使用门面模式来封装库或框架的内部实现细节使得用户只需调用简单的接口即可完成复杂的操作。 遗留系统的接口升级当需要对一个遗留系统进行接口升级或者重构时可以使用门面模式来封装原有的接口提供一个向后兼容的接口给客户端使用从而减少对客户端的影响。 跨平台开发当需要在不同平台上开发应用程序时可以使用门面模式来封装不同平台的差异提供一个统一的接口给客户端使用从而简化开发工作。 系统的分层设计当一个系统被分为多个层次每个层次都有不同的责任时可以使用门面模式来定义每个层次的门面使得每个层次都可以独立于其他层次进行开发和测试。
示例
#include stdio.h// 子系统1CPU
struct CPU {void (*run)(struct CPU *);
};// 子系统1的操作实现
void cpu_run(struct CPU *cpu) {printf(CPU开始运行\n);
}// 子系统2内存
struct Memory {void (*load)(struct Memory *);
};// 子系统2的操作实现
void memory_load(struct Memory *memory) {printf(内存加载数据\n);
}// 子系统3硬盘
struct HardDrive {void (*read)(struct HardDrive *);
};// 子系统3的操作实现
void harddrive_read(struct HardDrive *hardDrive) {printf(硬盘读取数据\n);
}// 门面计算机
struct Computer {struct CPU cpu;struct Memory memory;struct HardDrive hardDrive;void (*start)(struct Computer *);
};// 门面的操作实现
void computer_start(struct Computer *computer) {printf(计算机启动中...\n);// 启动计算机时依次启动CPU、内存和硬盘computer-cpu.run((computer-cpu));computer-memory.load((computer-memory));computer-hardDrive.read((computer-hardDrive));printf(计算机启动完成\n);
}int main() {// 创建计算机对象struct Computer computer;// 初始化计算机对象的各个子系统computer.cpu.run cpu_run;computer.memory.load memory_load;computer.hardDrive.read harddrive_read;// 初始化计算机对象的启动函数computer.start computer_start;// 使用门面模式启动计算机computer.start(computer);return 0;
}输出结果
计算机启动中...
CPU开始运行
内存加载数据
硬盘读取数据
计算机启动完成桥接模式
C语言中桥接模式Bridge Pattern是一种结构型设计模式它将抽象部分与实现部分分离使它们可以独立变化。桥接模式通过将抽象部分与实现部分进行解耦允许它们可以独立地进行变化从而提高了系统的灵活性和可扩展性。 抽象部分Abstraction定义了抽象类接口维护一个指向实现部分的引用。 扩展抽象部分Refined Abstraction继承自抽象部分扩展了抽象类接口增加了新的功能或行为。 实现部分Implementor定义了实现类接口提供了实现类的基本操作。 具体实现部分Concrete Implementor实现了实现部分接口的具体类。
场景 多维度变化的系统当一个系统有多个维度的变化而且这些维度都需要独立变化时可以使用桥接模式将不同维度的变化进行解耦。例如一个图形界面系统中可能有多种不同的绘制方式和多种不同的控件类型可以使用桥接模式将不同的绘制方式和控件类型进行解耦使得系统更加灵活。 运行时切换实现当一个系统需要在运行时动态地选择不同的实现时可以使用桥接模式。例如一个网络通信库可能需要支持多种不同的网络协议可以使用桥接模式将不同的网络协议的实现进行解耦使得系统可以在运行时动态地选择不同的网络协议。 多平台支持当一个系统需要支持多个不同的平台时可以使用桥接模式将不同平台的实现进行解耦。例如一个图形库可能需要支持在Windows、Linux和macOS等多个平台上运行可以使用桥接模式将不同平台的图形接口进行解耦使得系统更易于扩展和维护。 数据库驱动程序在数据库访问层中不同的数据库可能有不同的实现方式可以使用桥接模式将不同数据库的实现进行解耦使得系统可以在运行时动态地选择不同的数据库实现。
示例
#include stdio.h// 实现部分接口
struct Implementor {void (*operationImpl)(void); // 操作实现函数指针
};// 具体实现部分A
void operationImplA() {printf(具体实现部分A的操作\n);
}// 具体实现部分B
void operationImplB() {printf(具体实现部分B的操作\n);
}// 抽象部分
struct Abstraction {struct Implementor *impl; // 实现部分指针void (*operation)(struct Abstraction *); // 操作函数
};// 扩展抽象部分
void operation(struct Abstraction *abstraction) {abstraction-impl-operationImpl(); // 调用实现部分的操作
}int main() {// 创建具体实现部分A的对象struct Implementor implA;implA.operationImpl operationImplA;// 创建具体实现部分B的对象struct Implementor implB;implB.operationImpl operationImplB;// 创建抽象部分对象关联具体实现部分Astruct Abstraction abstractionA;abstractionA.impl implA;abstractionA.operation operation;// 调用抽象部分的操作实际执行具体实现部分A的操作abstractionA.operation(abstractionA);// 创建抽象部分对象关联具体实现部分Bstruct Abstraction abstractionB;abstractionB.impl implB;abstractionB.operation operation;// 调用抽象部分的操作实际执行具体实现部分B的操作abstractionB.operation(abstractionB);return 0;
}输出结果
具体实现部分A的操作
具体实现部分B的操作适配器模式
C语言中适配器模式Adapter Pattern是一种结构型设计模式它允许接口不兼容的类能够一起工作。适配器模式通过将一个类的接口转换成客户端所期望的另一个接口从而使得原本由于接口不兼容而不能一起工作的类可以一起工作。 目标接口Target客户端期望的接口适配器模式通过适配器将被适配者的接口转换成目标接口。 被适配者Adaptee需要被适配的类它的接口与目标接口不兼容。 适配器Adapter实现了目标接口并包含一个被适配者的对象它将客户端的请求转发给被适配者并进行适配。
场景 使用现有库或框架当需要使用一个已经存在的库或框架但它的接口与系统的其他部分不兼容时可以使用适配器模式将它的接口转换成系统所期望的接口。 跨平台开发在跨平台开发中不同平台上的API可能存在差异导致代码无法跨平台使用。可以使用适配器模式将不同平台上的API接口进行统一使得代码可以跨平台使用。 日志系统的适配当系统需要更换日志系统时可以使用适配器模式将新的日志系统的接口适配成原有日志系统的接口使得系统可以无缝切换日志系统而不需要修改大量代码。 数据库访问的适配当系统需要支持多种不同的数据库时可以使用适配器模式将不同数据库的访问接口适配成统一的接口使得系统可以使用相同的代码访问不同的数据库。 设备驱动的适配当系统需要支持多种不同的硬件设备时可以使用适配器模式将不同设备的驱动接口适配成统一的接口使得系统可以使用相同的代码操作不同的设备。
示例
#include stdio.h// 目标接口
struct Target {void (*request)(struct Target *);
};// 被适配者
struct Adaptee {void (*specificRequest)(struct Adaptee *);
};// 被适配者的特定请求实现
void specificRequest(struct Adaptee *adaptee) {printf(被适配者的特定请求\n);
}// 适配器
struct Adapter {struct Target target; // 目标接口struct Adaptee adaptee; // 被适配者
};// 适配器的请求实现
void request(struct Target *target) {// 将目标接口的请求转发给被适配者的特定请求struct Adapter *adapter (struct Adapter *)target;adapter-adaptee.specificRequest((adapter-adaptee));
}int main() {// 创建被适配者对象struct Adaptee adaptee;adaptee.specificRequest specificRequest;// 创建适配器对象struct Adapter adapter;adapter.target.request request;adapter.adaptee adaptee;// 使用适配器调用目标接口adapter.target.request((adapter.target));return 0;
}输出结果
被适配者的特定请求外观模式
外观模式Facade Pattern是一种结构型设计模式它提供了一个统一的接口用来访问子系统中的一群接口。外观模式定义了一个高层接口使得子系统更容易使用。
在C语言中外观模式可以帮助简化复杂系统的使用隐藏系统的复杂性提供一个更加友好和简单的接口给客户端使用。外观模式通常包含以下几个角色 外观Facade提供了一个简单的接口用来访问子系统中的一群接口。外观模式通过将客户端的请求委派给子系统中的各个对象来实现这个接口。 子系统Subsystems实现了系统的各个功能但是这些功能对客户端来说可能过于复杂。外观模式通过封装这些子系统提供了一个更简单的接口供客户端使用。
场景 复杂系统的简化接口当一个系统由多个子系统组成而客户端只需使用其中的一部分功能时可以使用外观模式将这些子系统的复杂功能进行封装提供一个简化的接口给客户端使用。 隐藏系统的复杂性当一个系统的内部结构复杂而客户端不需要了解系统的内部实现细节时可以使用外观模式隐藏系统的复杂性提供一个更加友好和简单的接口给客户端使用。 简化接口的调用流程当一个系统的接口调用流程比较繁琐需要依次调用多个接口时可以使用外观模式将这些接口调用流程进行封装提供一个更简单和直观的接口给客户端使用。 封装遗留系统当一个系统的接口需要向后兼容或者需要与其他系统进行集成时可以使用外观模式封装遗留系统的接口提供一个统一的接口给客户端使用从而降低系统的耦合度。 统一接口规范当一个系统需要支持多种不同的接口规范时可以使用外观模式将这些不同的接口规范进行统一提供一个统一的接口给客户端使用使得客户端可以无需关心不同接口规范的细节。
示例
#include stdio.h// 子系统1CPU
struct CPU {void (*run)(void); // 运行方法
};// 子系统1的具体实现
void cpu_run() {printf(CPU开始运行\n);
}// 子系统2内存
struct Memory {void (*load)(void); // 加载方法
};// 子系统2的具体实现
void memory_load() {printf(内存加载数据\n);
}// 子系统3硬盘
struct HardDrive {void (*read)(void); // 读取方法
};// 子系统3的具体实现
void harddrive_read() {printf(硬盘读取数据\n);
}// 外观计算机
struct ComputerFacade {struct CPU cpu;struct Memory memory;struct HardDrive hardDrive;void (*start)(void); // 启动方法
};// 外观的实现
void start() {printf(计算机启动中...\n);// 启动计算机时依次启动CPU、内存和硬盘cpu_run();memory_load();harddrive_read();printf(计算机启动完成\n);
}int main() {// 创建外观对象struct ComputerFacade computerFacade;// 初始化外观对象的各个子系统computerFacade.cpu.run cpu_run;computerFacade.memory.load memory_load;computerFacade.hardDrive.read harddrive_read;// 初始化外观对象的启动方法computerFacade.start start;// 使用外观模式启动计算机computerFacade.start();return 0;
}输出结果
计算机启动中...
CPU开始运行
内存加载数据
硬盘读取数据
计算机启动完成享元模式
享元模式Flyweight Pattern是一种结构型设计模式它旨在通过共享对象来最大限度地减少内存使用和提高性能。在享元模式中将对象的状态分为内部状态Intrinsic State和外部状态Extrinsic State其中内部状态可以被多个对象共享而外部状态需要根据场景而变化。 享元工厂Flyweight Factory负责创建和管理享元对象通过共享已创建的享元对象来减少对象的创建数量。 享元接口Flyweight Interface定义了享元对象的接口包括设置外部状态的方法等。 具体享元对象Concrete Flyweight实现了享元接口包含了内部状态并对外部状态进行了处理。 客户端Client通过享元工厂获取享元对象并设置外部状态实现具体的业务逻辑。
场景 大量对象的共享当系统中存在大量相似对象并且这些对象可以共享部分状态时可以使用享元模式来减少对象的创建数量降低内存消耗。 对象的状态可分为内部状态和外部状态当一个对象的状态可以分为内部状态Intrinsic State和外部状态Extrinsic State并且内部状态可以被多个对象共享时可以使用享元模式来共享内部状态减少对象的创建数量。 需要缓存对象的场景当系统需要缓存一些常用的对象并且这些对象可以共享部分状态时可以使用享元模式来缓存这些对象提高系统的性能。 系统需要保持独立的对象当系统需要保持独立的对象但又希望共享相同的状态时可以使用享元模式来共享这些状态同时保持对象的独立性。 需要减少系统中对象的数量当系统中存在大量相似对象并且这些对象可以共享部分状态时可以使用享元模式来减少对象的创建数量提高系统的性能和资源利用率。
示例
#include stdio.h
#include stdlib.h
#include string.h// 享元对象结构体
typedef struct {char *name; // 内部状态int size; // 外部状态
} Flyweight;// 享元工厂
Flyweight *get_flyweight(char *name) {static Flyweight *flyweights[10] {NULL}; // 预先创建的享元对象数组static int index 0;// 查找现有的享元对象for (int i 0; i index; i) {if (strcmp(flyweights[i]-name, name) 0) {return flyweights[i];}}// 创建新的享元对象Flyweight *flyweight (Flyweight *)malloc(sizeof(Flyweight));flyweight-name strdup(name);flyweights[index] flyweight;return flyweight;
}// 客户端使用享元对象
void client(char *name, int size) {Flyweight *flyweight get_flyweight(name);printf(对象名%s大小%d\n, flyweight-name, size);
}int main() {// 客户端使用享元对象client(object1, 10);client(object2, 20);client(object1, 30); // 复用现有的享元对象client(object3, 15);client(object2, 25); // 复用现有的享元对象return 0;
}输出结果
对象名object1大小10
对象名object2大小20
对象名object1大小30
对象名object3大小15
对象名object2大小25装饰器模式
装饰器模式Decorator Pattern是一种结构型设计模式它允许向现有对象动态地添加新功能同时又不改变其结构。装饰器模式通过创建一个包装器Wrapper将被装饰的对象进行包装从而可以在运行时动态地添加新的功能。 组件接口Component Interface定义了被装饰对象和装饰器共同实现的接口。 具体组件Concrete Component实现了组件接口的具体对象它是被装饰的对象。 装饰器Decorator实现了组件接口并包含了一个指向被装饰对象的指针它可以动态地添加新的功能。 具体装饰器Concrete Decorator实现了装饰器接口的具体对象用于添加新的功能。
场景 动态添加功能当需要在不修改对象的基本结构的情况下动态地添加额外的功能时可以使用装饰器模式。这样可以避免修改现有的代码使得系统更加灵活和可扩展。 多个功能的组合当需要对对象的功能进行组合和排列以满足不同的需求时可以使用装饰器模式。通过组合不同的装饰器可以实现不同的功能组合而无需创建大量的子类。 功能的分层扩展当需要对对象的功能进行分层扩展以便于复用和维护时可以使用装饰器模式。通过创建不同层次的装饰器可以实现对对象功能的分层扩展从而使得系统更易于理解和维护。 功能的独立扩展当需要对对象的部分功能进行独立扩展和修改时可以使用装饰器模式。通过创建独立的装饰器可以实现对对象的部分功能进行扩展而不影响其他功能的使用。 动态改变对象的行为当需要动态地改变对象的行为以适应不同的场景时可以使用装饰器模式。通过在运行时动态地装饰对象可以实现对对象行为的动态改变从而提高系统的灵活性和可定制性。
示例
#include stdio.h// 组件接口
typedef struct {void (*operation)(void);
} Component;// 具体组件
typedef struct {Component component;
} ConcreteComponent;// 具体组件的操作实现
void concrete_operation(void) {printf(执行具体组件的操作\n);
}// 装饰器
typedef struct {Component component;void (*decorate)(Component *);
} Decorator;// 具体装饰器1
typedef struct {Decorator decorator;
} ConcreteDecorator1;// 具体装饰器1的装饰方法
void decorate1(Component *component) {printf(在具体装饰器1中添加功能1\n);component-operation();
}// 具体装饰器2
typedef struct {Decorator decorator;
} ConcreteDecorator2;// 具体装饰器2的装饰方法
void decorate2(Component *component) {printf(在具体装饰器2中添加功能2\n);component-operation();
}int main() {// 创建具体组件ConcreteComponent concreteComponent;concreteComponent.component.operation concrete_operation;// 创建具体装饰器1并装饰具体组件ConcreteDecorator1 concreteDecorator1;concreteDecorator1.decorator.component concreteComponent.component;concreteDecorator1.decorator.decorate decorate1;concreteDecorator1.decorator.decorate((concreteDecorator1.decorator.component));// 创建具体装饰器2并装饰具体组件ConcreteDecorator2 concreteDecorator2;concreteDecorator2.decorator.component concreteComponent.component;concreteDecorator2.decorator.decorate decorate2;concreteDecorator2.decorator.decorate((concreteDecorator2.decorator.component));return 0;
}输出结果
在具体装饰器1中添加功能1
执行具体组件的操作
在具体装饰器2中添加功能2
执行具体组件的操作组合模式
组合模式Composite Pattern是一种结构型设计模式它允许将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式让客户端以统一的方式处理单个对象以及对象组合从而使得客户端无需区分对象和对象组合。 组件接口Component Interface定义了组合中所有对象共同的接口以便于客户端统一处理对象和对象组合。 叶子组件Leaf Component表示组合中的叶子节点它实现了组件接口但是没有子节点。 复合组件Composite Component表示组合中的复合节点它实现了组件接口并且包含了子节点。
场景 文件系统文件系统中的目录和文件可以使用组合模式来表示。目录可以看作是复合组件它包含了多个文件或目录叶子组件和复合组件而文件可以看作是叶子组件它不包含其他文件或目录。 图形用户界面GUI图形用户界面中的控件和容器可以使用组合模式来表示。控件可以看作是叶子组件它显示具体的内容或功能而容器可以看作是复合组件它包含了多个控件叶子组件和复合组件。 组织架构组织架构中的部门和员工可以使用组合模式来表示。部门可以看作是复合组件它包含了多个员工叶子组件和复合组件而员工可以看作是叶子组件它不包含其他员工。 菜单系统菜单系统中的菜单项和菜单可以使用组合模式来表示。菜单项可以看作是叶子组件它表示一个具体的功能或选项而菜单可以看作是复合组件它包含了多个菜单项叶子组件和复合组件。 物品组织在游戏开发中物品的组织结构可以使用组合模式来表示。物品可以看作是叶子组件它表示一个具体的物品而物品箱或背包可以看作是复合组件它包含了多个物品叶子组件和复合组件。
示例
#include stdio.h// 定义组件类型
typedef enum {LEAF, // 叶子节点COMPOSITE // 复合节点
} NodeType;// 定义组件结构体
typedef struct Node {NodeType type; // 节点类型叶子节点或复合节点char *name; // 节点名称union {struct Node *child; // 叶子节点指向NULL复合节点指向子节点链表的头节点struct Node *next; // 复合节点链表中的下一个节点} next;
} Node;// 打印节点名称
void print_node(Node *node) {printf(%s\n, node-name);
}// 打印树节点
void print_tree(Node *root, int depth) {if (root NULL) return;// 打印节点名称for (int i 0; i depth; i) {printf( );}print_node(root);// 递归打印子节点if (root-type COMPOSITE) {print_tree(root-next.child, depth 1);}// 递归打印兄弟节点print_tree(root-next.next, depth);
}int main() {// 创建根节点Node root {COMPOSITE, 根节点, .next {NULL}};// 创建子节点Node node1 {LEAF, 叶子节点1, .next {NULL}};Node node2 {LEAF, 叶子节点2, .next {NULL}};// 创建复合节点Node composite_node {COMPOSITE, 复合节点, .next {.child node1}};// 将复合节点添加到根节点root.next.next composite_node;composite_node.next.next node2;// 打印树节点print_tree(root, 0);return 0;
}输出结果
根节点复合节点叶子节点2叶子节点2
复合节点叶子节点2
叶子节点2
