UML类图：

代码实现：

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

// 产品类
typedef struct {
    char* part1;
    char* part2;
    char* part3;
} Product;

// 抽象建造者类
typedef struct {
    void (*buildPart1)(void*, const char*);
    void (*buildPart2)(void*, const char*);
    void (*buildPart3)(void*, const char*);
    Product* (*getResult)(void*);
} Builder;

// 具体建造者类
typedef struct {
    Product* product;
    void (*buildPart1)(void*, const char*);
    void (*buildPart2)(void*, const char*);
    void (*buildPart3)(void*, const char*);
    Product* (*getResult)(void*);
} ConcreteBuilder;

void ConcreteBuilder_buildPart1(void* obj, const char* value) {
    ConcreteBuilder* builder = (ConcreteBuilder*)obj;
    builder->product->part1 = malloc(sizeof(char) * (strlen(value) + 1));
    strcpy(builder->product->part1, value);
}

void ConcreteBuilder_buildPart2(void* obj, const char* value) {
    ConcreteBuilder* builder = (ConcreteBuilder*)obj;
    builder->product->part2 = malloc(sizeof(char) * (strlen(value) + 1));
    strcpy(builder->product->part2, value);
}

void ConcreteBuilder_buildPart3(void* obj, const char* value) {
    ConcreteBuilder* builder = (ConcreteBuilder*)obj;
    builder->product->part3 = malloc(sizeof(char) * (strlen(value) + 1));
    strcpy(builder->product->part3, value);
}

Product* ConcreteBuilder_getResult(void* obj) {
    ConcreteBuilder* builder = (ConcreteBuilder*)obj;
    return builder->product;
}

// 指挥者类
typedef struct {
    void (*construct)(void*, Builder*);
} Director;

void Director_construct(void* obj, Builder* builder) {
    Director* director = (Director*)obj;
    director->builder = builder;
    director->builder->buildPart1(director->builder, "Part 1");
    director->builder->buildPart2(director->builder, "Part 2");
    director->builder->buildPart3(director->builder, "Part 3");
}

int main() {
    ConcreteBuilder builder;
    Product* product;

    builder.product = malloc(sizeof(Product));
    builder.buildPart1 = ConcreteBuilder_buildPart1;
    builder.buildPart2 = ConcreteBuilder_buildPart2;
    builder.buildPart3 = ConcreteBuilder_buildPart3;
    builder.getResult = ConcreteBuilder_getResult;

    Director director;
    director.construct = Director_construct;
    director.construct(&director, (Builder*)&builder);

    product = builder.getResult(&builder);

    printf("Part 1: %s\n", product->part1);
    printf("Part 2: %s\n", product->part2);
    printf("Part 3: %s\n", product->part3);

    free(product->part1);
    free(product->part2);
    free(product->part3);
    free(product);
    
    return 0;
}

在上面的示例代码中，首先定义了产品类Product，其中包含了三个部分。然后定义了抽象建造者类Builder，其中包含了构建产品的各个部分的函数指针。

接着定义了具体建造者类ConcreteBuilder，它实现了抽象建造者类中的函数，并拥有一个指向产品对象的指针。具体建造者类通过实现不同的构建方法来构建产品的不同部分，并提供获取最终产品的函数。

最后定义了指挥者类Director，它接收一个具体建造者对象作为参数，通过调用具体建造者的函数来构建产品。

在main函数中，创建了具体建造者对象builder和指挥者对象director，然后通过指挥者对象来构建产品。最后获取并打印产品的各个部分。

建造者模式将产品的构建过程与产品的表示分离，使得构建过程可以独立于产品而变化。通过使用建造者模式，可以更加灵活地构建复杂对象，并且可以复用相同的构建过程来创建不同的产品。

建造者模式的优点：

1. 可以将复杂对象的创建过程分解为多个简单的步骤，使得代码更加清晰、易于维护和扩展。

2. 可以复用相同的构建过程来创建不同的产品，具有良好的灵活性。

3. 可以控制产品对象的创建过程，保证其完整性和一致性。

4. 可以隐藏产品的内部实现细节，使得客户端只需要关心产品的接口。

建造者模式的缺点：

1. 建造者模式中会增加很多类，导致代码量增加。

2. 如果产品的组成部分发生变化，可能需要修改建造者类的代码，影响系统的稳定性。

适用场景：

1. 需要创建复杂的对象，而且对象的构建过程是稳定的，但是具体的构建步骤可能会有所差异。

2. 需要创建多个相似但不同的对象，可以使用同一个构建过程来构建不同的对象。

3. 需要控制对象的创建过程，并且希望隐藏产品的创建细节，只暴露出产品的接口。

4. 当产品的构成部分需要动态变化时，可以使用建造者模式。