浅谈C++之触发器用法

一、基本用法

        在C++中，触发器（Trigger）的概念通常指的是在特定条件下自动执行某些操作的机制。这可以是通过事件驱动编程、回调函数、信号和槽机制（如Qt框架中使用）等方式实现的。

二、简单应用

1. 使用函数指针和回调函数

这是实现触发器的一种简单方式，通过将函数作为参数传递给另一个函数，当特定条件满足时，调用这个函数。

#include <iostream>
#include <functional>

// 定义一个函数，它接受一个回调函数作为参数
void trigger(std::function<void()> callback) {
    // 特定条件满足时，调用回调函数
    callback();
}

int main() {
    // 定义一个回调函数
    std::function<void()> myCallback = []() {
        std::cout << "Triggered!" << std::endl;
    };

    // 调用trigger函数，并传递回调函数
    trigger(myCallback);

    return 0;
}

2. 使用信号和槽（Qt框架）

在Qt框架中，信号和槽是一种非常强大的触发器机制，用于对象之间的通信。

#include <QObject>
#include <QDebug>

class Sender : public QObject {
    Q_OBJECT

public:
    void doSomething() {
        qDebug() << "Sender::doSomething()";
        emit mySignal();
    }

signals:
    void mySignal();
};

class Receiver : public QObject {
    Q_OBJECT

public slots:
    void doSomething() {
        qDebug() << "Receiver::doSomething()";
    }
};

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);

    Sender sender;
    Receiver receiver;

    // 连接信号和槽
    QObject::connect(&sender, &Sender::mySignal, &receiver, &Receiver::doSomething);

    sender.doSomething();

    return a.exec();
}

#include "main.moc"

3. 使用事件驱动编程

在事件驱动编程中，程序的执行流程由事件（如用户输入、定时器事件等）驱动。

#include <iostream>
#include <thread>
#include <chrono>

void timerTrigger() {
    std::cout << "Timer triggered!" << std::endl;
}

int main() {
    // 设置一个定时器，5秒后触发
    std::thread timerThread([&]() {
        std::this_thread::sleep_for(std::chrono::seconds(5));
        timerTrigger();
    });

    timerThread.join();

    return 0;
}

4. 使用C++20的协程

C++20引入了协程，可以用于实现更复杂的异步操作和触发器。

#include <iostream>
#include <coroutine>
#include <thread>

struct Task {
    struct promise_type {
        Task get_return_object() { return {}; }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
};

Task triggerAfter(std::chrono::seconds delay) {
    std::this_thread::sleep_for(delay);
    std::cout << "Triggered after " << delay.count() << " seconds." << std::endl;
}

int main() {
    std::coroutine_handle<> h = std::coroutine_handle<promise_type<Task>>::from_promise(promise_type<Task>{});
    h.resume();
    h.destroy();

    return 0;
}