23种设计模式-7种结构模式

结构型模式简述

把类或对象结合在一起形成一个更大的结构。

装饰器模式：动态的给对象添加新的功能。

代理模式：为其它对象提供一个代理以便控制这个对象的访问。

桥接模式：将抽象部分和它的实现部分分离，使它们都可以独立的变化。

适配器模式：将一个类的方法接口转换成客户希望的另一个接口。

组合模式：将对象组合成树形结构以表示“部分-整体”的层次结构。

外观模式：对外提供一个统一的方法，来访问子系统中的一群接口。

享元模式：通过共享技术来有效的支持大量细粒度的对象。

模式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::vector<FileSystemComponent*> 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_map<char, 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 是字符工厂类，负责创建和管理字符实例。通过使用享元模式，我们可以共享相同字符的实例，从而减少了内存的使用。

享元模式的关键是将对象的共享和非共享状态分离，共享状态可以被多个对象共享，非共享状态可以通过参数传递给对象。这样可以在一定程度上减少对象的创建和内存占用。