组合根

constexpr size_t maxOrders = 8;

//entity
typedef struct {
    int id;
    int sum;
} Order;

int orderPayable(const Order *order) {
    int sum = order->sum;
    return sum >= 200 ? sum - sum / 10 : sum;
}

//gateway
typedef struct Catalog {
    bool (*price)(struct Catalog *self, const char *sku,
                  int *price);
} Catalog;

//repository
typedef struct Orders {
    bool (*save)(struct Orders *self, const Order *order);
    size_t (*count)(struct Orders *self);
} Orders;

//output port
typedef struct Report {
    void (*say)(struct Report *self, const char *text);
} Report;

typedef struct {
    const char *sku;
    int count;
} Item;

//use case: asks for its parts, never builds them
typedef struct {
    Catalog *catalog;
    Orders *orders;
    Report *report;
    int nextId;
} PlaceOrder;

void placeOrder(PlaceOrder *useCase, const Item items[],
                size_t count) {
    Catalog *catalog = useCase->catalog;
    Report *report = useCase->report;
    char text[32];
    int total = 0;
    for (size_t i = 0; i < count; i++) {
        const Item *item = &items[i];
        int price = 0;
        if (!catalog->price(catalog, item->sku, &price)) {
            snprintf(text, sizeof text, "no %s", item->sku);
            report->say(report, text);
            return;
        }
        total += price * item->count;
    }
    Order order = {useCase->nextId, total};
    if (!useCase->orders->save(useCase->orders, &order)) {
        report->say(report, "not saved");
        return;
    }
    useCase->nextId++;
    snprintf(text, sizeof text, "order %d for %d", order.id,
             orderPayable(&order));
    report->say(report, text);
}

//adapters
bool memoryPrice(Catalog *, const char *sku, int *price) {
    static const struct {
        const char *sku;
        int price;
    } prices[] = {{"pen", 30}, {"lamp", 190}};
    size_t count = sizeof prices / sizeof prices[0];
    for (size_t i = 0; i < count; i++) {
        if (strcmp(prices[i].sku, sku) == 0) {
            *price = prices[i].price;
            return true;
        }
    }
    return false;
}

typedef struct {
    Orders base;
    Order rows[maxOrders];
    size_t size;
} MemoryOrders;

bool memorySave(Orders *self, const Order *order) {
    MemoryOrders *memory = (MemoryOrders *)self;
    if (memory->size == maxOrders) {
        return false;
    }
    memory->rows[memory->size++] = *order;
    return true;
}

size_t memoryCount(Orders *self) {
    return ((MemoryOrders *)self)->size;
}

void consoleSay(Report *, const char *text) {
    printf("%s\n", text);
}

void silentSay(Report *, const char *) {}

//composition root: the only place that sees every layer
//at once, and the only place where an adapter is built.
//C has no unique_ptr: the root holds the adapters by
//value, so they live exactly as long as the root does
typedef struct {
    Catalog catalog;
    MemoryOrders orders;
    Report report;
    PlaceOrder useCase;
} ShopApp;

//the use case points into the root, so a root is built
//in its place and never copied afterwards
void shopAppBuild(ShopApp *app, Report report) {
    app->catalog = (Catalog){memoryPrice};
    app->orders = (MemoryOrders){
        .base = {memorySave, memoryCount}};
    app->report = report;
    app->useCase = (PlaceOrder){&app->catalog,
                                &app->orders.base,
                                &app->report, 1001};
}

void shopAppLoud(ShopApp *app) {
    shopAppBuild(app, (Report){consoleSay});
}

void shopAppQuiet(ShopApp *app) {
    shopAppBuild(app, (Report){silentSay});
}

//client code
ShopApp app;
shopAppLoud(&app);
Item wanted[] = {{"pen", 2}, {"lamp", 1}};
placeOrder(&app.useCase, wanted, 2);
placeOrder(&app.useCase, (Item[]){{"chair", 1}}, 1);

//a second root builds the same use case differently
ShopApp night;
shopAppQuiet(&night);
placeOrder(&night.useCase, (Item[]){{"lamp", 1}}, 1);
Orders *orders = &night.orders.base;
printf("saved %zu\n", orders->count(orders));
//printed: order 1001 for 225
//         no chair
//         saved 1