使用“桥接模式“，实现跨平台绘图或多类型消息发送机制

    桥接模式（Bridge Pattern）是一种结构型设计模式，它将抽象部分与实现部分分离，使它们可以独立地变化。以下是两个C++桥接模式，实现2种不同的场景：跨Windows/Linux平台绘图、多类型消息发送。

案例1：跨平台绘图

场景：开发一个跨平台图形应用，需要在不同操作系统（Windows、Linux）上绘制不同形状（圆形、矩形）。

实现：

#include <iostream>
#include <string>

// 实现部分接口：绘制API
class DrawingAPI {
public:
    virtual void drawCircle(double x, double y, double radius) = 0;
    virtual ~DrawingAPI() = default;
};

// Windows平台实现
class WindowsDrawingAPI : public DrawingAPI {
public:
    void drawCircle(double x, double y, double radius) override {
        std::cout << "Windows: Circle at (" << x << "," << y 
                  << ") radius " << radius << std::endl;
    }
};

// Linux平台实现
class LinuxDrawingAPI : public DrawingAPI {
public:
    void drawCircle(double x, double y, double radius) override {
        std::cout << "Linux: Circle at (" << x << "," << y 
                  << ") radius " << radius << std::endl;
    }
};

// 抽象部分：形状
class Shape {
protected:
    DrawingAPI* drawingAPI;  // 桥接实现
public:
    explicit Shape(DrawingAPI* api) : drawingAPI(api) {}
    virtual void draw() = 0;
    virtual ~Shape() = default;
};

// 具体形状：圆形
class Circle : public Shape {
private:
    double x, y, radius;
public:
    Circle(double x, double y, double radius, DrawingAPI* api)
        : Shape(api), x(x), y(y), radius(radius) {}
    
    void draw() override {
        drawingAPI->drawCircle(x, y, radius);  // 委派给实现
    }
};

// 客户端代码
int main() {
    DrawingAPI* windowsAPI = new WindowsDrawingAPI();
    DrawingAPI* linuxAPI = new LinuxDrawingAPI();

    Shape* circle1 = new Circle(1, 2, 3, windowsAPI);
    Shape* circle2 = new Circle(4, 5, 6, linuxAPI);

    circle1->draw();  // 输出: Windows: Circle at (1,2) radius 3
    circle2->draw();  // 输出: Linux: Circle at (4,5) radius 6

    delete circle1;
    delete circle2;
    delete windowsAPI;
    delete linuxAPI;
    return 0;
}

说明：

• 抽象部分：Shape类及其子类（如Circle）。
• 实现部分：DrawingAPI接口及其具体实现（如WindowsDrawingAPI）。
• 桥接：通过Shape类的构造函数注入具体的DrawingAPI实现，使形状和平台解耦。

案例2：多类型消息发送

场景：开发一个消息系统，支持多种消息类型（文本、邮件）和多种发送方式（同步、异步）。

实现：

#include <iostream>
#include <string>

// 实现部分接口：发送方式
class MessageSender {
public:
    virtual void send(const std::string& message) = 0;
    virtual ~MessageSender() = default;
};

// 同步发送实现
class SyncSender : public MessageSender {
public:
    void send(const std::string& message) override {
        std::cout << "同步发送: " << message << std::endl;
    }
};

// 异步发送实现
class AsyncSender : public MessageSender {
public:
    void send(const std::string& message) override {
        std::cout << "异步发送: " << message << std::endl;
    }
};

// 抽象部分：消息
class Message {
protected:
    MessageSender* sender;
public:
    explicit Message(MessageSender* s) : sender(s) {}
    virtual void sendMessage() = 0;
    virtual ~Message() = default;
};

// 具体消息：文本消息
class TextMessage : public Message {
private:
    std::string content;
public:
    TextMessage(const std::string& text, MessageSender* s) 
        : Message(s), content(text) {}
    
    void sendMessage() override {
        sender->send("文本消息: " + content);
    }
};

// 具体消息：邮件消息
class EmailMessage : public Message {
private:
    std::string subject;
    std::string body;
public:
    EmailMessage(const std::string& sub, const std::string& bd, MessageSender* s) 
        : Message(s), subject(sub), body(bd) {}
    
    void sendMessage() override {
        sender->send("邮件: " + subject + "\n" + body);
    }
};

// 客户端代码
int main() {
    MessageSender* sync = new SyncSender();
    MessageSender* async = new AsyncSender();

    Message* text1 = new TextMessage("紧急通知", sync);
    Message* text2 = new TextMessage("普通消息", async);
    Message* email = new EmailMessage("会议邀请", "明天上午10点开会", sync);

    text1->sendMessage();  // 输出: 同步发送: 文本消息: 紧急通知
    text2->sendMessage();  // 输出: 异步发送: 文本消息: 普通消息
    email->sendMessage();  // 输出: 同步发送: 邮件: 会议邀请...

    delete text1;
    delete text2;
    delete email;
    delete sync;
    delete async;
    return 0;
}

说明：

• 抽象部分：Message类及其子类（如TextMessage）。
• 实现部分：MessageSender接口及其具体实现（如SyncSender）。
• 桥接：通过Message类的构造函数注入具体的MessageSender实现，使消息类型和发送方式解耦。

桥接模式的核心价值

1. 分离抽象与实现：抽象部分（如形状、消息）和实现部分（如平台、发送方式）可以独立扩展。
2. 灵活组合：可以动态组合不同的抽象和实现，无需修改现有代码。
3. 符合开闭原则：新增抽象或实现时，无需修改现有代码。