观察者模式和命令模式联合使用的代码

答：观察者模式和命令模式联合使用的代码非常简单，只需要实现一个观察者接口并将其注册到命令模式中即可。要实现这一目标，可以使用Java中的java.util.Observer类，也可以使用自定义的观察者接口。

相关问题

命令模式和观察者模式易出错点

命令模式易出错点：

1. 命令类的职责要单一，不能包含多个操作，否则会使代码复杂化；
2. 命令对象的执行结果需要被正确地回滚，否则会出现不可预知的错误；
3. 命令模式可能会造成内存泄漏，需要注意对象的生命周期管理。

观察者模式易出错点：

1. 观察者模式可能会导致过多的通知，影响系统性能；
2. 观察者模式可能会导致循环依赖，需要注意解决循环依赖问题；
3. 观察者模式可能会导致过多的代码重复，需要注意代码的封装和抽象。

工厂模式和观察者模式 C++ 代码

工厂模式的 C 代码实现：

#include <stdio.h>

// 定义产品接口
typedef struct Product {
    void (*show)(void);
} Product;

// 定义具体产品A
typedef struct ConcreteProductA {
    Product product;
    char name[10];
} ConcreteProductA;

void ConcreteProductA_show(void) {
    printf("This is ConcreteProductA\n");
}

// 定义具体产品B
typedef struct ConcreteProductB {
    Product product;
    char name[10];
} ConcreteProductB;

void ConcreteProductB_show(void) {
    printf("This is ConcreteProductB\n");
}

// 工厂类
typedef struct Factory {
    Product *(*create_product)(void);
} Factory;

// 工厂类的具体实现，创建具体产品A
Product *ConcreteFactoryA_create_product(void) {
    ConcreteProductA *product = (ConcreteProductA *)malloc(sizeof(ConcreteProductA));
    product->product.show = ConcreteProductA_show;
    strcpy(product->name, "ConcreteProductA");
    return (Product *)product;
}

// 工厂类的具体实现，创建具体产品B
Product *ConcreteFactoryB_create_product(void) {
    ConcreteProductB *product = (ConcreteProductB *)malloc(sizeof(ConcreteProductB));
    product->product.show = ConcreteProductB_show;
    strcpy(product->name, "ConcreteProductB");
    return (Product *)product;
}

int main() {
    Factory factoryA, factoryB;

    factoryA.create_product = ConcreteFactoryA_create_product;
    factoryB.create_product = ConcreteFactoryB_create_product;

    Product *productA = factoryA.create_product();
    Product *productB = factoryB.create_product();

    productA->show();
    productB->show();

    free(productA);
    free(productB);

    return 0;
}

观察者模式的 C 代码实现：

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

// 定义观察者接口
typedef struct Observer {
    void (*update)(struct Observer *observer, int value);
} Observer;

// 定义具体观察者A
typedef struct ConcreteObserverA {
    Observer observer;
    char name[10];
} ConcreteObserverA;

void ConcreteObserverA_update(Observer *observer, int value) {
    ConcreteObserverA *concrete_observer = (ConcreteObserverA *)observer;
    printf("Observer %s received new value: %d\n", concrete_observer->name, value);
}

// 定义具体观察者B
typedef struct ConcreteObserverB {
    Observer observer;
    char name[10];
} ConcreteObserverB;

void ConcreteObserverB_update(Observer *observer, int value) {
    ConcreteObserverB *concrete_observer = (ConcreteObserverB *)observer;
    printf("Observer %s received new value: %d\n", concrete_observer->name, value);
}

// 定义被观察者接口
typedef struct Subject {
    void (*attach)(struct Subject *subject, Observer *observer);
    void (*detach)(struct Subject *subject, Observer *observer);
    void (*notify)(struct Subject *subject, int value);
} Subject;

// 定义具体被观察者
typedef struct ConcreteSubject {
    Subject subject;
    int value;
    Observer *observers[10];
    int count;
} ConcreteSubject;

void ConcreteSubject_attach(Subject *subject, Observer *observer) {
    ConcreteSubject *concrete_subject = (ConcreteSubject *)subject;
    concrete_subject->observers[concrete_subject->count++] = observer;
}

void ConcreteSubject_detach(Subject *subject, Observer *observer) {
    ConcreteSubject *concrete_subject = (ConcreteSubject *)subject;
    for (int i = 0; i < concrete_subject->count; i++) {
        if (concrete_subject->observers[i] == observer) {
            for (int j = i; j < concrete_subject->count - 1; j++) {
                concrete_subject->observers[j] = concrete_subject->observers[j + 1];
            }
            concrete_subject->count--;
            break;
        }
    }
}

void ConcreteSubject_notify(Subject *subject, int value) {
    ConcreteSubject *concrete_subject = (ConcreteSubject *)subject;
    for (int i = 0; i < concrete_subject->count; i++) {
        concrete_subject->observers[i]->update(concrete_subject->observers[i], value);
    }
}

int main() {
    ConcreteSubject subject;
    ConcreteObserverA observerA;
    ConcreteObserverB observerB;

    observerA.observer.update = ConcreteObserverA_update;
    strcpy(observerA.name, "A");

    observerB.observer.update = ConcreteObserverB_update;
    strcpy(observerB.name, "B");

    subject.subject.attach = ConcreteSubject_attach;
    subject.subject.detach = ConcreteSubject_detach;
    subject.subject.notify = ConcreteSubject_notify;

    subject.subject.attach((Subject *)&subject, (Observer *)&observerA);
    subject.subject.attach((Subject *)&subject, (Observer *)&observerB);

    subject.subject.notify((Subject *)&subject, 10);

    subject.subject.detach((Subject *)&subject, (Observer *)&observerA);

    subject.subject.notify((Subject *)&subject, 20);

    return 0;
}