Chemmy's Blog

桥接模式（Bridge Pattern）是结构型设计模式的核心成员之一，其核心设计思想是将抽象部分与它的实现部分分离，使两者能够独立地定义、扩展，互不干扰。这种模式摒弃了传统继承带来的强耦合问题，通过“组合替代继承”的方式，让抽象维度与实现维度可以沿着各自的方向灵活迭代，是解决多维度扩展、避免继承体系臃肿的关键设计方案。

一、桥接模式核心结构

桥接模式的设计核心的是“解耦双维度”，通过四个角色的分工协作，实现抽象与实现的分离，确保两个维度可独立扩展，各角色职责清晰、边界明确：

• 抽象化（Abstraction）：定义抽象层的核心接口，同时持有一个指向实现化对象的引用，是“抽象维度”的顶层抽象，负责封装抽象层的通用逻辑，不直接依赖具体实现。

• 扩展抽象化（Refined Abstraction）：继承或实现抽象化接口，是抽象维度的具体扩展，在抽象层基础上增加特定业务逻辑，无需关注实现层的具体细节。

• 实现化（Implementor）：定义实现层的核心接口，仅声明实现层的基础方法，供扩展抽象化调用，是“实现维度”的顶层规范，与抽象层解耦。

• 具体实现化（Concrete Implementor）：实现实现化接口，是实现维度的具体落地，负责提供底层的实现逻辑，可独立扩展新的实现方式，无需修改抽象层代码。

核心逻辑拆解：抽象维度通过持有实现维度的引用，间接调用实现维度的方法，实现“抽象依赖实现、实现不依赖抽象”的解耦效果。当需要扩展时，可单独新增抽象维度的扩展类（如新增智能遥控器）或实现维度的具体类（如新增投影仪），无需修改原有代码，完全符合“开闭原则”。

二、多语言实现桥接模式

桥接模式的核心是“双维度分离与组合”，不同语言因语法特性差异，实现方式略有不同，但核心逻辑高度统一。以下基于“设备控制”的统一场景（遥控器_抽象维度_与设备_实现维度_的桥接），实现C#、Python、Golang、C++、纯C五种语言的完整可运行案例，清晰呈现各语言的适配方式。

2.1 C# 实现（面向对象标准实现）

C# 作为强类型面向对象语言，通过接口清晰界定实现化规范，通过抽象类定义抽象层，依托继承与组合完成桥接，代码结构严谨，贴合企业级开发规范。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

using System;
using System.Threading;

// 实现化接口（Implementor）：设备的核心操作规范
public interface IDevice
{
    // 设备开机方法
    void TurnOn();
    // 设备关机方法
    void TurnOff();
}

// 具体实现化1：电视（设备维度的具体实现）
public class TV : IDevice
{
    public void TurnOn() => Console.WriteLine("电视已开机，正在加载节目...");
    public void TurnOff() => Console.WriteLine("电视已关机，已保存观看记录\n");
}

// 具体实现化2：空调（设备维度的扩展实现）
public class AirConditioner : IDevice
{
    public void TurnOn() => Console.WriteLine("空调已开机，正在调节至26℃...");
    public void TurnOff() => Console.WriteLine("空调已关机，已关闭节能模式\n");
}

// 抽象化（Abstraction）：遥控器的抽象层，持有设备引用
public abstract class RemoteControl
{
    // 持有实现化对象的引用，建立抽象与实现的桥接
    protected IDevice _device;

    // 构造函数注入设备，实现松耦合
    public RemoteControl(IDevice device)
    {
        _device = device;
    }

    // 抽象方法：遥控器核心操作（由扩展抽象化实现）
    public abstract void PowerOperation();
}

// 扩展抽象化：普通遥控器（抽象维度的具体实现）
public class BasicRemote : RemoteControl
{
    public BasicRemote(IDevice device) : base(device) { }

    // 实现抽象方法，封装遥控器的操作逻辑
    public override void PowerOperation()
    {
        Console.WriteLine("执行普通遥控器电源操作：");
        _device.TurnOn();
        Thread.Sleep(1000); // 模拟设备运行1秒
        _device.TurnOff();
    }
}

// 客户端调用：仅关注抽象层与实现层的组合，无需感知桥接细节
class Program
{
    static void Main()
    {
        // 组合1：普通遥控器 + 电视
        IDevice tv = new TV();
        RemoteControl tvRemote = new BasicRemote(tv);
        tvRemote.PowerOperation();

        // 组合2：普通遥控器 + 空调
        IDevice ac = new AirConditioner();
        RemoteControl acRemote = new BasicRemote(ac);
        acRemote.PowerOperation();
    }
}

2.2 Python 实现（动态语言简洁实现）

Python 遵循“鸭子类型”，无需显式定义接口，通过类的继承模拟抽象层与实现层，依托组合建立桥接关系，代码简洁灵活，无需繁琐的类型声明，适配快速开发场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

import time

# 实现化类（Implementor）：设备的抽象基类，定义实现层规范
class Device:
    def turn_on(self):
        """设备开机方法，由具体设备实现"""
        raise NotImplementedError("具体设备需实现开机方法")

    def turn_off(self):
        """设备关机方法，由具体设备实现"""
        raise NotImplementedError("具体设备需实现关机方法")

# 具体实现化1：电视
class TV(Device):
    def turn_on(self):
        print("电视已开机，正在加载节目...")

    def turn_off(self):
        print("电视已关机，已保存观看记录\n")

# 具体实现化2：空调
class AirConditioner(Device):
    def turn_on(self):
        print("空调已开机，正在调节至26℃...")

    def turn_off(self):
        print("空调已关机，已关闭节能模式\n")

# 抽象化类（Abstraction）：遥控器抽象层，持有设备引用
class RemoteControl:
    def __init__(self, device):
        # 组合设备对象，建立桥接
        self.device = device

    def power_operation(self):
        """遥控器核心操作，由扩展抽象化实现"""
        raise NotImplementedError("具体遥控器需实现电源操作方法")

# 扩展抽象化：普通遥控器
class BasicRemote(RemoteControl):
    def power_operation(self):
        print("执行普通遥控器电源操作：")
        self.device.turn_on()
        time.sleep(1)  # 模拟设备运行1秒
        self.device.turn_off()

# 客户端调用：灵活组合抽象与实现
if __name__ == "__main__":
    # 组合1：普通遥控器控制电视
    tv = TV()
    tv_remote = BasicRemote(tv)
    tv_remote.power_operation()

    # 组合2：普通遥控器控制空调
    ac = AirConditioner()
    ac_remote = BasicRemote(ac)
    ac_remote.power_operation()

2.3 Go 实现（组合优于继承的极简实现）

Go 语言无类和继承概念，核心遵循“组合优于继承”的设计哲学，通过接口定义实现化规范，通过结构体组合建立抽象与实现的桥接，贴合Go语言极简、高效的开发理念。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

package main

import (
   mt"
  time"
)

// 实现化接口（Implementor）：设备操作接口
type Device interface {
   rnOn()  // 开机方法
 TurnOff() // 关机方法
}

// 具体实现化1：电视
type TV struct{}

// 实现Device接口的开机方法
func (t *TV) TurnOn() {
     Println("电视已开机，正在加载节目...")
}

// 实现Device接口的关机方法
func (t *TV) TurnOff() {
        ftln("电视已关机，已保存观看记录\n")
}

// 具体实现化2：空调
type AirConditioner struct{}

// 实现Device接口的开机方法
func (a *AirConditioner) TurnOn() {
  mt.Println("空调已开机，正在调节至26℃...")
}

// 实现Device接口的关机方法
func (a *AirConditioner) TurnOff() {
     Println("空调已关机，已关闭节能模式\n")
}

// 抽象化结构体（Abstraction）：遥控器抽象层，组合设备接口
type RemoteControl struct {
  evice Device // 持有实现化接口引用，建立桥接
}

// 扩展抽象化：普通遥控器，组合抽象化结构体
type BasicRemote struct {
 RemoteControl // 嵌入结构体，实现抽象层的继承效果
}

// 扩展抽象化的核心操作方法
func (b *BasicRemote) PowerOperation() {
 fmt.Println("执行普通遥控器电源操作：")
 b.device.TurnOn()
  ime.Sleep(1 * time.Second) // 模拟设备运行1秒
  .device.TurnOff()
}

// 客户端调用：通过接口组合，实现灵活适配
func main() {
  / 组合1：普通遥控器 + 电视
 tv := &TV{}
 tvRemote := &BasicRemote{RemoteControl{device: tv}}
 tvRemote.PowerOperation()

  / 组合2：普通遥控器 + 空调
       &AirConditioner{}
  cRemote := &BasicRemote{RemoteControl{device: ac}}
   Remote.PowerOperation()
}
     ac      a  ac :=      /                           /      b      t                           d   fmt.      fmt.Prin   fmt.            Tu      "     "f

2.4 C++ 实现（面向对象经典实现）

C++ 作为经典面向对象语言，通过纯虚函数定义抽象接口（抽象化与实现化），依托类继承实现扩展，通过指针持有实现化对象，完成桥接逻辑，兼顾灵活性与性能，适配底层开发场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

#include <iostream>
#include <chrono>
#include <thread>

// 实现化接口（Implementor）：设备操作抽象接口
class Device {
public:
    // 纯虚函数，定义设备开机规范
    virtual void turnOn() = 0;
    // 纯虚函数，定义设备关机规范
    virtual void turnOff() = 0;
    // 虚析构函数，避免析构时内存泄漏
    virtual ~Device() = default;
};

// 具体实现化1：电视
class TV : public Device {
public:
    void turnOn() override {
        std::cout << "电视已开机，正在加载节目..." << std::endl;
    }
    void turnOff() override {
        std::cout << "电视已关机，已保存观看记录\n" << std::endl;
    }
};

// 具体实现化2：空调
class AirConditioner : public Device {
public:
    void turnOn() override {
        std::cout << "空调已开机，正在调节至26℃..." << std::endl;
    }
    void turnOff() override {
        std::cout << "空调已关机，已关闭节能模式\n" << std::endl;
    }
};

// 抽象化类（Abstraction）：遥控器抽象层
class RemoteControl {
protected:
    Device* device; // 持有实现化对象指针，建立桥接
public:
    // 构造函数注入设备
    RemoteControl(Device* dev) : device(dev) {}
    // 虚析构函数
    virtual ~RemoteControl() = default;
    // 纯虚函数，定义遥控器核心操作
    virtual void powerOperation() = 0;
};

// 扩展抽象化：普通遥控器
class BasicRemote : public RemoteControl {
public:
    BasicRemote(Device* dev) : RemoteControl(dev) {}
    // 实现核心操作方法
    void powerOperation() override {
        std::cout << "执行普通遥控器电源操作：" << std::endl;
        device->turnOn();
        // 模拟设备运行1秒
        std::this_thread::sleep_for(std::chrono::seconds(1));
        device->turnOff();
    }
};

// 客户端调用：管理抽象与实现的组合，释放内存
int main() {
    // 组合1：普通遥控器 + 电视
    Device* tv = new TV();
    RemoteControl* tvRemote = new BasicRemote(tv);
    tvRemote->powerOperation();

    // 组合2：普通遥控器 + 空调
    Device* ac = new AirConditioner();
    RemoteControl* acRemote = new BasicRemote(ac);
    acRemote->powerOperation();

    // 释放内存，避免泄漏
    delete tvRemote;
    delete tv;
    delete acRemote;
    delete ac;

    return 0;
}

2.5 纯C语言实现（结构体+函数指针模拟实现）

纯C语言无面向对象特性，通过“结构体封装数据+函数指针模拟接口”，模拟抽象化与实现化的分离，依托结构体嵌套和函数指针赋值，建立桥接关系，代码虽冗余但底层可控，适配嵌入式、底层开发场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

#include <stdio.h>
#include <unistd.h>

// 实现化结构体（模拟Implementor接口）：设备操作规范
typedef struct Device {
    void (*turn_on)(struct Device*);  // 开机函数指针
    void (*turn_off)(struct Device*); // 关机函数指针
} Device;

// 具体实现化1：电视（嵌入Device结构体，实现设备接口）
typedef struct TV {
    Device device; // 嵌套实现化结构体，建立桥接基础
} TV;

// 电视的开机实现
void tv_turn_on(Device* dev) {
    printf("电视已开机，正在加载节目...\n");
}

// 电视的关机实现
void tv_turn_off(Device* dev) {
    printf("电视已关机，已保存观看记录\n\n");
}

// 初始化电视：绑定函数指针，实现设备接口
void tv_init(TV* tv) {
    tv->device.turn_on = tv_turn_on;
    tv->device.turn_off = tv_turn_off;
}

// 具体实现化2：空调（嵌入Device结构体）
typedef struct AirConditioner {
    Device device; // 嵌套实现化结构体
} AirConditioner;

// 空调的开机实现
void ac_turn_on(Device* dev) {
    printf("空调已开机，正在调节至26℃...\n");
}

// 空调的关机实现
void ac_turn_off(Device* dev) {
    printf("空调已关机，已关闭节能模式\n\n");
}

// 初始化空调：绑定函数指针
void ac_init(AirConditioner* ac) {
    ac->device.turn_on = ac_turn_on;
    ac->device.turn_off = ac_turn_off;
}

// 抽象化结构体（模拟Abstraction）：遥控器抽象层
typedef struct RemoteControl {
    Device* device; // 持有实现化结构体指针，建立桥接
    void (*power_operation)(struct RemoteControl*); // 核心操作函数指针
} RemoteControl;

// 扩展抽象化：普通遥控器的核心操作实现
void basic_remote_power_operation(RemoteControl* remote) {
    printf("执行普通遥控器电源操作：\n");
    remote->device->turn_on(remote->device);
    sleep(1); // 模拟设备运行1秒
    remote->device->turn_off(remote->device);
}

// 初始化遥控器：绑定设备和核心操作方法
void remote_control_init(RemoteControl* remote, Device* dev) {
    remote->device = dev;
    remote->power_operation = basic_remote_power_operation;
}

// 客户端调用：手动组合抽象与实现，完成桥接逻辑
int main() {
    // 组合1：普通遥控器 + 电视
    TV tv;
    tv_init(&tv);
    RemoteControl tv_remote;
    remote_control_init(&tv_remote, (Device*)&tv);
    tv_remote.power_operation(&tv_remote);

    // 组合2：普通遥控器 + 空调
    AirConditioner ac;
    ac_init(&ac);
    RemoteControl ac_remote;
    remote_control_init(&ac_remote, (Device*)&ac);
    ac_remote.power_operation(&ac_remote);

    return 0;
}

三、桥接模式的优缺点

桥接模式的核心价值的是“解耦双维度、优化扩展能力”，其优缺点均围绕这一核心展开，需结合系统复杂度和扩展需求权衡使用，避免过度设计。

3.1 核心优点

• 彻底解耦抽象与实现：抽象层与实现层完全分离，两者可独立迭代，新增抽象维度或实现维度无需修改原有代码，符合“开闭原则”，降低系统维护成本。

• 避免继承爆炸：解决了多维度扩展带来的继承体系臃肿问题（例如“遥控器类型×设备类型”的组合，若用继承会产生大量子类），通过组合实现更灵活的扩展。

• 提升系统扩展性：抽象维度和实现维度可单独扩展，例如新增“语音遥控器”（扩展抽象化）无需修改设备代码，新增“投影仪”（具体实现化）无需修改遥控器代码。

• 符合合成复用原则：优先使用对象组合而非继承，降低代码耦合度，提升代码的可复用性和可维护性。

• 支持动态切换实现：可在运行时动态更换实现化对象，例如遥控器可切换控制电视、空调等不同设备，灵活性极高。

3.2 主要缺点

• 增加系统复杂度：引入抽象层、实现层及桥接关系，会增加代码量和类/结构体数量，简单场景下会提升理解成本和开发成本。

• 设计门槛较高：需要提前精准识别系统中的“抽象维度”和“实现维度”，对设计人员的架构能力要求较高，若维度划分不当，反而会导致代码更难维护。

• 间接调用带来轻微性能损耗：抽象层通过引用/指针调用实现层方法，存在少量间接调用开销（通常可忽略，仅在高频调用场景下需关注）。

四、桥接模式的使用场景

桥接模式的核心适用场景是“系统存在两个及以上独立变化的维度”，且需要长期扩展，具体场景如下：

• 系统存在双独立扩展维度：例如“产品类型（抽象）与产品品牌（实现）”“UI组件（抽象）与渲染引擎（实现）”“遥控器（抽象）与设备（实现）”，两者需独立扩展。

• 避免继承体系臃肿：当一个类的扩展方向超过一个时，继承会导致子类数量呈指数级增长（继承爆炸），桥接模式可通过组合替代继承，简化架构。

• 抽象与实现需解耦：例如跨平台开发中，“业务逻辑（抽象）”与“平台API（实现）”分离，适配不同操作系统（Windows、Linux、Mac），无需修改业务逻辑代码。

• 需要动态切换实现：需在运行时灵活切换对象的实现方式，例如视频播放器的“播放逻辑（抽象）”与“解码方式（实现）”，可动态切换硬解码、软解码。

• 复用现有实现：已有多个实现类，需在不修改其代码的前提下，为其提供统一的抽象接口，实现多实现的统一调用。

典型实战案例

• 图形界面框架：“窗口样式（抽象维度：普通窗口、弹窗、全屏窗口）”与“底层渲染（实现维度：DirectX、OpenGL、CPU渲染）”分离，支持灵活扩展。

• 数据库驱动：“数据库操作接口（抽象维度：查询、插入、删除）”与“不同数据库适配（实现维度：MySQL、PostgreSQL、Oracle）”分离，统一操作接口。

• 外设控制库：“控制逻辑（抽象维度：普通控制、智能控制）”与“外设协议（实现维度：蓝牙、WiFi、红外）”分离，适配不同类型外设。

• 日志框架：“日志操作（抽象维度：普通日志、异步日志）”与“日志输出方式（实现维度：文件输出、控制台输出、远程上报）”分离，支持动态切换输出方式。

五、总结

桥接模式的核心是“分离抽象与实现，通过组合实现解耦”，其本质是打破继承的强耦合枷锁，让两个独立变化的维度能够自由扩展、互不干扰。它不是为了简化代码，而是为了优化系统架构，提升系统的可扩展性和可维护性，尤其适用于复杂系统的多维度扩展场景。

从多语言实现来看，尽管语法形式差异显著，但核心逻辑高度统一，且适配不同语言的设计理念：

• 面向对象语言（C#、Python、C++）：依托接口/抽象类定义双维度规范，通过继承扩展抽象层，通过组合建立桥接，代码结构清晰、易维护；

• Go语言：遵循“组合优于继承”，通过接口定义实现化规范，通过结构体嵌套组合抽象层与实现层，极简且高效，贴合语言特性；

• 纯C语言：通过结构体+函数指针模拟面向对象特性，手动实现双维度分离与桥接，底层可控，适配嵌入式等资源受限场景。

在工程实践中，使用桥接模式需注意两点：一是明确识别系统的双独立维度，避免维度划分不当导致的架构冗余；二是避免过度使用，简单场景（无多维度扩展需求）下，直接使用继承或组合更简洁。当系统需要长期扩展、存在多维度变化时，桥接模式是平衡扩展性与耦合度的最优设计方案之一，是每一位开发者必备的架构设计工具。

适配器模式（Adapter Pattern）是软件工程中经典的结构型设计模式，其核心价值在于解决接口不兼容问题——将一个类或模块的接口，转换为客户端期望的另一种接口，使得原本因接口差异无法协同工作的组件，能够无缝集成、正常交互。类比现实场景，电源适配器可让不同插头规格的电器适配统一插座，而适配器模式正是软件世界中的“接口转换器”，是系统集成、遗留代码改造的核心工具。

一、适配器模式核心结构

适配器模式的设计围绕“接口转换”展开，核心包含四个角色，各角色分工明确、协同完成适配逻辑，确保客户端与适配者的解耦：

• 目标接口（Target）：客户端期望的标准接口，定义了客户端可直接调用的方法规范，是客户端与系统交互的统一入口。

• 适配者（Adaptee）：现有系统中已存在的组件（类/模块），其功能符合需求，但接口格式与目标接口不兼容，是需要被适配的核心对象。

• 适配器（Adapter）：模式的核心角色，一边实现目标接口，一边持有适配者的引用，负责将客户端的请求转换为适配者能识别的调用，完成接口适配。

• 客户（Client）：仅依赖目标接口进行交互，无需感知适配者的存在，也无需关注接口转换的细节，实现与适配者的完全解耦。

根据实现方式的不同，适配器模式分为两类，适配不同语言特性与业务场景：

• 类适配器：通过继承适配者、实现目标接口完成适配，依赖语言的多继承特性（如C++），耦合度略高，灵活性有限。

• 对象适配器：通过组合方式持有适配者实例、实现目标接口完成适配，不依赖继承，耦合度低、灵活性高，是更通用的实现方式（如C#、Python、Go、纯C）。

二、多语言实现适配器模式

不同语言因语法特性（如继承机制、接口定义、动态特性）差异，适配器模式的实现方式各有侧重，但核心逻辑一致——通过适配器完成接口转换。以下基于“第三方组件集成”的统一场景（支付、日志组件适配），实现C#、Python、Golang、C++、纯C五种语言的完整案例，均可直接编译运行。

2.1 C# 实现（对象适配器）

C# 不支持多继承，因此优先采用对象适配器模式，依托接口定义目标规范，通过组合方式持有适配者实例，兼顾解耦性与代码可读性，贴合.NET开发规范。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

using System;

// 目标接口：客户端期望的统一支付接口
public interface IPayment
{
    void Pay(double amount); // 统一支付方法，参数为支付金额
}

// 适配者：第三方支付宝SDK（接口不兼容，方法名、参数类型可能存在差异）
public class AlipaySDK
{
    // 第三方SDK的支付方法，参数为decimal类型，方法名与目标接口不一致
    public void DoAlipayPayment(decimal money)
    {
        Console.WriteLine($"支付宝支付：{money:F1} 元");
    }
}

// 适配器：将AlipaySDK适配为IPayment接口，完成接口转换
public class AlipayAdapter : IPayment
{
    // 组合适配者实例，实现松耦合
    private readonly AlipaySDK _alipaySDK;

    // 构造函数注入适配者，提升灵活性
    public AlipayAdapter(AlipaySDK alipaySDK)
    {
        _alipaySDK = alipaySDK;
    }

    // 实现目标接口的Pay方法，完成参数转换与方法转发
    public void Pay(double amount)
    {
        // 将客户端传入的double类型金额，转换为第三方SDK所需的decimal类型
        _alipaySDK.DoAlipayPayment(Convert.ToDecimal(amount));
    }
}

// 客户端调用：仅依赖目标接口，无需感知适配者细节
class Client
{
    static void Main(string[] args)
    {
        // 初始化适配者与适配器
        IPayment payment = new AlipayAdapter(new AlipaySDK());
        // 客户端直接调用目标接口方法，适配逻辑被适配器封装
        payment.Pay(100.5); // 输出：支付宝支付：100.5 元
    }
}

2.2 Python 实现（对象适配器）

Python 是动态语言，无需显式定义接口（遵循“鸭子类型”），通过类的组合实现对象适配器，代码简洁灵活，无需繁琐的类型声明，适配快速开发场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 目标接口（约定）：客户端期望的统一支付接口，定义pay方法
class PaymentTarget:
    def pay(self, amount):
        """统一支付方法，子类需实现该方法"""
        raise NotImplementedError("请实现pay方法以完成支付适配")

# 适配者：第三方微信支付SDK（接口不兼容，方法名与目标接口不一致）
class WeChatPaySDK:
    def do_wechat_pay(self, money):
        """第三方微信支付方法"""
        print(f"微信支付：{money:.1f} 元")

# 适配器：继承目标接口约定，组合适配者，完成接口转换
class WeChatPayAdapter(PaymentTarget):
    def __init__(self, wechat_sdk):
        # 组合适配者实例，实现松耦合
        self.wechat_sdk = wechat_sdk

    def pay(self, amount):
        """实现目标接口的pay方法，转发请求到适配者"""
        self.wechat_sdk.do_wechat_pay(amount)

# 客户端调用：仅与目标接口交互，无需关注适配细节
if __name__ == "__main__":
    # 初始化适配者与适配器
    payment = WeChatPayAdapter(WeChatPaySDK())
    # 调用统一支付方法
    payment.pay(200.8)  # 输出：微信支付：200.8 元

2.3 Go 实现（对象适配器）

Go 语言无类和继承概念，核心是“面向接口编程”，通过结构体组合适配者、实现目标接口完成适配，接口匹配遵循“鸭子类型”（只需方法签名一致），贴合Go语言极简、高效的设计哲学。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

package main

import "fmt"

// 目标接口：客户端期望的统一支付接口
type Payment interface {
     amount float64) // 统一支付方法，参数为float64类型
}

// 适配者：第三方银联支付SDK（接口不兼容，参数类型与目标接口不一致）
type UnionPaySDK struct{}

// 第三方SDK的支付方法，参数为float32类型
func (u *UnionPaySDK) DoUnionPay(money float32) {
  mt.Printf("银联支付：%.1f 元\n", money)
}

// 适配器：结构体组合适配者，实现目标接口
type UnionPayAdapter struct {
   ionPay *UnionPaySDK // 持有适配者实例
}

// 实现目标接口的Pay方法，完成参数转换与请求转发
func (a *UnionPayAdapter) Pay(amount float64) {
      户端传入的float64类型，转换为适配者所需的float32类型
  .unionPay.DoUnionPay(float32(amount))
}

// 客户端调用：依赖目标接口，解耦适配者
func main() {
 // 初始化适配器（注入适配者）
 var payment Payment = &UnionPayAdapter{unionPay: &UnionPaySDK{}}
  / 调用统一支付方法
 payment.Pay(300.6) // 输出：银联支付：300.6 元
}
             /                    a  // 将客     un      f   Pay(

2.4 C++ 实现（类适配器+对象适配器）

C++ 支持多继承，可同时实现类适配器与对象适配器。类适配器通过继承适配者和目标接口完成适配，耦合度略高；对象适配器通过组合实现，更推荐使用。以下重点展示类适配器，兼顾两种实现的特性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#include <iostream>
#include <string>
using namespace std;

// 目标接口：客户端期望的统一日志接口
class LogTarget {
public:
    // 纯虚函数，定义统一日志方法
    virtual void Log(string msg) = 0;
    // 虚析构函数，避免析构时内存泄漏
    virtual ~LogTarget() = default;
};

// 适配者：第三方文件日志SDK（接口不兼容，方法参数与目标接口不一致）
class FileLogSDK {
public:
    // 第三方日志方法，参数为const char*类型
    void WriteFileLog(const char* message) {
        cout << "文件日志：" << message << endl;
    }
};

// 类适配器：继承目标接口和适配者，完成接口转换
class FileLogAdapter : public LogTarget, public FileLogSDK {
public:
    // 实现目标接口的Log方法
    void Log(string msg) override {
        // 将string类型转换为const char*，调用适配者的日志方法
        WriteFileLog(msg.c_str());
    }
};

// 客户端调用：依赖目标接口，无需感知适配者
int main() {
    LogTarget* logger = new FileLogAdapter();
    logger->Log("系统启动成功，日志记录正常"); // 输出：文件日志：系统启动成功，日志记录正常
    delete logger; // 释放内存，避免泄漏
    return 0;
}

2.5 纯C语言实现（对象适配器）

纯C语言无类和接口概念，通过“结构体封装数据、函数指针模拟接口”，模拟面向对象的特性，实现对象适配器。核心是通过结构体组合适配者，用函数指针实现目标接口，手动完成请求转发，适配嵌入式、底层开发场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 目标接口：用函数指针模拟统一支付接口
typedef struct {
    // 目标接口方法：参数为适配器实例和支付金额
    void (*Pay)(void* adapter, float amount);
} PaymentInterface;

// 适配者：第三方苹果支付SDK（用结构体模拟“类”）
typedef struct {
    char name[20]; // SDK版本信息
} ApplePaySDK;

// 适配者的支付方法（模拟类的成员方法）
void ApplePaySDK_DoPay(ApplePaySDK* sdk, float money) {
    printf("苹果支付：%.1f 元（SDK版本：%s）\n", money, sdk->name);
}

// 适配器：结构体组合适配者，实现目标接口
typedef struct {
    PaymentInterface interface; // 目标接口（函数指针）
    ApplePaySDK* applePay;     // 组合适配者实例
} ApplePayAdapter;

// 适配器的Pay方法实现（目标接口的具体逻辑）
void ApplePayAdapter_Pay(void* adapter, float amount) {
    // 类型转换，获取适配器实例
    ApplePayAdapter* adapterObj = (ApplePayAdapter*)adapter;
    // 转发请求到适配者的支付方法
    ApplePaySDK_DoPay(adapterObj->applePay, amount);
}

// 客户端调用：通过函数指针调用目标接口
int main() {
    // 初始化适配者
    ApplePaySDK* applePay = (ApplePaySDK*)malloc(sizeof(ApplePaySDK));
    strcpy(applePay->name, "ApplePay v1.0");
    
    // 初始化适配器：绑定目标接口方法，关联适配者
    ApplePayAdapter* adapter = (ApplePayAdapter*)malloc(sizeof(ApplePayAdapter));
    adapter->interface.Pay = ApplePayAdapter_Pay;
    adapter->applePay = applePay;
    
    // 客户端调用目标接口，无需关注适配细节
    adapter->interface.Pay(adapter, 400.9); // 输出：苹果支付：400.9 元（SDK版本：ApplePay v1.0）
    
    // 释放内存，避免泄漏
    free(applePay);
    free(adapter);
    return 0;
}

三、适配器模式的优缺点

适配器模式的核心价值是“兼容旧接口、集成新组件”，其优缺点均围绕“接口转换”的核心逻辑展开，需结合业务场景权衡使用，避免过度设计。

3.1 核心优点

• 解决接口兼容问题：无需修改原有适配者代码和客户端代码，即可实现不兼容接口的协同工作，完全符合“开闭原则”，降低系统改造风险。

• 解耦客户端与适配者：客户端仅依赖目标接口，无需感知适配者的实现细节和接口差异，降低代码耦合度，提升系统可维护性。

• 复用现有组件：无需为适配新接口重写现有组件逻辑，充分复用已有代码（如第三方SDK、遗留系统组件），减少开发工作量。

• 灵活性高：可灵活替换不同的适配者，适配不同版本的第三方组件或遗留系统，无需修改客户端和目标接口，扩展成本低。

3.2 主要缺点

• 增加系统复杂度：引入适配器类/结构体后，会增加系统的代码量和类结构复杂度，提升代码理解和维护成本。

• 存在轻微性能损耗：适配过程中的参数转换、方法转发，会带来少量性能开销（通常可忽略，仅在高频调用场景下需关注）。

• 类适配器局限性强：类适配器依赖多继承，耦合度高于对象适配器，且受限于语言的继承特性（如C#、Java不支持多继承），灵活性不足。

• 适配逻辑维护成本高：若适配者接口发生变更，需同步修改适配器的转换逻辑，增加后期维护成本。

四、适配器模式的使用场景

适配器模式的核心适用场景是“接口不兼容但功能需复用”，尤其在系统集成、遗留代码改造、第三方组件引入等场景中，能发挥重要作用，具体如下：

• 集成第三方组件：项目引入第三方SDK（如支付、日志、缓存、地图组件），其接口格式与项目现有接口不兼容，无需修改SDK源码，通过适配器完成适配。

• 改造遗留系统：维护老旧系统时，需将遗留组件接入新的业务系统，无需重构遗留代码，通过适配器适配新系统的接口规范，降低改造风险。

• 多版本接口兼容：同一功能存在多个版本的接口（如API v1/v2），通过适配器统一对外暴露的接口，让客户端无需感知版本差异，提升兼容性。

• 跨语言交互：多语言协同开发的项目中，适配不同语言的接口规范（如C语言接口适配Go/Python的调用逻辑），实现跨语言组件的无缝集成。

• 单元测试场景：单元测试中，适配测试桩（Mock对象）到目标接口，模拟第三方依赖的行为，确保测试用例的独立性和可执行性。

典型实战案例

• 电商系统集成多种支付方式（支付宝、微信、银联），通过适配器统一支付接口，客户端无需区分支付类型；

• 日志系统适配不同的日志组件（文件日志、控制台日志、第三方日志服务），通过适配器统一日志输出接口；

• 旧系统迁移时，通过适配器让遗留模块适配新系统的接口，逐步替换旧组件，实现平滑过渡；

• 框架开发中，适配不同的数据库驱动（MySQL、PostgreSQL、Oracle），统一数据库操作接口，提升框架兼容性。

五、总结

适配器模式的核心是“接口转换”，本质是通过一个中间层（适配器），屏蔽接口差异，实现不兼容组件的协同工作，其核心价值在于“兼容现有代码、降低集成成本”，是系统扩展和重构的重要工具。

从多语言实现来看，尽管语法形式差异显著，但核心逻辑高度统一，且适配不同语言的特性：

• 面向对象语言（C#、Python、C++）：依托类、接口、继承/组合实现适配，其中对象适配器因耦合度低、灵活性高，成为主流实现方式；

• 静态语言（Go、C++、C#）：需关注类型转换和接口匹配，代码严谨性高，适合高性能、企业级开发场景；

• 动态语言（Python）：无需显式定义接口，适配逻辑更简洁，适合快速开发、迭代场景；

• 过程式语言（纯C）：通过结构体+函数指针模拟面向对象特性，实现适配逻辑，代码冗余但底层可控，适合嵌入式、底层开发场景。

在工程实践中，使用适配器模式需注意两点：一是优先选择对象适配器，降低代码耦合度；二是避免过度使用——若接口差异过大，或适配逻辑过于复杂，重构接口可能比引入适配器更高效。适配器模式并非万能，但在接口兼容、组件集成场景中，能有效提升系统的复用性、扩展性和可维护性，是每一位开发者都应掌握的设计模式。

原型模式是一种创建型设计模式，其核心思想是通过复制已有对象（原型）来创建新对象，而非通过构造函数从头初始化。这种模式能有效减少重复初始化的开销，尤其适用于创建复杂对象或大量相似对象的场景。本文将从核心结构、多语言实现、优缺点、使用场景等维度全面解析原型模式。

一、原型模式核心结构

原型模式的核心包含两个关键角色，同时需重点区分浅拷贝与深拷贝，这是原型模式的核心要点：

1.1 核心角色

• 抽象原型（Prototype）：定义克隆自身的接口，通常包含一个Clone方法，声明对象拷贝的规范，是所有具体原型的公共约束。

• 具体原型（Concrete Prototype）：实现抽象原型的Clone方法，完成自身的拷贝逻辑，根据需求实现浅拷贝或深拷贝。

1.2 核心概念：浅拷贝与深拷贝

原型模式的核心差异的在于拷贝的深度，直接决定新旧对象的独立性：

• 浅拷贝：仅复制对象本身及基本类型成员，引用类型成员（如指针、对象引用）仅复制引用地址，新旧对象共享同一引用对象，一方修改会影响另一方。

• 深拷贝：完全复制对象及所有嵌套的引用类型成员，为每个引用类型成员重新分配内存并复制内容，新旧对象相互独立，修改互不影响。

二、多语言实现原型模式

不同语言因语法特性、内置工具差异，原型模式的实现方式各有侧重，以下结合C#、Python、Golang、C++、纯C五种语言，实现统一场景（拷贝包含引用类型成员的Person对象），清晰展示深浅拷贝的实现逻辑。

2.1 C# 实现（内置接口+序列化）

C# 内置ICloneable接口作为抽象原型，通过MemberwiseClone实现浅拷贝，深拷贝可借助序列化快速实现，无需手动处理嵌套引用，适配面向对象开发场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

// 抽象原型接口（复用系统内置ICloneable，简化开发）
public interface IPrototype : ICloneable { }

// 具体原型（包含引用类型成员）
[Serializable] // 深拷贝需添加序列化标记，否则无法序列化引用类型
public class Person : IPrototype
{
    public string Name { get; set; }
    public int Age { get; set; }
    public Address Address { get; set; } // 引用类型成员（嵌套对象）

    // 浅拷贝实现：调用系统内置方法，仅拷贝值类型和引用地址
    public object Clone()
    {
        return this.MemberwiseClone(); // 内置浅拷贝方法，高效简洁
    }

    // 深拷贝实现：通过二进制序列化/反序列化，自动处理嵌套引用
    public Person DeepClone()
    {
        using (var ms = new MemoryStream())
        {
            var formatter = new BinaryFormatter();
            formatter.Serialize(ms, this); // 序列化对象
            ms.Position = 0; // 重置流位置
            return (Person)formatter.Deserialize(ms); // 反序列化生成新对象
        }
    }
}

// 引用类型成员（需同步添加序列化标记）
[Serializable]
public class Address
{
    public string City { get; set; }
    public string Street { get; set; }
}

// 测试代码（验证深浅拷贝效果）
class Program
{
    static void Main()
    {
        // 初始化原型对象
        var prototype = new Person
        {
            Name = "张三",
            Age = 25,
            Address = new Address { City = "北京", Street = "朝阳路" }
        };

        // 浅拷贝测试
        var shallowCopy = (Person)prototype.Clone();
        shallowCopy.Address.City = "上海"; // 修改引用成员
        Console.WriteLine($"浅拷贝后原型地址：{prototype.Address.City}"); // 输出：上海（原型受影响）

        // 深拷贝测试
        var deepCopy = prototype.DeepClone();
        deepCopy.Address.City = "广州"; // 修改引用成员
        Console.WriteLine($"深拷贝后原型地址：{prototype.Address.City}"); // 输出：上海（原型不受影响）
    }
}

2.2 Python 实现（内置copy模块）

Python 遵循“鸭子类型”，无需显式定义抽象原型接口，copy模块内置copy()（浅拷贝）和deepcopy()（深拷贝）方法，可直接复用，大幅简化代码，适配快速开发场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

import copy

# 引用类型：地址类
class Address:
    def __init__(self, city, street):
        self.city = city
        self.street = street

# 具体原型类：人员类
class Person:
    def __init__(self, name, age, address):
        self.name = name  # 基本类型
        self.age = age    # 基本类型
        self.address = address  # 引用类型成员

    # 浅拷贝方法：复用copy模块
    def shallow_clone(self):
        return copy.copy(self)

    # 深拷贝方法：复用copy模块，自动处理嵌套引用
    def deep_clone(self):
        return copy.deepcopy(self)

# 测试代码
if __name__ == "__main__":
    # 初始化原型对象
    prototype = Person("张三", 25, Address("北京", "朝阳路"))

    # 浅拷贝验证
    shallow_copy = prototype.shallow_clone()
    shallow_copy.address.city = "上海"
    print(f"浅拷贝后原型地址：{prototype.address.city}")  # 输出：上海

    # 深拷贝验证
    deep_copy = prototype.deep_clone()
    deep_copy.address.city = "广州"
    print(f"深拷贝后原型地址：{prototype.address.city}")  # 输出：上海

2.3 Golang 实现（结构体方法+序列化）

Golang 无类和继承，通过结构体模拟原型，浅拷贝可通过结构体值传递实现，深拷贝可借助JSON序列化实现通用逻辑，兼顾简洁性与性能，符合Go语言极简设计哲学。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

package main

import (
    coding/json"
  fmt"
)

// 引用类型：地址结构体
type Address struct {
    y   string
     et string
}

// 具体原型：人员结构体
type Person struct {
    e    string
 Age     int
         *Address // 指针类型（引用类型）
}

// 浅拷贝：结构体值传递，指针成员仅复制地址
func (p *Person) ShallowClone() *Person {
     e := *p // 值拷贝，指针成员仍指向原地址
  eturn &clone
}

// 深拷贝：通过JSON序列化/反序列化，通用且无需手动处理嵌套
func (p *Person) DeepClone() (*Person, error) {
    序列化原对象
 data, err := json.Marshal(p)
      r != nil {
   eturn nil, err
        序列化生成新对象
   r clone Person
        ern.Unmarshal(data, &clone)
  f err != nil {
  return nil, err
      turn &clone, nil
}

func main() {
  / 初始化原型对象
 prototype := &Person{
  Name: "张三",
   ge:  25,
   ddress: &Address{
   City:   "北京",
    treet: "朝阳路",
      }

  / 浅拷贝测试
 shallowCopy := prototype.ShallowClone()
 shallowCopy.Address.City = "上海"
 fmt.Printf("浅拷贝后原型地址：%s\n", prototype.Address.City) // 输出：上海

  / 深拷贝测试
    pCopy, _ := prototype.DeepClone()
 deepCopy.Address.City = "广州"
 fmt.Printf("深拷贝后原型地址：%s\n", prototype.Address.City) // 输出：上海
}
                  dee      /                           /          },
                     S                                  A             A                                  /  }
        re                    ir = jso     va}
        // 反             r  if er            //      r   clonAddress           Nam   Stre    Cit      "    "en

2.4 C++ 实现（拷贝构造函数）

C++ 通过拷贝构造函数实现原型模式，默认拷贝构造为浅拷贝，深拷贝需手动重载拷贝构造函数或自定义克隆方法，需注意内存管理，避免内存泄漏，适配高性能底层开发场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

#include <iostream>
#include <string>
using namespace std;

// 引用类型：地址类
class Address {
public:
    string city;
    string street;
    // 构造函数
    Address(string c, string s) : city(c), street(s) {}
};

// 具体原型：人员类
class Person {
private:
    string name;
    int age;
    Address* address; // 指针（引用类型）
public:
    // 构造函数
    Person(string n, int a, Address* addr) : name(n), age(a), address(addr) {}

    // 浅拷贝构造函数（默认行为，仅复制指针）
    Person(const Person& other) {
        this->name = other.name;
        this->age = other.age;
        this->address = other.address; // 共享指针，浅拷贝
    }

    // 深拷贝方法：手动创建新的引用对象，实现完全拷贝
    Person* DeepClone() {
        Address* newAddr = new Address(this->address->city, this->address->street);
        return new Person(this->name, this->age, newAddr);
    }

    // 析构函数：释放内存，避免泄漏
    ~Person() {
        delete address;
    }

    // 辅助方法：修改地址城市
    void setCity(string c) {
        this->address->city = c;
    }

    // 辅助方法：获取地址城市
    string getCity() {
        return this->address->city;
    }
};

// 测试代码
int main() {
    // 初始化原型对象
    Address* addr = new Address("北京", "朝阳路");
    Person* prototype = new Person("张三", 25, addr);

    // 浅拷贝测试
    Person shallowCopy = *prototype; // 调用浅拷贝构造函数
    shallowCopy.setCity("上海");
    cout << "浅拷贝后原型地址：" << prototype->getCity() << endl; // 输出：上海

    // 深拷贝测试
    Person* deepCopy = prototype->DeepClone();
    deepCopy->setCity("广州");
    cout << "深拷贝后原型地址：" << prototype->getCity() << endl; // 输出：上海

    // 释放内存
    delete prototype;
    delete deepCopy;
    return 0;
}

2.5 纯C语言实现（结构体+函数模拟）

纯C语言无面向对象特性，通过结构体封装数据，函数模拟克隆行为，深浅拷贝均需手动处理指针和内存分配，代码冗余但底层可控，适配嵌入式、底层开发场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 引用类型：地址结构体
typedef struct {
    char* city;
    char* street;
} Address;

// 具体原型：人员结构体
typedef struct {
    char* name;
    int age;
    Address* address;
} Person;

// 工具函数：初始化Address
Address* address_init(const char* city, const char* street) {
    Address* addr = (Address*)malloc(sizeof(Address));
    addr->city = (char*)malloc(strlen(city) + 1);
    strcpy(addr->city, city);
    addr->street = (char*)malloc(strlen(street) + 1);
    strcpy(addr->street, street);
    return addr;
}

// 工具函数：初始化Person
Person* person_init(const char* name, int age, Address* addr) {
    Person* p = (Person*)malloc(sizeof(Person));
    p->name = (char*)malloc(strlen(name) + 1);
    strcpy(p->name, name);
    p->age = age;
    p->address = addr;
    return p;
}

// 浅拷贝函数：仅复制结构体，共享指针成员
Person* person_shallow_clone(Person* p) {
    Person* clone = (Person*)malloc(sizeof(Person));
    clone->name = p->name; // 共享字符串指针
    clone->age = p->age;   // 复制基本类型
    clone->address = p->address; // 共享Address指针
    return clone;
}

// 深拷贝函数：手动复制所有指针成员，分配新内存
Person* person_deep_clone(Person* p) {
    // 深拷贝Address
    Address* newAddr = (Address*)malloc(sizeof(Address));
    newAddr->city = (char*)malloc(strlen(p->address->city) + 1);
    strcpy(newAddr->city, p->address->city);
    newAddr->street = (char*)malloc(strlen(p->address->street) + 1);
    strcpy(newAddr->street, p->address->street);

    // 深拷贝Person
    Person* clone = (Person*)malloc(sizeof(Person));
    clone->name = (char*)malloc(strlen(p->name) + 1);
    strcpy(clone->name, p->name);
    clone->age = p->age;
    clone->address = newAddr;
    return clone;
}

// 工具函数：释放Person内存
void person_free(Person* p) {
    free(p->name);
    free(p->address->city);
    free(p->address->street);
    free(p->address);
    free(p);
}

// 测试代码
int main() {
    // 初始化原型对象
    Address* addr = address_init("北京", "朝阳路");
    Person* prototype = person_init("张三", 25, addr);

    // 浅拷贝测试
    Person* shallowCopy = person_shallow_clone(prototype);
    // 修改浅拷贝对象的引用成员（需先释放原内存，避免内存泄漏）
    free(shallowCopy->address->city);
    shallowCopy->address->city = (char*)malloc(strlen("上海") + 1);
    strcpy(shallowCopy->address->city, "上海");
    printf("浅拷贝后原型地址：%s\n", prototype->address->city); // 输出：上海

    // 深拷贝测试
    Person* deepCopy = person_deep_clone(prototype);
    free(deepCopy->address->city);
    deepCopy->address->city = (char*)malloc(strlen("广州") + 1);
    strcpy(deepCopy->address->city, "广州");
    printf("深拷贝后原型地址：%s\n", prototype->address->city); // 输出：上海

    // 释放内存
    person_free(prototype);
    free(shallowCopy); // 浅拷贝仅释放结构体，不释放共享指针
    person_free(deepCopy);

    return 0;
}

三、原型模式的优缺点

原型模式的价值与局限均围绕“拷贝替代创建”的核心逻辑，需结合场景权衡使用，避免过度设计。

3.1 核心优点

• 降低对象创建开销：对于初始化成本高的对象（如数据库连接、大文件解析、复杂计算对象），拷贝比重新初始化更高效，减少重复操作。

• 简化对象创建逻辑：无需关注构造函数的参数、访问权限等限制，直接复制已有原型对象，降低创建复杂度，提升开发效率。

• 支持动态扩展：可在运行时动态修改原型对象，生成不同变体的新对象，无需修改原有代码，符合“开闭原则”。

• 保护原型状态：深拷贝可保留原型对象的初始状态，新对象的修改不会影响原型，适用于需要基准模板的场景。

3.2 主要缺点

• 深拷贝实现复杂：嵌套引用类型越多，深拷贝逻辑越繁琐，易出现内存泄漏（如C/C++）、循环引用（如Python）等问题，增加开发难度。

• 维护成本较高：当原型对象的属性或结构发生变更时，需同步修改拷贝逻辑（尤其是深拷贝），否则会出现拷贝不完整的问题。

• 性能损耗差异：深拷贝涉及大量内存复制，在高频拷贝、大对象拷贝场景下，性能损耗明显高于浅拷贝和直接创建。

• 非面向对象语言适配差：纯C等无面向对象特性的语言，需手动模拟原型结构和拷贝逻辑，代码冗余度高，维护不便。

四、原型模式的使用场景

原型模式的核心适用场景是“对象创建成本高、需批量生成相似对象”，同时需根据引用类型的存在与否，选择浅拷贝或深拷贝。

• 对象创建成本高：如创建包含大量数据的缓存对象、需频繁读取文件/数据库的配置对象、经过复杂计算初始化的对象。

• 批量生成相似对象：如游戏中的角色、粒子系统、NPC，电商系统中的批量订单，仅属性略有差异，通过拷贝原型可快速生成。

• 动态生成对象变体：如根据模板生成不同主题的UI组件、不同配置的接口请求对象，无需重复编写初始化逻辑。

• 避免构造函数耦合：当对象构造逻辑复杂，且创建逻辑需与业务逻辑隔离时，拷贝原型可降低代码耦合度。

• 浅拷贝适用场景：对象无引用类型成员，或引用成员为只读数据、无需独立修改，追求拷贝效率。

• 深拷贝适用场景：对象包含嵌套引用类型，且新旧对象需完全独立（如多线程操作、对象修改不影响原型、需保留基准状态）。

典型实战案例

• 设计工具的“复制粘贴”功能（如PS图层、Axure组件），本质是原型模式的浅拷贝/深拷贝应用；

• 数据库连接池中的连接对象克隆，避免频繁创建/关闭连接，提升数据库访问性能；

• 序列化/反序列化场景（如JSON、二进制序列化），核心是深拷贝的实现，用于对象传输、持久化；

• 游戏开发中的角色实例生成，通过原型拷贝快速创建大量相似角色，仅修改属性（如血量、攻击力）。

五、总结

原型模式以“拷贝替代创建”为核心，核心价值在于平衡对象创建的性能与复杂度，其核心难点是深浅拷贝的选择与实现。不同语言的实现方式，反映了语言本身的设计理念和适用场景：

• 高级面向对象语言（C#、Python）：提供内置工具（接口、模块）简化拷贝逻辑，深拷贝可通过序列化快速实现，开发效率高；

• 静态语言（Golang）：通过结构体方法+序列化实现通用拷贝，兼顾简洁性与性能，贴合语言极简特性；

• 编译型语言（C++）：需手动管理拷贝构造函数和内存，深拷贝实现灵活但易出错，适配高性能底层开发；

• 纯C语言：通过结构体+函数模拟原型模式，代码冗余但底层可控，适用于嵌入式等资源受限场景。

在工程实践中，原型模式并非万能，需注意：浅拷贝虽高效但存在数据共享风险，深拷贝虽安全但性能开销较高；当对象结构简单、创建成本低时，直接使用构造函数更简洁。原型模式可与工厂模式、单例模式协同使用（如单例管理原型对象，工厂负责克隆分发），最大化发挥其价值，成为优化复杂对象创建流程的重要工具。

在软件开发中，创建复杂对象往往需要经历多个步骤，且不同场景下对象的组件配置、构建顺序可能存在差异。建造者模式（Builder Pattern）作为经典的创建型设计模式，核心价值在于将复杂对象的构建过程与最终表示分离，让相同的构建流程能生成不同的产品形态，同时屏蔽底层构建细节，大幅提升代码的灵活性与可维护性。

一、建造者模式核心结构

建造者模式通过分层设计解耦对象构建逻辑，其经典结构包含5个核心角色，各角色分工明确、协同完成复杂对象的创建，确保构建过程的规范性与灵活性。

1.1 核心角色及职责

1.2 核心设计思想

建造者模式的核心逻辑的是“分离构建与表示”：客户端只需指定具体建造者的类型，指挥者便会按照预设流程调用建造者的组件构建方法，无需关注组件如何组装、顺序如何安排，即可生成不同配置的产品。这种设计既保证了构建流程的规范性，又实现了产品变体的灵活扩展。

二、多语言实现建造者模式

为便于跨语言对比理解，本文以“构建不同配置的电脑”为统一场景（产品：电脑；具体建造者：游戏电脑建造者、办公电脑建造者；指挥者：电脑组装指挥者），分别通过C#、Python、Golang、C++、纯C语言实现建造者模式，贴合各语言特性与工程实践规范，所有代码均可直接编译运行。

2.1 C# 实现（抽象类+继承，经典面向对象落地）

C#作为强类型面向对象语言，完全契合建造者模式的经典类结构，通过抽象类定义建造规范，子类实现具体构建逻辑，具备良好的类型安全性和代码可读性，适合企业级系统开发。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

using System;

// 产品：电脑（封装核心组件）
public class Computer
{
    public string CPU { get; set; }
    public string RAM { get; set; }
    public string HardDisk { get; set; }

    // 重写ToString，便于展示产品配置
    public override string ToString()
    {
        return $"电脑配置：CPU={CPU}，内存={RAM}，硬盘={HardDisk}";
    }
}

// 抽象建造者：定义电脑构建的统一接口
public abstract class ComputerBuilder
{
    protected Computer _computer = new Computer(); // 持有产品实例，供子类操作
    public abstract void BuildCPU();   // 构建CPU组件
    public abstract void BuildRAM();   // 构建内存组件
    public abstract void BuildHardDisk(); // 构建硬盘组件
    public Computer GetComputer() => _computer; // 返回构建完成的产品
}

// 具体建造者1：游戏电脑建造者（高性能配置）
public class GamingComputerBuilder : ComputerBuilder
{
    public override void BuildCPU() => _computer.CPU = "Intel i9-14900K";
    public override void BuildRAM() => _computer.RAM = "32GB DDR5 6400";
    public override void BuildHardDisk() => _computer.HardDisk = "2TB NVMe PCIe4.0";
}

// 具体建造者2：办公电脑建造者（高性价比配置）
public class OfficeComputerBuilder : ComputerBuilder
{
    public override void BuildCPU() => _computer.CPU = "Intel i5-13400";
    public override void BuildRAM() => _computer.RAM = "16GB DDR4 3200";
    public override void BuildHardDisk() => _computer.HardDisk = "1TB SATA3 SSD";
}

// 指挥者：控制电脑构建的流程顺序
public class ComputerDirector
{
    // 统一构建流程，屏蔽底层实现细节
    public Computer Construct(ComputerBuilder builder)
    {
        builder.BuildCPU(); // 优先构建核心CPU
        builder.BuildRAM(); // 其次构建内存
        builder.BuildHardDisk(); // 最后构建存储设备
        return builder.GetComputer();
    }
}

// 客户端调用示例
class Program
{
    static void Main(string[] args)
    {
        ComputerDirector director = new ComputerDirector();
        
        // 构建游戏电脑
        ComputerBuilder gamingBuilder = new GamingComputerBuilder();
        Computer gamingPC = director.Construct(gamingBuilder);
        Console.WriteLine(gamingPC);

        // 切换建造者，构建办公电脑（无需修改其他逻辑）
        ComputerBuilder officeBuilder = new OfficeComputerBuilder();
        Computer officePC = director.Construct(officeBuilder);
        Console.WriteLine(officePC);
    }
}

2.2 Python 实现（动态特性+极简设计）

Python无严格的抽象类语法，通过基类抛出异常实现“抽象接口”的约束，结合动态语言的灵活性简化代码，无需繁琐的类型声明，兼顾可读性与开发效率，适合快速迭代场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

# 产品：电脑
class Computer:
    def __init__(self):
        self.cpu = None  # CPU组件
        self.ram = None  # 内存组件
        self.hard_disk = None  # 硬盘组件

    def __str__(self):
        return f"电脑配置：CPU={self.cpu}，内存={self.ram}，硬盘={self.hard_disk}"

# 抽象建造者（基类，定义规范）
class ComputerBuilder:
    def __init__(self):
        self.computer = Computer()  # 初始化产品实例

    def build_cpu(self):
        # 抽象方法，子类必须实现
        raise NotImplementedError("子类必须重写build_cpu方法，实现CPU构建逻辑")

    def build_ram(self):
        raise NotImplementedError("子类必须重写build_ram方法，实现内存构建逻辑")

    def build_hard_disk(self):
        raise NotImplementedError("子类必须重写build_hard_disk方法，实现硬盘构建逻辑")

    def get_computer(self):
        # 返回构建完成的产品
        return self.computer

# 具体建造者1：游戏电脑建造者
class GamingComputerBuilder(ComputerBuilder):
    def build_cpu(self):
        self.computer.cpu = "AMD Ryzen 9 7950X"

    def build_ram(self):
        self.computer.ram = "64GB DDR5 6000"

    def build_hard_disk(self):
        self.computer.hard_disk = "4TB NVMe PCIe5.0"

# 具体建造者2：办公电脑建造者
class OfficeComputerBuilder(ComputerBuilder):
    def build_cpu(self):
        self.computer.cpu = "AMD Ryzen 5 7600"

    def build_ram(self):
        self.computer.ram = "8GB DDR4 3200"

    def build_hard_disk(self):
        self.computer.hard_disk = "512GB SATA3 SSD"

# 指挥者：静态方法简化调用，控制构建流程
class ComputerDirector:
    @staticmethod
    def construct(builder):
        # 固定构建顺序，确保组件兼容性
        builder.build_cpu()
        builder.build_ram()
        builder.build_hard_disk()
        return builder.get_computer()

# 客户端调用
if __name__ == "__main__":
    # 构建游戏电脑
    gaming_builder = GamingComputerBuilder()
    gaming_pc = ComputerDirector.construct(gaming_builder)
    print(gaming_pc)

    # 构建办公电脑
    office_builder = OfficeComputerBuilder()
    office_pc = ComputerDirector.construct(office_builder)
    print(office_pc)

2.3 Golang 实现（接口+结构体，面向接口编程）

Golang无类和继承特性，核心是“面向接口编程”，通过接口定义建造者规范，结构体实现接口方法，贴合Go语言“极简、高效”的设计哲学，代码无冗余、执行效率高。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

package main

import "fmt"

// 产品：电脑（封装核心组件）
type Computer struct {
	CPU      string // 中央处理器
	RAM      string // 内存
	HardDisk string // 硬盘
}

// 自定义String方法，用于展示产品配置
func (c *Computer) String() string {
	return fmt.Sprintf("电脑配置：CPU=%s，内存=%s，硬盘=%s", c.CPU, c.RAM, c.HardDisk)
}

// 抽象建造者：接口定义电脑构建的规范
type ComputerBuilder interface {
	BuildCPU()        // 构建CPU
	BuildRAM()        // 构建内存
	BuildHardDisk()   // 构建硬盘
	GetComputer() *Computer // 获取成品电脑
}

// 具体建造者1：游戏电脑建造者
type GamingComputerBuilder struct {
	computer *Computer // 持有产品实例
}

// 初始化游戏电脑建造者
func NewGamingComputerBuilder() *GamingComputerBuilder {
	return &GamingComputerBuilder{computer: &Computer{}}
}

func (g *GamingComputerBuilder) BuildCPU() {
	g.computer.CPU = "Intel i7-14700KF"
}

func (g *GamingComputerBuilder) BuildRAM() {
	g.computer.RAM = "48GB DDR5 6200"
}

func (g *GamingComputerBuilder) BuildHardDisk() {
	g.computer.HardDisk = "2TB NVMe PCIe4.0"
}

func (g *GamingComputerBuilder) GetComputer() *Computer {
	return g.computer
}

// 具体建造者2：办公电脑建造者
type OfficeComputerBuilder struct {
	computer *Computer // 持有产品实例
}

// 初始化办公电脑建造者
func NewOfficeComputerBuilder() *OfficeComputerBuilder {
	return &OfficeComputerBuilder{computer: &Computer{}}
}

func (o *OfficeComputerBuilder) BuildCPU() {
	o.computer.CPU = "Intel i3-12100"
}

func (o *OfficeComputerBuilder) BuildRAM() {
	o.computer.RAM = "8GB DDR4 2666"
}

func (o *OfficeComputerBuilder) BuildHardDisk() {
	o.computer.HardDisk = "512GB SATA3 SSD"
}

func (o *OfficeComputerBuilder) GetComputer() *Computer {
	return o.computer
}

// 指挥者：控制构建流程，解耦客户端与建造细节
type ComputerDirector struct{}

func (d *ComputerDirector) Construct(builder ComputerBuilder) *Computer {
	// 按固定顺序调用构建方法
	builder.BuildCPU()
	builder.BuildRAM()
	builder.BuildHardDisk()
	return builder.GetComputer()
}

// 客户端调用
func main() {
	director := &ComputerDirector{}
	
	// 构建游戏电脑
	gamingBuilder := NewGamingComputerBuilder()
	gamingPC := director.Construct(gamingBuilder)
	fmt.Println(gamingPC)

	// 构建办公电脑
	officeBuilder := NewOfficeComputerBuilder()
	officePC := director.Construct(officeBuilder)
	fmt.Println(officePC)
}

2.4 C++ 实现（抽象类+多态，高性能落地）

C++通过纯虚函数定义抽象建造者接口，子类继承并实现具体构建逻辑，需注意定义虚析构函数以避免内存泄漏，兼顾多态特性与性能，适合高性能、底层开发场景，是建造者模式的经典落地方式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

#include <iostream>
#include <string>
using namespace std;

// 产品：电脑
class Computer {
private:
    string cpu;    // CPU组件
    string ram;    // 内存组件
    string hardDisk; // 硬盘组件
public:
    // 设置组件的setter方法
    void setCPU(string cpu) { this->cpu = cpu; }
    void setRAM(string ram) { this->ram = ram; }
    void setHardDisk(string hardDisk) { this->hardDisk = hardDisk; }
    
    // 展示产品配置
    string toString() {
        return "电脑配置：CPU=" + cpu + "，内存=" + ram + "，硬盘=" + hardDisk;
    }
};

// 抽象建造者：抽象类定义构建接口
class ComputerBuilder {
protected:
    Computer* computer; // 持有产品实例
public:
    ComputerBuilder() { computer = new Computer(); }
    virtual ~ComputerBuilder() { delete computer; } // 虚析构函数，避免内存泄漏
    virtual void buildCPU() = 0; // 纯虚函数，强制子类实现
    virtual void buildRAM() = 0;
    virtual void buildHardDisk() = 0;
    Computer* getComputer() { return computer; } // 返回成品
};

// 具体建造者1：游戏电脑建造者
class GamingComputerBuilder : public ComputerBuilder {
public:
    void buildCPU() override { computer->setCPU("AMD Ryzen 7 7800X3D"); }
    void buildRAM() override { computer->setRAM("32GB DDR5 5600"); }
    void buildHardDisk() override { computer->setHardDisk("2TB NVMe PCIe4.0"); }
};

// 具体建造者2：办公电脑建造者
class OfficeComputerBuilder : public ComputerBuilder {
public:
    void buildCPU() override { computer->setCPU("AMD Ryzen 3 7300X"); }
    void buildRAM() override { computer->setRAM("16GB DDR4 3200"); }
    void buildHardDisk() override { computer->setHardDisk("1TB SATA3 HDD"); }
};

// 指挥者：控制构建流程
class ComputerDirector {
public:
    Computer* construct(ComputerBuilder* builder) {
        // 按顺序调用构建方法，确保组件正常组装
        builder->buildCPU();
        builder->buildRAM();
        builder->buildHardDisk();
        return builder->getComputer();
    }
};

// 客户端调用
int main() {
    ComputerDirector director;
    
    // 构建游戏电脑
    ComputerBuilder* gamingBuilder = new GamingComputerBuilder();
    Computer* gamingPC = director.construct(gamingBuilder);
    cout << gamingPC->toString() << endl;

    // 构建办公电脑
    ComputerBuilder* officeBuilder = new OfficeComputerBuilder();
    Computer* officePC = director.construct(officeBuilder);
    cout << officePC->toString() << endl;

    // 释放内存，避免泄漏
    delete gamingBuilder;
    delete officeBuilder;
    delete gamingPC;
    delete officePC;
    return 0;
}

2.5 纯C语言实现（结构体+函数指针，模拟面向对象）

纯C语言无面向对象特性，通过“结构体封装数据、函数指针封装行为”模拟抽象建造者和多态特性，核心是解耦构建流程与组件实现，代码轻量化、执行高效，适合嵌入式、底层开发场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 产品：电脑（结构体封装核心组件）
typedef struct {
    char cpu[32];      // CPU组件
    char ram[32];      // 内存组件
    char hard_disk[32];// 硬盘组件
} Computer;

// 抽象建造者：函数指针模拟构建行为，定义统一规范
typedef struct {
    Computer* computer;
    void (*build_cpu)(struct ComputerBuilder*);    // 构建CPU的函数指针
    void (*build_ram)(struct ComputerBuilder*);    // 构建内存的函数指针
    void (*build_hard_disk)(struct ComputerBuilder*); // 构建硬盘的函数指针
} ComputerBuilder;

// 具体建造者1：游戏电脑建造者（组合抽象建造者，模拟继承）
typedef struct {
    ComputerBuilder builder;
} GamingComputerBuilder;

// 游戏电脑CPU构建逻辑
void gaming_build_cpu(ComputerBuilder* b) {
    strcpy(b->computer->cpu, "Intel i9-14900KF");
}

// 游戏电脑内存构建逻辑
void gaming_build_ram(ComputerBuilder* b) {
    strcpy(b->computer->ram, "64GB DDR5 6400");
}

// 游戏电脑硬盘构建逻辑
void gaming_build_hard_disk(ComputerBuilder* b) {
    strcpy(b->computer->hard_disk, "4TB NVMe PCIe5.0");
}

// 初始化游戏电脑建造者（绑定函数指针，完成初始化）
GamingComputerBuilder* new_gaming_builder() {
    GamingComputerBuilder* builder = (GamingComputerBuilder*)malloc(sizeof(GamingComputerBuilder));
    builder->builder.computer = (Computer*)malloc(sizeof(Computer));
    builder->builder.build_cpu = gaming_build_cpu;
    builder->builder.build_ram = gaming_build_ram;
    builder->builder.build_hard_disk = gaming_build_hard_disk;
    return builder;
}

// 具体建造者2：办公电脑建造者（组合抽象建造者，模拟继承）
typedef struct {
    ComputerBuilder builder;
} OfficeComputerBuilder;

// 办公电脑CPU构建逻辑
void office_build_cpu(ComputerBuilder* b) {
    strcpy(b->computer->cpu, "Intel i5-12400");
}

// 办公电脑内存构建逻辑
void office_build_ram(ComputerBuilder* b) {
    strcpy(b->computer->ram, "16GB DDR4 3200");
}

// 办公电脑硬盘构建逻辑
void office_build_hard_disk(ComputerBuilder* b) {
    strcpy(b->computer->hard_disk, "1TB SATA3 SSD");
}

// 初始化办公电脑建造者
OfficeComputerBuilder* new_office_builder() {
    OfficeComputerBuilder* builder = (OfficeComputerBuilder*)malloc(sizeof(OfficeComputerBuilder));
    builder->builder.computer = (Computer*)malloc(sizeof(Computer));
    builder->builder.build_cpu = office_build_cpu;
    builder->builder.build_ram = office_build_ram;
    builder->builder.build_hard_disk = office_build_hard_disk;
    return builder;
}

// 指挥者：控制构建流程，调用建造者的构建方法
Computer* construct(ComputerBuilder* builder) {
    builder->build_cpu(builder);
    builder->build_ram(builder);
    builder->build_hard_disk(builder);
    return builder->computer;
}

// 打印电脑配置
void print_computer(Computer* pc) {
    printf("电脑配置：CPU=%s，内存=%s，硬盘=%s\n", pc->cpu, pc->ram, pc->hard_disk);
}

// 客户端调用
int main() {
    // 构建游戏电脑
    GamingComputerBuilder* gaming_builder = new_gaming_builder();
    Computer* gaming_pc = construct(&gaming_builder->builder);
    print_computer(gaming_pc);

    // 构建办公电脑
    OfficeComputerBuilder* office_builder = new_office_builder();
    Computer* office_pc = construct(&office_builder->builder);
    print_computer(office_pc);

    // 释放内存，避免泄漏
    free(gaming_builder->builder.computer);
    free(gaming_builder);
    free(office_builder->builder.computer);
    free(office_builder);
    free(gaming_pc);
    free(office_pc);
    return 0;
}

三、建造者模式的优缺点

建造者模式是为解决复杂对象构建问题而生的，其优势与劣势均源于“分离构建与表示”的设计思路，需结合实际业务场景权衡使用。

3.1 核心优点

• 解耦构建与表示：产品的内部结构、组件组装逻辑封装在具体建造者中，产品结构变化时仅需修改建造者，无需改动指挥者和客户端，完全符合“开闭原则”。

• 灵活扩展产品变体：替换具体建造者即可快速生成不同配置的产品，无需修改构建流程，适配多变体产品的创建需求，降低扩展成本。

• 精细化控制构建过程：指挥者统一管理构建步骤，可实现分步构建、暂停/恢复构建，甚至动态调整组件配置，适用于需逐步组装的复杂对象。

• 提升代码可维护性：客户端无需关注复杂的构建细节，只需指定建造者类型，代码逻辑清晰、可读性强，便于后期迭代与调试。

3.2 主要缺点

• 适用场景受限：仅适用于“复杂对象+构建步骤固定”的场景，对于结构简单、无需分步构建的对象，使用建造者模式会增加代码冗余，降低开发效率。

• 类/结构体数量膨胀：每新增一种产品变体，需对应新增一个具体建造者，当产品变体过多时，会导致类/结构体数量激增，增加代码维护成本。

• 依赖固定构建流程：指挥者的构建顺序固定，若不同产品的构建顺序差异较大，需修改指挥者代码，违反“开闭原则”，灵活性不足。

四、建造者模式的使用场景

建造者模式的核心价值在于“复杂对象的分步构建与灵活扩展”，适用于以下核心场景，能显著提升代码的可维护性与扩展性：

• 复杂对象分步构建：对象由多个组件组成，且组件构建有明确顺序（如汽车组装：底盘→发动机→车身→内饰；文档生成：标题→正文→页码→格式）。

• 多变体产品创建：同一类产品有多种配置变体，且构建逻辑相似（如不同配置的电脑、不同规格的订单、不同样式的报表），需灵活切换产品形态。

• 屏蔽构建细节：希望客户端仅关注产品结果，无需了解组件如何组装、依赖如何处理（如框架中的对象工厂、SDK中的实例创建），降低客户端使用成本。

• 动态调整构建过程：需在构建过程中动态修改组件配置（如分步构建HTTP请求：先设置Header，再添加Body，最后设置请求参数）。