#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;
}

#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;
}

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

// 抽象产品1：电视机（结构体+函数指针模拟抽象接口）
typedef struct TV {
    void (*ShowInfo)(struct TV*); // 展示产品信息的函数指针
} TV;

// 抽象产品2：空调（结构体+函数指针模拟抽象接口）
typedef struct AirConditioner {
    void (*ShowInfo)(struct AirConditioner*); // 展示产品信息的函数指针
} AirConditioner;

// 具体产品1-1：海尔电视机（嵌套TV结构体，模拟继承）
typedef struct HaierTV {
    TV tv;
} HaierTV;

// 海尔电视机的具体实现
void HaierTV_ShowInfo(TV* tv) {
    printf("【海尔电视机】- 智能4K，节能护眼\n");
}

// 具体产品1-2：海尔空调（嵌套AirConditioner结构体，模拟继承）
typedef struct HaierAirConditioner {
    AirConditioner ac;
} HaierAirConditioner;

// 海尔空调的具体实现
void HaierAirConditioner_ShowInfo(AirConditioner* ac) {
    printf("【海尔空调】- 一级能效，静音节能\n");
}

// 具体产品2-1：TCL电视机（嵌套TV结构体，模拟继承）
typedef struct TCLTV {
    TV tv;
} TCLTV;

// TCL电视机的具体实现
void TCLTV_ShowInfo(TV* tv) {
    printf("【TCL电视机】- 量子点屏幕，高刷清晰\n");
}

// 具体产品2-2：TCL空调（嵌套AirConditioner结构体，模拟继承）
typedef struct TCLAirConditioner {
    AirConditioner ac;
} TCLAirConditioner;

// TCL空调的具体实现
void TCLAirConditioner_ShowInfo(AirConditioner* ac) {
    printf("【TCL空调】- 快速制冷，智能控温\n");
}

// 抽象工厂：电器工厂（结构体+函数指针模拟抽象接口）
typedef struct ElectricApplianceFactory {
    TV* (*CreateTV)(struct ElectricApplianceFactory*); // 创建电视机
    AirConditioner* (*CreateAirConditioner)(struct ElectricApplianceFactory*); // 创建空调
} ElectricApplianceFactory;

// 具体工厂1：海尔工厂（嵌套电器工厂结构体，模拟继承）
typedef struct HaierFactory {
    ElectricApplianceFactory factory;
} HaierFactory;

// 海尔工厂创建电视机
TV* HaierFactory_CreateTV(ElectricApplianceFactory* factory) {
    HaierTV* haierTV = (HaierTV*)malloc(sizeof(HaierTV));
    haierTV->tv.ShowInfo = HaierTV_ShowInfo; // 绑定函数指针
    return (TV*)haierTV;
}

// 海尔工厂创建空调
AirConditioner* HaierFactory_CreateAirConditioner(ElectricApplianceFactory* factory) {
    HaierAirConditioner* haierAC = (HaierAirConditioner*)malloc(sizeof(HaierAirConditioner));
    haierAC->ac.ShowInfo = HaierAirConditioner_ShowInfo; // 绑定函数指针
    return (AirConditioner*)haierAC;
}

// 具体工厂2：TCL工厂（嵌套电器工厂结构体，模拟继承）
typedef struct TCLFactory {
    ElectricApplianceFactory factory;
} TCLFactory;

// TCL工厂创建电视机
TV* TCLFactory_CreateTV(ElectricApplianceFactory* factory) {
    TCLTV* tclTV = (TCLTV*)malloc(sizeof(TCLTV));
    tclTV->tv.ShowInfo = TCLTV_ShowInfo; // 绑定函数指针
    return (TV*)tclTV;
}

// TCL工厂创建空调
AirConditioner* TCLFactory_CreateAirConditioner(ElectricApplianceFactory* factory) {
    TCLAirConditioner* tclAC = (TCLAirConditioner*)malloc(sizeof(TCLAirConditioner));
    tclAC->ac.ShowInfo = TCLAirConditioner_ShowInfo; // 绑定函数指针
    return (AirConditioner*)tclAC;
}

// 客户端调用
int main() {
    // 1. 初始化海尔工厂，获取海尔产品族
    HaierFactory haierFactory;
    haierFactory.factory.CreateTV = HaierFactory_CreateTV;
    haierFactory.factory.CreateAirConditioner = HaierFactory_CreateAirConditioner;
    
    TV* haierTV = haierFactory.factory.CreateTV((ElectricApplianceFactory*)&haierFactory);
    haierTV->ShowInfo(haierTV);
    AirConditioner* haierAC = haierFactory.factory.CreateAirConditioner((ElectricApplianceFactory*)&haierFactory);
    haierAC->ShowInfo(haierAC);

    // 2. 初始化TCL工厂，获取TCL产品族
    TCLFactory tclFactory;
    tclFactory.factory.CreateTV = TCLFactory_CreateTV;
    tclFactory.factory.CreateAirConditioner = TCLFactory_CreateAirConditioner;
    
    TV* tclTV = tclFactory.factory.CreateTV((ElectricApplianceFactory*)&tclFactory);
    tclTV->ShowInfo(tclTV);
    AirConditioner* tclAC = tclFactory.factory.CreateAirConditioner((ElectricApplianceFactory*)&tclFactory);
    tclAC->ShowInfo(tclAC);

    // 释放内存，避免泄漏
    free(haierTV);
    free(haierAC);
    free(tclTV);
    free(tclAC);
    return 0;
}