qt c++ 延迟2000毫秒后执行一个表达式_c++ 延迟执行-优快云博客

本文链接：https://blog.youkuaiyun.com/xie__jin__cheng/article/details/147348550

1.概要

2.内容

在 Qt C++ 中延迟执行表达式，可以通过 QTimer::singleShot 配合 lambda 表达式实现。以下是两种典型方案：

方案一：使用 lambda 表达式（推荐）

#include <QTimer>
#include <QDebug>

int main() {
    // 延迟执行表达式示例
    QTimer::singleShot(2000, [](){
        qDebug() << "2秒后执行此表达式";
        int result = 42 * 2; // 这里可以是任意表达式
        qDebug() << "计算结果：" << result;
    });

    // 保持程序运行（实际开发中不需要）
    QCoreApplication a(argc, argv);
    return a.exec();
}

方案二：封装为临时函数

#include <QTimer>
#include <QDebug>

// 临时封装函数
void delayedExpression() {
    qDebug() << "延迟执行的表达式";
    double value = 3.14 * 2;
    qDebug() << "计算结果：" << value;
}

int main() {
    QTimer::singleShot(2000, delayedExpression);
    
    // 保持程序运行
    QCoreApplication a(argc, argv);
    return a.exec();
}

关键注意事项：

作用域捕获：使用 lambda 时注意捕获变量（[=] 或 [&]）

QTimer::singleShot(2000, [=](){
    qDebug() << "使用捕获的变量：" << capturedVar;
});

线程安全：涉及 GUI 操作需确保在主线程执行
对象生命周期：确保延迟期间相关对象保持有效

错误处理：建议添加异常处理机制

QTimer::singleShot(2000, [](){
    try {
        // 可能抛出异常的表达式
    } catch (...) {
        qDebug() << "表达式执行出错";
    }
});

高级用法（带参数传递）：

void processData(int param) {
    qDebug() << "处理参数：" << param;
}

// 通过 lambda 传递参数
QTimer::singleShot(2000, [](){
    int dynamicValue = calculateValue();
    processData(dynamicValue);
});

选择方案时：

简单表达式 → 直接使用 lambda
复杂逻辑 → 封装为独立函数
需要参数传递 → 通过 lambda 捕获或传递参数包

这种方法既保持了代码的简洁性，又充分利用了 C++11 的 lambda 特性，是 Qt 中实现延迟表达式的推荐方式。

3.关联链接

4.关联知识

1.C++ Lambda 表达式详解

C++ Lambda 表达式详解

1. 什么是 Lambda 表达式？

定义：C++11 引入的一种匿名函数（inline function），无需显式定义函数名，可直接在代码中声明并使用。
语法：
```
[capture](parameters) -> return_type {
    // 函数体
};
```
- [capture]：捕获外部变量的方式（值捕获、引用捕获等）。
- (parameters)：参数列表（可选）。
- -> return_type：返回类型（可省略，编译器自动推导）。
- { ... }：函数体。

2. 基本用法

示例 1：无参数、无捕获

#include <iostream>

int main() {
    auto sayHello = []() {
        std::cout << "Hello, Lambda!" << std::endl;
    };
    sayHello();  // 输出: Hello, Lambda!
    return 0;
}

示例 2：带参数和返回值

#include <iostream>

int main() {
    auto add = [](int a, int b) -> int {
        return a + b;
    };
    std::cout << "3 + 5 = " << add(3, 5) << std::endl;  // 输出: 3 + 5 = 8
    return 0;
}

3. 捕获外部变量

值捕获（[=] 或 [var]）：

#include <iostream>

int main() {
    int x = 10, y = 20;
    auto printSum = [=]() {
        std::cout << "Sum: " << (x + y) << std::endl;
    };
    printSum();  // 输出: Sum: 30
    return 0;
}

引用捕获（[&] 或 [&var]）：

#include <iostream>

int main() {
    int x = 10, y = 20;
    auto modify = [&]() {
        x += 5;
        y += 10;
    };
    modify();
    std::cout << "x: " << x << ", y: " << y << std::endl;  // 输出: x: 15, y: 30
    return 0;
}

混合捕获：

#include <iostream>

int main() {
    int x = 10, y = 20;
    auto demo = [=, &y]() {
        // x 是值捕获，不可修改
        // y 是引用捕获，可以修改
        // x += 1;  // 错误：值捕获的变量是只读的
        y += 10;
        std::cout << "x: " << x << ", y: " << y << std::endl;
    };
    demo();  // 输出: x: 10, y: 30
    return 0;
}

4. 泛型 Lambda（C++14 引入）

使用 auto 作为参数类型，实现泛型函数。

#include <iostream>

int main() {
    auto print = [](auto value) {
        std::cout << value << std::endl;
    };
    print(42);        // 输出: 42
    print(3.14);      // 输出: 3.14
    print("Hello");   // 输出: Hello
    return 0;
}

5. 常见应用场景

1. 与标准库算法结合：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5};
    // 使用 lambda 表达式筛选偶数
    std::for_each(nums.begin(), nums.end(), [](int n) {
        if (n % 2 == 0) {
            std::cout << n << " ";
        }
    });  // 输出: 2 4
    return 0;
}

2. 回调函数：

#include <iostream>
#include <functional>

void executeCallback(std::function<void()> callback) {
    callback();
}

int main() {
    auto myCallback = []() {
        std::cout << "Lambda executed!" << std::endl;
    };
    executeCallback(myCallback);  // 输出: Lambda executed!
    return 0;
}