【C++类和数据抽象】消息处理示例(1)：从设计模式到实战应用

#include <iostream>
#include <vector>
#include <memory>
#include <algorithm> // 使用 std::remove_if

// 抽象观察者接口
class ButtonObserver {
public:
    // 纯虚函数，具体观察者需要实现该函数来处理按钮点击事件
    virtual void OnButtonClick() = 0;
    // 虚析构函数，确保在通过基类指针删除派生类对象时能正确调用派生类的析构函数
    virtual ~ButtonObserver() = default;
};

// 具体观察者：日志记录器
class LogObserver : public ButtonObserver {
public:
    // 实现 OnButtonClick 函数，处理日志记录
    void OnButtonClick() override {
        std::cout << "Button clicked: Logging event..." << std::endl;
    }
};

// 具体观察者：业务处理器
class BusinessObserver : public ButtonObserver {
public:
    // 实现 OnButtonClick 函数，处理业务逻辑
    void OnButtonClick() override {
        std::cout << "Button clicked: Processing business logic..." << std::endl;
    }
};

// 主题：按钮类
class Button {
public:
    // 向观察者列表中添加观察者
    void AddObserver(std::shared_ptr<ButtonObserver> observer) {
        if (observer) {
            observers_.push_back(observer);
        } else {
            std::cerr << "Error: Attempt to add a null observer." << std::endl;
        }
    }

    // 从观察者列表中移除指定的观察者
    void RemoveObserver(std::shared_ptr<ButtonObserver> observer) {
        if (observer) {
            auto newEnd = std::remove_if(observers_.begin(), observers_.end(), [&observer](const std::shared_ptr<ButtonObserver>& obs) {
                return obs == observer;
            });
            if (newEnd != observers_.end()) {
                observers_.erase(newEnd, observers_.end());
            } else {
                std::cerr << "Error: Observer not found in the list." << std::endl;
            }
        } else {
            std::cerr << "Error: Attempt to remove a null observer." << std::endl;
        }
    }

    // 模拟按钮点击，发送消息给所有注册的观察者
    void Click() {
        std::cout << "Button clicked: Notifying observers..." << std::endl;
        for (const auto& observer : observers_) {
            if (observer) {
                observer->OnButtonClick();
            } else {
                std::cerr << "Error: Found a null observer in the list." << std::endl;
            }
        }
    }

private:
    // 存储观察者的列表
    std::vector<std::shared_ptr<ButtonObserver>> observers_;
};

// 主函数：测试消息处理流程
int main() {
    Button button;
    auto logObserver = std::make_shared<LogObserver>();
    auto businessObserver = std::make_shared<BusinessObserver>();

    button.AddObserver(logObserver);
    button.AddObserver(businessObserver);

    button.Click(); // 触发消息发送

    return 0;
}

#include <iostream>
#include <vector>
#include <memory>

// 抽象命令接口
class FileCommand {
public:
    virtual void Execute() = 0;
    virtual ~FileCommand() = default;
};

// 具体命令：创建文件
class CreateFileCommand : public FileCommand {
public:
    CreateFileCommand(const std::string& filename) : filename_(filename) {}
    void Execute() override {
        std::cout << "Creating file: " << filename_ << std::endl;
        // 实际文件创建逻辑
    }

private:
    std::string filename_;
};

// 具体命令：删除文件
class DeleteFileCommand : public FileCommand {
public:
    DeleteFileCommand(const std::string& filename) : filename_(filename) {}
    void Execute() override {
        std::cout << "Deleting file: " << filename_ << std::endl;
        // 实际文件删除逻辑
    }

private:
    std::string filename_;
};

// 命令调用者：消息队列
class CommandQueue {
public:
    void AddCommand(std::shared_ptr<FileCommand> command) {
        commands_.push_back(command);
    }

    void ProcessCommands() { // 批量处理消息
        for (const auto& command : commands_) {
            command->Execute();
        }
        commands_.clear();
    }

private:
    std::vector<std::shared_ptr<FileCommand>> commands_;
};

// 主函数：测试命令模式
int main() {
    CommandQueue queue;
    queue.AddCommand(std::make_shared<CreateFileCommand>("data.txt"));
    queue.AddCommand(std::make_shared<DeleteFileCommand>("temp.txt"));

    std::cout << "Processing commands..." << std::endl;
    queue.ProcessCommands();

    return 0;
}

#include <iostream>
#include <vector>
#include <functional>

// 信号类：支持绑定槽函数
template <typename... Args>
class Signal {
public:
    void Connect(std::function<void(Args...)> slot) {
        slots_.push_back(slot);
    }

    void Emit(Args... args) { // 发送消息
        for (const auto& slot : slots_) {
            slot(args...);
        }
    }

private:
    std::vector<std::function<void(Args...)>> slots_;
};

// 按钮类：发送点击消息
class GuiButton {
public:
    Signal<> clicked; // 无参数信号
};

// 主函数：模拟GUI消息处理
int main() {
    GuiButton button;

    // 绑定槽函数：日志输出
    button.clicked.Connect([]() {
        std::cout << "Button clicked (via signal-slot)!" << std::endl;
    });

    // 触发信号：模拟按钮点击
    std::cout << "Simulating button click..." << std::endl;
    button.clicked.Emit();

    return 0;
}

#include <iostream>
#include <queue>

template <typename T>
class NonThreadSafeQueue {
public:
    void Enqueue(T message) {
        queue_.push(std::move(message));
    }

    T Dequeue() {
        T message = queue_.front();
        queue_.pop();
        return message;
    }

    bool Empty() {
        return queue_.empty();
    }

private:
    std::queue<T> queue_;
};

// 消息类型定义
struct Message {
    int type;
    std::string data;
};

// 生产者线程（非线程安全，仅演示逻辑）
void Producer(NonThreadSafeQueue<Message>& queue) {
    Message msg = {1, "Hello, message queue!"};
    queue.Enqueue(msg);
    std::cout << "Producer sent message: " << msg.data << std::endl;
}

// 消费者线程（非线程安全，仅演示逻辑）
void Consumer(NonThreadSafeQueue<Message>& queue) {
    while (!queue.Empty()) {
        Message msg = queue.Dequeue();
        std::cout << "Consumer received message: " << msg.data << std::endl;
    }
}

int main() {
    NonThreadSafeQueue<Message> queue;
    Producer(queue);
    Consumer(queue);
    return 0;
}

void OnButtonClick() {
    try {
        // 消息处理逻辑
    } catch (const std::exception& e) {
        std::cerr << "Message handling error: " << e.what() << std::endl;
    }
}