访问者

typedef struct Engine Engine;
typedef struct Wheel Wheel;
typedef struct Car Car;

//Visitor: C has no overloading, so each element
//has its own function in the table
typedef struct {
    void (*visitEngine)(const Engine *engine);
    void (*visitWheel)(const Wheel *wheel);
    void (*visitCar)(const Car *car);
} CarVisitor;

//Element: the base struct is the first field of each element
typedef struct Element {
    void (*accept)(const struct Element *self, const CarVisitor *v);
} Element;

//ConcreteElement
struct Engine {
    Element base;
};

//the second dispatch: the element picks the function of the visitor
void engineAccept(const Element *self, const CarVisitor *v) {
    v->visitEngine((const Engine *)self);
}

//ConcreteElement
struct Wheel {
    Element base;
    int number;
};

void wheelAccept(const Element *self, const CarVisitor *v) {
    v->visitWheel((const Wheel *)self);
}

//ConcreteElement: the car keeps its parts inside, no malloc
struct Car {
    Element base;
    Engine engine;
    Wheel wheels[4];
};

void carAccept(const Element *self, const CarVisitor *v) {
    const Car *car = (const Car *)self;
    const Element *items[] = {
        &car->engine.base,
        &car->wheels[0].base, &car->wheels[1].base,
        &car->wheels[2].base, &car->wheels[3].base};
    for (size_t i = 0; i < sizeof items / sizeof items[0]; i++) {
        items[i]->accept(items[i], v);
    }
    v->visitCar(car);
}

Car carMake(void) {
    Car car = {.base = {carAccept}, .engine = {{engineAccept}}};
    for (int i = 0; i < 4; i++) {
        car.wheels[i] = (Wheel){{wheelAccept}, i + 1};
    }
    return car;
}

//ConcreteVisitor
//C23: an unused parameter may stay without a name
void testEngine(const Engine *) {
    printf("test engine\n");
}

void testWheel(const Wheel *wheel) {
    printf("test wheel #%d\n", wheel->number);
}

void testCar(const Car *) {
    printf("test car\n");
}

//ConcreteVisitor
void repairEngine(const Engine *) {
    printf("repair engine\n");
}

void repairWheel(const Wheel *wheel) {
    printf("repair wheel #%d\n", wheel->number);
}

void repairCar(const Car *) {
    printf("repair car\n");
}

//Client: a ConcreteVisitor is a table of its own functions
Car car = carMake();
CarVisitor v1 = {testEngine, testWheel, testCar};
CarVisitor v2 = {repairEngine, repairWheel, repairCar};

//the first dispatch: the element's own accept
car.base.accept(&car.base, &v1);
//printed: test engine
//         test wheel #1
//         test wheel #2
//         test wheel #3
//         test wheel #4
//         test car
car.base.accept(&car.base, &v2);
//printed: repair engine
//         repair wheel #1
//         repair wheel #2
//         repair wheel #3
//         repair wheel #4
//         repair car