Chemmy's Blog

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

// 定义常量，避免魔法数字，提升代码可读性
#define MAX_USER_NAME_LEN 20  // 最大用户名长度
#define MAX_USERS 10         // 最大在线用户数（适配资源受限场景）
#define MAX_MESSAGE_LEN 100  // 最大消息长度

// 前向声明：解决结构体交叉引用问题
typedef struct User User;
typedef struct ChatRoomMediator ChatRoomMediator;

// 抽象中介者：结构体+函数指针模拟接口
typedef struct ChatRoomMediator {
    User* users[MAX_USERS];                          // 在线用户数组
    int user_count;                                  // 已注册用户数量
    pthread_mutex_t mutex;                           // 互斥锁，保证并发安全
    // 中介者方法：注册用户、转发消息
    void (*register_user)(ChatRoomMediator* mediator, User* user);
    void (*send_message)(ChatRoomMediator* mediator, const char* message, User* sender);
} ChatRoomMediator;

// 抽象同事类：结构体+函数指针模拟接口
typedef struct User {
    char name[MAX_USER_NAME_LEN];                    // 用户名
    ChatRoomMediator* mediator;                     // 关联的中介者
    // 用户方法：发送消息、接收消息
    void (*send_message)(User* user, const char* message);
    void (*receive_message)(User* user, const char* message, const char* sender_name);
} User;

// 具体中介者方法：注册用户
void chat_room_register_user(ChatRoomMediator* mediator, User* user) {
    if (mediator == NULL || user == NULL) {
        printf("C: 中介者或用户实例无效\n");
        return;
    }
    pthread_mutex_lock(&mediator->mutex);

    // 校验用户数量上限和重复注册
    if (mediator->user_count >= MAX_USERS) {
        printf("C: 聊天室用户数量已达上限，无法注册\n");
        pthread_mutex_unlock(&mediator->mutex);
        return;
    }
    for (int i = 0; i < mediator->user_count; i++) {
        if (mediator->users[i] == user) {
            printf("C: 用户已注册，无需重复操作\n");
            pthread_mutex_unlock(&mediator->mutex);
            return;
        }
    }
    // 注册用户并绑定中介者
    mediator->users[mediator->user_count++] = user;
    user->mediator = mediator;
    printf("用户【%s】加入聊天室\n", user->name);
    pthread_mutex_unlock(&mediator->mutex);
}

// 具体中介者方法：转发消息
void chat_room_send_message(ChatRoomMediator* mediator, const char* message, User* sender) {
    if (mediator == NULL || sender == NULL || message == NULL || strlen(message) == 0) {
        printf("C: 中介者、发送者或消息内容无效\n");
        return;
    }
    pthread_mutex_lock(&mediator->mutex);

    // 转发消息，发送者不接收自己的消息
    for (int i = 0; i < mediator->user_count; i++) {
        if (mediator->users[i] != sender) {
            mediator->users[i]->receive_message(mediator->users[i], message, sender->name);
        }
    }
    pthread_mutex_unlock(&mediator->mutex);
}

// 具体同事类方法：发送消息
void normal_user_send_message(User* user, const char* message) {
    if (user == NULL || message == NULL || strlen(message) == 0) {
        printf("C: 用户或消息内容无效\n");
        return;
    }
    if (user->mediator == NULL) {
        printf("C: 用户【%s】未加入任何聊天室，无法发送消息\n", user->name);
        return;
    }
    // 截取消息，避免内存溢出
    char msg[MAX_MESSAGE_LEN];
    strncpy(msg, message, MAX_MESSAGE_LEN - 1);
    msg[MAX_MESSAGE_LEN - 1] = '\0';

    printf("\n%s 发送消息：%s\n", user->name, msg);
    user->mediator->send_message(user->mediator, msg, user); // 通过中介者转发
}

// 具体同事类方法：接收消息
void normal_user_receive_message(User* user, const char* message, const char* sender_name) {
    if (user == NULL || message == NULL || sender_name == NULL) {
        printf("C: 用户、消息或发送者信息无效\n");
        return;
    }
    printf("%s 收到 %s 的消息：%s\n", user->name, sender_name, message);
}

// 工厂函数：创建聊天室（中介者）实例
ChatRoomMediator* create_chat_room() {
    ChatRoomMediator* mediator = (ChatRoomMediator*)malloc(sizeof(ChatRoomMediator));
    if (mediator == NULL) {
        printf("C: 内存分配失败，无法创建聊天室\n");
        return NULL;
    }
    // 初始化用户数组和计数
    memset(mediator->users, 0, sizeof(mediator->users));
    mediator->user_count = 0;
    // 初始化互斥锁
    pthread_mutex_init(&mediator->mutex, NULL);
    // 绑定中介者方法
    mediator->register_user = chat_room_register_user;
    mediator->send_message = chat_room_send_message;
    return mediator;
}

// 工厂函数：创建普通用户（同事类）实例
User* create_normal_user(const char* name) {
    if (name == NULL || strlen(name) == 0 || strlen(name) >= MAX_USER_NAME_LEN) {
        printf("C: 用户名无效（为空或长度过长）\n");
        return NULL;
    }
    User* user = (User*)malloc(sizeof(User));
    if (user == NULL) {
        printf("C: 内存分配失败，无法创建用户\n");
        return NULL;
    }
    // 复制用户名，避免野指针
    strncpy(user->name, name, MAX_USER_NAME_LEN - 1);
    user->name[MAX_USER_NAME_LEN - 1] = '\0';
    user->mediator = NULL;
    // 绑定用户方法
    user->send_message = normal_user_send_message;
    user->receive_message = normal_user_receive_message;
    return user;
}

// 释放用户内存
void destroy_user(User* user) {
    if (user != NULL) {
        free(user);
        user = NULL;
    }
}

// 释放聊天室内存
void destroy_chat_room(ChatRoomMediator* mediator) {
    if (mediator != NULL) {
        pthread_mutex_destroy(&mediator->mutex);
        free(mediator);
        mediator = NULL;
    }
}

// 客户端测试代码
int main() {
    // 1. 创建中介者（聊天室）
    ChatRoomMediator* chat_room = create_chat_room();
    if (chat_room == NULL) return -1;

    // 2. 创建具体同事类（用户）
    User* user1 = create_normal_user("张三");
    User* user2 = create_normal_user("李四");
    User* user3 = create_normal_user("王五");
    if (user1 == NULL || user2 == NULL || user3 == NULL) {
        destroy_user(user1);
        destroy_user(user2);
        destroy_user(user3);
        destroy_chat_room(chat_room);
        return -1;
    }

    // 3. 注册用户到聊天室
    chat_room->register_user(chat_room, user1);
    chat_room->register_user(chat_room, user2);
    chat_room->register_user(chat_room, user3);

    // 4. 模拟用户发送消息
    user1->send_message(user1, "大家好！我是张三，很高兴加入聊天室～");
    printf("---\n");
    user2->send_message(user2, "张三你好！欢迎加入～");
    printf("---\n");
    user3->send_message(user3, "大家好呀！");

    // 5. 释放内存
    destroy_user(user1);
    destroy_user(user2);
    destroy_user(user3);
    destroy_chat_room(chat_room);
    return 0;
}
      

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

// 定义最大天气信息长度，避免内存溢出
#define MAX_WEATHER_LEN 128
// 定义最大观察者数量，适配资源受限场景
#define MAX_OBSERVERS 10

// 抽象观察者：结构体+函数指针模拟接口
typedef struct {
    // 更新方法：接收天气信息，执行更新逻辑
    void (*update)(void*, const char*);
    // 观察者私有数据（可选）
    void* data;
} Observer;

// 被观察者（主题）：天气中心
typedef struct {
    Observer* observers[MAX_OBSERVERS]; // 观察者数组（固定长度，适配嵌入式）
    int observer_count;                 // 已注册的观察者数量
    char current_weather[MAX_WEATHER_LEN]; // 当前天气状态
    pthread_mutex_t mutex;              // 互斥锁，保证并发安全
    // 被观察者方法：注册、注销、通知
    void (*register_observer)(void*, Observer*);
    void (*remove_observer)(void*, Observer*);
    void (*notify_observers)(void*);
    void (*set_weather)(void*, const char*);
} WeatherSubject;

// 具体观察者更新方法1：手机APP
void phone_app_update(void* observer, const char* weather_info) {
    (void)observer; // 未使用观察者私有数据，仅占位
    printf("C 手机APP：收到天气更新 - %s，已同步显示\n", weather_info);
}

// 具体观察者更新方法2：气象看板
void weather_board_update(void* observer, const char* weather_info) {
    (void)observer;
    printf("C 气象看板：收到天气更新 - %s，已刷新看板\n", weather_info);
}

// 被观察者方法：注册观察者
void weather_subject_register(void* subject, Observer* observer) {
    if (subject == NULL || observer == NULL || observer->update == NULL) {
        printf("C: 被观察者或观察者实例无效\n");
        return;
    }
    WeatherSubject* sub = (WeatherSubject*)subject;
    pthread_mutex_lock(&sub->mutex);

    // 检查是否达到最大观察者数量，是否重复注册
    if (sub->observer_count >= MAX_OBSERVERS) {
        printf("C: 观察者数量已达上限，无法注册\n");
        pthread_mutex_unlock(&sub->mutex);
        return;
    }
    for (int i = 0; i < sub->observer_count; i++) {
        if (sub->observers[i] == observer) {
            printf("C: 观察者已注册，无需重复操作\n");
            pthread_mutex_unlock(&sub->mutex);
            return;
        }
    }
    // 注册观察者
    sub->observers[sub->observer_count++] = observer;
    pthread_mutex_unlock(&sub->mutex);
}

// 被观察者方法：注销观察者
void weather_subject_remove(void* subject, Observer* observer) {
    if (subject == NULL || observer == NULL) {
        printf("C: 被观察者或观察者实例无效\n");
        return;
    }
    WeatherSubject* sub = (WeatherSubject*)subject;
    pthread_mutex_lock(&sub->mutex);

    // 查找并移除观察者
    int index = -1;
    for (int i = 0; i < sub->observer_count; i++) {
        if (sub->observers[i] == observer) {
            index = i;
            break;
        }
    }
    if (index == -1) {
        printf("C: 未找到该观察者，无法注销\n");
        pthread_mutex_unlock(&sub->mutex);
        return;
    }
    // 移动数组，覆盖被移除的观察者
    for (int i = index; i < sub->observer_count - 1; i++) {
        sub->observers[i] = sub->observers[i + 1];
    }
    sub->observer_count--;
    pthread_mutex_unlock(&sub->mutex);
}

// 被观察者方法：通知所有观察者
void weather_subject_notify(void* subject) {
    if (subject == NULL) {
        printf("C: 被观察者实例无效\n");
        return;
    }
    WeatherSubject* sub = (WeatherSubject*)subject;
    pthread_mutex_lock(&sub->mutex);

    // 遍历所有观察者，触发更新方法
    for (int i = 0; i < sub->observer_count; i++) {
        sub->observers[i]->update(sub->observers[i], sub->current_weather);
    }
    pthread_mutex_unlock(&sub->mutex);
}

// 被观察者方法：更新天气状态，触发通知
void weather_subject_set_weather(void* subject, const char* weather_info) {
    if (subject == NULL || weather_info == NULL || strlen(weather_info) == 0) {
        printf("C: 被观察者实例无效或天气信息为空\n");
        return;
    }
    WeatherSubject* sub = (WeatherSubject*)subject;
    pthread_mutex_lock(&sub->mutex);

    // 复制天气信息，避免野指针
    strncpy(sub->current_weather, weather_info, MAX_WEATHER_LEN - 1);
    sub->current_weather[MAX_WEATHER_LEN - 1] = '\0';
    pthread_mutex_unlock(&sub->mutex);

    printf("\nC 模拟天气状态变更：%s\n", sub->current_weather);
    weather_subject_notify(sub);
}

// 创建观察者实例
Observer* observer_create(void (*update)(void*, const char*), void* data) {
    if (update == NULL) {
        printf("C: 观察者更新方法不可为NULL\n");
        return NULL;
    }
    Observer* observer = (Observer*)malloc(sizeof(Observer));
    if (observer == NULL) {
        printf("C: 内存分配失败，无法创建观察者\n");
        return NULL;
    }
    observer->update = update;
    observer->data = data;
    return observer;
}

// 创建被观察者实例
WeatherSubject* weather_subject_create() {
    WeatherSubject* subject = (WeatherSubject*)malloc(sizeof(WeatherSubject));
    if (subject == NULL) {
        printf("C: 内存分配失败，无法创建被观察者\n");
        return NULL;
    }
    // 初始化观察者数组和计数
    memset(subject->observers, 0, sizeof(subject->observers));
    subject->observer_count = 0;
    // 初始化互斥锁
    pthread_mutex_init(&subject->mutex, NULL);
    // 绑定被观察者方法
    subject->register_observer = weather_subject_register;
    subject->remove_observer = weather_subject_remove;
    subject->notify_observers = weather_subject_notify;
    subject->set_weather = weather_subject_set_weather;
    return subject;
}

// 释放观察者内存
void observer_destroy(Observer* observer) {
    if (observer != NULL) {
        free(observer);
        observer = NULL;
    }
}

// 释放被观察者内存
void weather_subject_destroy(WeatherSubject* subject) {
    if (subject != NULL) {
        pthread_mutex_destroy(&subject->mutex);
        free(subject);
        subject = NULL;
    }
}

// 客户端测试代码
int main() {
    // 1. 创建被观察者（天气中心）
    WeatherSubject* weather_subject = weather_subject_create();
    if (weather_subject == NULL) return -1;

    // 2. 创建具体观察者
    Observer* phone_app = observer_create(phone_app_update, NULL);
    Observer* weather_board = observer_create(weather_board_update, NULL);
    if (phone_app == NULL || weather_board == NULL) {
        observer_destroy(phone_app);
        observer_destroy(weather_board);
        weather_subject_destroy(weather_subject);
        return -1;
    }

    // 3. 注册观察者
    weather_subject->register_observer(weather_subject, phone_app);
    weather_subject->register_observer(weather_subject, weather_board);

    // 4. 模拟天气变更
    weather_subject->set_weather(weather_subject, "晴转多云，气温18-25℃");

    // 5. 注销观察者
    weather_subject->remove_observer(weather_subject, phone_app);
    printf("C 模拟手机APP注销观察者\n");

    // 6. 再次模拟天气变更
    weather_subject->set_weather(weather_subject, "多云转雨，气温16-22℃，注意携带雨具");

    // 7. 释放内存
    observer_destroy(phone_app);
    observer_destroy(weather_board);
    weather_subject_destroy(weather_subject);
    return 0;
}