鞍山网站页设计制作,100件创意产品,国外的贸易网站,虹口品牌网站建设结构型模式简述
把类或对象结合在一起形成一个更大的结构。
装饰器模式#xff1a;动态的给对象添加新的功能。
代理模式#xff1a;为其它对象提供一个代理以便控制这个对象的访问。
桥接模式#xff1a;将抽象部分和它的实现部分分离#xff0c;使它们都可以独立的变…结构型模式简述
把类或对象结合在一起形成一个更大的结构。
装饰器模式动态的给对象添加新的功能。
代理模式为其它对象提供一个代理以便控制这个对象的访问。
桥接模式将抽象部分和它的实现部分分离使它们都可以独立的变化。
适配器模式将一个类的方法接口转换成客户希望的另一个接口。
组合模式将对象组合成树形结构以表示“部分-整体”的层次结构。
外观模式对外提供一个统一的方法来访问子系统中的一群接口。
享元模式通过共享技术来有效的支持大量细粒度的对象。
模式C代码实现
桥接模式
桥接模式Bridge Pattern是一种结构性设计模式用于将抽象部分与其实现部分分离使它们可以独立地变化。桥接模式通过将多维度的类层次结构分为两个独立的继承层次结构从而提高了系统的可扩展性和灵活性。
以下是一个使用C实现桥接模式的简单示例假设我们要实现不同类型的电视和遥控器的桥接模式
#include iostream// 实现部分
class TV {
public:virtual void turnOn() 0;virtual void turnOff() 0;
};class SonyTV : public TV {
public:void turnOn() override {std::cout Sony TV is turned on std::endl;}void turnOff() override {std::cout Sony TV is turned off std::endl;}
};class LGTV : public TV {
public:void turnOn() override {std::cout LG TV is turned on std::endl;}void turnOff() override {std::cout LG TV is turned off std::endl;}
};// 抽象部分
class RemoteControl {
protected:TV* tv;public:RemoteControl(TV* tv) : tv(tv) {}virtual void turnOn() {tv-turnOn();}virtual void turnOff() {tv-turnOff();}
};class BasicRemoteControl : public RemoteControl {
public:BasicRemoteControl(TV* tv) : RemoteControl(tv) {}void turnOn() override {std::cout Basic Remote: ;RemoteControl::turnOn();}void turnOff() override {std::cout Basic Remote: ;RemoteControl::turnOff();}
};class AdvancedRemoteControl : public RemoteControl {
public:AdvancedRemoteControl(TV* tv) : RemoteControl(tv) {}void mute() {std::cout Advanced Remote: Muted std::endl;}
};int main() {TV* sonyTV new SonyTV();TV* lgTV new LGTV();RemoteControl* basicRemoteSony new BasicRemoteControl(sonyTV);RemoteControl* advancedRemoteLG new AdvancedRemoteControl(lgTV);basicRemoteSony-turnOn();basicRemoteSony-turnOff();advancedRemoteLG-turnOn();advancedRemoteLG-mute();advancedRemoteLG-turnOff();delete sonyTV;delete lgTV;delete basicRemoteSony;delete advancedRemoteLG;return 0;
}在这个示例中TV 类表示实现部分SonyTV 和 LGTV 是其具体实现。RemoteControl 类表示抽象部分BasicRemoteControl 和 AdvancedRemoteControl 是其具体实现。通过使用桥接模式我们可以轻松地将不同的遥控器与不同的电视组合实现了抽象部分和实现部分的解耦。
装饰模式
装饰模式Decorator Pattern是一种结构性设计模式允许在不改变已有对象的结构的情况下动态地将功能添加到对象上。在装饰模式中通过创建装饰器类将装饰器类与被装饰的类组合从而实现功能的叠加和扩展。
以下是一个使用C实现装饰模式的简单示例假设我们要实现不同类型的咖啡以及可以添加调料的功能
#include iostream
#include string// 基础咖啡类被装饰的类
class Coffee {
public:virtual std::string getDescription() const {return Basic Coffee;}virtual double cost() const {return 1.0;}
};// 调料装饰器类
class CoffeeDecorator : public Coffee {
protected:Coffee* coffee;public:CoffeeDecorator(Coffee* coffee) : coffee(coffee) {}std::string getDescription() const override {return coffee-getDescription();}double cost() const override {return coffee-cost();}
};// 具体的调料装饰器类
class MilkDecorator : public CoffeeDecorator {
public:MilkDecorator(Coffee* coffee) : CoffeeDecorator(coffee) {}std::string getDescription() const override {return coffee-getDescription() , Milk;}double cost() const override {return coffee-cost() 0.5;}
};class SugarDecorator : public CoffeeDecorator {
public:SugarDecorator(Coffee* coffee) : CoffeeDecorator(coffee) {}std::string getDescription() const override {return coffee-getDescription() , Sugar;}double cost() const override {return coffee-cost() 0.2;}
};int main() {Coffee* basicCoffee new Coffee();Coffee* milkCoffee new MilkDecorator(basicCoffee);Coffee* milkSugarCoffee new SugarDecorator(milkCoffee);std::cout Description: milkSugarCoffee-getDescription() std::endl;std::cout Cost: $ milkSugarCoffee-cost() std::endl;delete basicCoffee;delete milkCoffee;delete milkSugarCoffee;return 0;
}在这个示例中Coffee 类表示被装饰的基础咖啡CoffeeDecorator 类表示调料装饰器。具体的调料装饰器类如 MilkDecorator 和 SugarDecorator 继承自 CoffeeDecorator并通过重写 getDescription 和 cost 方法来添加调料的描述和价格。通过组合不同的装饰器我们可以在运行时动态地为咖啡添加不同的调料。
适配器模式
适配器模式Adapter Pattern是一种结构性设计模式它允许将不兼容的接口转换成客户端期望的接口。适配器模式通常用于连接两个不兼容的接口使它们可以一起工作。
以下是一个使用C实现适配器模式的简单示例假设我们有一个已有的音频播放器接口和一个新的MP3播放器类我们需要将MP3播放器接口适配成音频播放器接口。
#include iostream
#include string// 旧的音频播放器接口
class AudioPlayer {
public:virtual void playAudio(const std::string audioType, const std::string fileName) 0;
};// 新的MP3播放器类
class Mp3Player {
public:void playMp3(const std::string fileName) {std::cout Playing MP3 file: fileName std::endl;}
};// 适配器类将Mp3Player适配成AudioPlayer接口
class Mp3Adapter : public AudioPlayer {
private:Mp3Player mp3Player;public:void playAudio(const std::string audioType, const std::string fileName) override {if (audioType mp3) {mp3Player.playMp3(fileName);}}
};int main() {AudioPlayer* audioPlayer new Mp3Adapter();audioPlayer-playAudio(mp3, song.mp3);audioPlayer-playAudio(wma, song.wma); // 这不会播放因为适配器只支持MP3delete audioPlayer;return 0;
}在这个示例中AudioPlayer 是旧的音频播放器接口Mp3Player 是新的MP3播放器类Mp3Adapter 是适配器类它继承自 AudioPlayer 并包含一个 Mp3Player 对象。适配器类的 playAudio 方法将传入的 audioType 参数与适配的格式进行比较如果是 “mp3” 格式就调用 Mp3Player 的方法来播放。
通过适配器模式我们可以在不改变已有代码的情况下将不兼容的MP3播放器接口适配成了音频播放器接口从而让它们可以一起工作。
外观模式
外观模式Facade Pattern是一种结构性设计模式它为复杂的子系统提供一个统一的接口使得外部客户端可以更简单地使用该子系统而不需要了解其内部的复杂逻辑。
以下是一个使用C实现外观模式的简单示例假设我们有一个复杂的电子设备系统包括电视、音响和灯光等组件我们可以使用外观模式来创建一个统一的接口以简化客户端的操作。
#include iostream// 子系统电视
class TV {
public:void turnOn() {std::cout TV is on std::endl;}void turnOff() {std::cout TV is off std::endl;}
};// 子系统音响
class Stereo {
public:void turnOn() {std::cout Stereo is on std::endl;}void turnOff() {std::cout Stereo is off std::endl;}
};// 子系统灯光
class Lights {
public:void turnOn() {std::cout Lights are on std::endl;}void turnOff() {std::cout Lights are off std::endl;}
};// 外观类家庭影院
class HomeTheaterFacade {
private:TV tv;Stereo stereo;Lights lights;public:void watchMovie() {std::cout Get ready to watch a movie! std::endl;tv.turnOn();stereo.turnOn();lights.turnOff();}void endMovie() {std::cout Movie is over, shutting down... std::endl;tv.turnOff();stereo.turnOff();lights.turnOn();}
};int main() {HomeTheaterFacade homeTheater;homeTheater.watchMovie();std::cout ---------------------- std::endl;homeTheater.endMovie();return 0;
}在这个示例中TV、Stereo 和 Lights 分别表示不同的电子设备子系统。HomeTheaterFacade 是外观类它封装了对各个子系统的操作提供了 watchMovie 和 endMovie 方法来统一操作电视、音响和灯光等组件从而让客户端更简单地操作整个家庭影院。
通过外观模式我们将复杂的子系统封装成一个简单的接口使得客户端不需要了解子系统的复杂性只需通过外观类来操作整个系统。
组合模式
组合模式Composite Pattern是一种结构性设计模式它允许将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得客户端可以统一处理单个对象和对象组合而不需要区分它们的具体类型。
以下是一个使用C实现组合模式的简单示例假设我们要创建一个文件系统的层次结构包括文件和文件夹。文件夹可以包含文件和其他文件夹形成一个树形结构。
#include iostream
#include vector// 组件抽象基类
class FileSystemComponent {
public:virtual void display() const 0;
};// 文件类
class File : public FileSystemComponent {
private:std::string name;public:File(const std::string n) : name(n) {}void display() const override {std::cout File: name std::endl;}
};// 文件夹类
class Folder : public FileSystemComponent {
private:std::string name;std::vectorFileSystemComponent* components;public:Folder(const std::string n) : name(n) {}void addComponent(FileSystemComponent* component) {components.push_back(component);}void display() const override {std::cout Folder: name std::endl;for (const auto component : components) {component-display();}}
};int main() {File file1(file1.txt);File file2(file2.txt);File file3(file3.txt);Folder folder1(folder1);folder1.addComponent(file1);folder1.addComponent(file2);Folder folder2(folder2);folder2.addComponent(file3);Folder root(root);root.addComponent(folder1);root.addComponent(folder2);root.display();return 0;
}在这个示例中FileSystemComponent 是组件的抽象基类包括了 File 和 Folder 类。File 表示文件Folder 表示文件夹文件夹可以包含文件和其他文件夹。通过使用组合模式我们可以将文件和文件夹组合成一个层次结构使得客户端可以统一地处理不同层次的组件。
通过组合模式我们可以轻松地创建复杂的层次结构同时可以使用统一的接口来操作整个结构。这种模式在处理递归结构时特别有用例如文件系统、组织架构等。
代理模式
代理模式Proxy Pattern是一种结构性设计模式它提供了一个代理对象用于控制对原始对象的访问。代理对象可以作为原始对象的替代用于控制、管理或增强原始对象的访问。
以下是一个使用C实现代理模式的简单示例假设我们有一个图片加载器可以从磁盘加载图片并显示。我们可以使用代理模式创建一个代理图片加载器用于控制图片的加载和显示。
#include iostream
#include string// 抽象主题
class Image {
public:virtual void display() 0;
};// 真实主题
class RealImage : public Image {
private:std::string filename;public:RealImage(const std::string file) : filename(file) {loadFromDisk();}void display() override {std::cout Displaying image: filename std::endl;}void loadFromDisk() {std::cout Loading image: filename std::endl;}
};// 代理类
class ProxyImage : public Image {
private:RealImage* realImage;std::string filename;public:ProxyImage(const std::string file) : filename(file), realImage(nullptr) {}void display() override {if (realImage nullptr) {realImage new RealImage(filename);}realImage-display();}
};int main() {Image* image new ProxyImage(image.jpg);// 图片未加载调用display会加载并显示image-display();// 图片已加载直接显示image-display();return 0;
}在这个示例中Image 是抽象主题接口定义了图片的显示方法。RealImage 是真实主题类实现了图片加载和显示的功能。ProxyImage 是代理类持有一个真实主题的实例在需要时创建并控制真实主题的访问。
通过代理模式我们可以延迟真实主题的创建和加载只有在需要时才会真正地创建和加载对象。代理可以用于实现懒加载、权限控制、缓存等功能从而对原始对象的访问进行了增强或控制。
享元模式
享元模式Flyweight Pattern是一种结构性设计模式旨在通过共享对象来最大程度地减少内存使用和对象创建的开销。它适用于存在大量相似对象的场景通过共享这些相似部分可以有效减少内存占用。
以下是一个使用C实现享元模式的简单示例假设我们要创建一个文字编辑器需要创建大量的字符对象。我们可以使用享元模式来共享相同字符的实例以减少内存使用。
#include iostream
#include unordered_map// 字符类享元类
class Character {
private:char symbol;public:Character(char c) : symbol(c) {}char getSymbol() const {return symbol;}void display(int pointSize) {std::cout Character: symbol Point size: pointSize std::endl;}
};// 字符工厂负责创建和管理字符实例
class CharacterFactory {
private:std::unordered_mapchar, Character* characters;public:Character* getCharacter(char c) {if (characters.find(c) characters.end()) {characters[c] new Character(c);}return characters[c];}
};int main() {CharacterFactory characterFactory;// 创建并显示字符实例Character* c1 characterFactory.getCharacter(A);c1-display(12);Character* c2 characterFactory.getCharacter(B);c2-display(16);// 再次获取相同字符实例Character* c3 characterFactory.getCharacter(A);c3-display(20);// 释放资源delete c1;delete c2;return 0;
}在这个示例中Character 是享元类表示一个字符对象。CharacterFactory 是字符工厂类负责创建和管理字符实例。通过使用享元模式我们可以共享相同字符的实例从而减少了内存的使用。
享元模式的关键是将对象的共享和非共享状态分离共享状态可以被多个对象共享非共享状态可以通过参数传递给对象。这样可以在一定程度上减少对象的创建和内存占用。
