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"); // 这不会播放，因为适配器只支持MP3

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

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