Qt cpp 已知 可以通过调用 long long queryID = m_localPlayback->FPB_GetRecordTimeSegment 去查询录像时间，从接收 SDK CallBack中获取数据，如何优雅的实现

您可以考虑使用Qt的信号与槽机制，将获取到的录像时间作为参数传递给一个槽函数，然后在槽函数中进行处理。

首先，在类的头文件中声明一个信号，如下：

signals:
    void recordTimeSegmentReceived(long long queryID, int startTime, int endTime);

然后，在接收SDK回调的函数中，调用上述信号并将获取到的参数传递给它，如下：

void YourClass::onSDKCallback(long long queryID, int startTime, int endTime)
{
    emit recordTimeSegmentReceived(queryID, startTime, endTime);
}

接着，您可以在需要处理录像时间的地方连接该信号与一个槽函数，如下：

connect(this, &YourClass::recordTimeSegmentReceived, this, &YourClass::handleRecordTimeSegment);

最后，在槽函数中进行录像时间的处理，如下：

void YourClass::handleRecordTimeSegment(long long queryID, int startTime, int endTime)
{
    // 处理录像时间
}

这样，您就可以通过信号与槽机制，优雅地实现获取录像时间并进行处理。

相关问题

Qt cpp 已知 可以通过调用 long long queryID = m_localPlayback->FPB_GetRecordTimeSegment 给服务端发消息要求查询录像时间，服务端会将消息返回值通过 SDK CallBack传出， 如何优雅的实现 批量调用m_localPlayback->FPB_GetRecordTimeSegment。获取数据，并等到所有结果都得到或者超时后，调用线程才继续执行。

可以使用 Qt 提供的 QFuture 和 QFutureWatcher 类来实现批量调用 `m_localPlayback->FPB_GetRecordTimeSegment` 并等待所有结果返回或者超时后继续执行。

具体步骤如下：

1. 定义一个 `QFutureWatcher` 对象和一个 `QList<QFuture<long long>>` 来存储异步操作的结果：

QFutureWatcher<long long> watcher;
QList<QFuture<long long>> futures;

2. 在需要进行批量调用的地方，循环调用 `m_localPlayback->FPB_GetRecordTimeSegment` 并添加到 `futures` 列表中：

for (int i = 0; i < count; i++) {
    QFutureInterface<long long> *futureInterface = new QFutureInterface<long long>();
    QtConcurrent::run([=]() {
        long long result = m_localPlayback->FPB_GetRecordTimeSegment(arg1, arg2);
        futureInterface->reportResult(result);
        futureInterface->reportFinished();
    });
    futures.append(futureInterface->future());
}

这里使用 `QFutureInterface` 来手动创建异步操作，并将操作的结果交给 `QFutureInterface`，以便可以将异步操作的结果添加到 `futures` 列表中。

3. 连接 `QFutureWatcher` 的 `finished` 信号，以便在所有异步操作完成后处理结果：

QObject::connect(&watcher, &QFutureWatcher<long long>::finished, [=]() {
    QList<long long> results;
    for (int i = 0; i < futures.count(); i++) {
        QFuture<long long> future = futures.at(i);
        if (future.isFinished() && !future.isCanceled()) {
            results.append(future.result());
        } else {
            results.append(-1);
        }
    }
    // 处理结果
});

4. 启动异步操作并等待结果，可以使用 `QFutureWatcher` 的 `setFuture` 函数来启动异步操作，并设置超时时间，以确保等待的时间不会过长：

watcher.setFuture(QtConcurrent::mapped(futures, [](const QFuture<long long>& future) {
    return future.result();
}));
if (!watcher.waitForFinished(timeout)) {
    // 超时处理
}

这里使用了 `QtConcurrent::mapped` 函数来将 `QList<QFuture<long long>>` 转换为 `QFuture<QList<long long>>`，以便可以使用 `QFutureWatcher` 来监控所有异步操作的状态和结果。

完整的示例代码如下：

QFutureWatcher<long long> watcher;
QList<QFuture<long long>> futures;

for (int i = 0; i < count; i++) {
    QFutureInterface<long long> *futureInterface = new QFutureInterface<long long>();
    QtConcurrent::run([=]() {
        long long result = m_localPlayback->FPB_GetRecordTimeSegment(arg1, arg2);
        futureInterface->reportResult(result);
        futureInterface->reportFinished();
    });
    futures.append(futureInterface->future());
}

QObject::connect(&watcher, &QFutureWatcher<long long>::finished, [=]() {
    QList<long long> results;
    for (int i = 0; i < futures.count(); i++) {
        QFuture<long long> future = futures.at(i);
        if (future.isFinished() && !future.isCanceled()) {
            results.append(future.result());
        } else {
            results.append(-1);
        }
    }
    // 处理结果
});

watcher.setFuture(QtConcurrent::mapped(futures, [](const QFuture<long long>& future) {
    return future.result();
}));
if (!watcher.waitForFinished(timeout)) {
    // 超时处理
}

修改优化这个代码#include <stdio.h> #include <stdlib.h> #include <string.h> void sort(char *c)//排序函数 { int n=strlen(c); char t; int i,j; for(i=0;i<n;i++)//用冒泡法排序 { for(j=0;j<i+1;j++) { if(c[i]>c[j]) { t=c[i]; c[j]=c[i]; c[j]=t; } } } } int main() { FILE *fpa,*fpb,*fpc; char c[1000]={0};//将字符型数组初始化 fpa=fopen("A.file","r");//打开三个文件夹 if(fpa==NULL) { printf("fpa文件打开失败！\n"); exit(0); } fpb=fopen("B.file","r"); if(fpb==NULL) { printf("fpb文件打开失败！\n"); exit(0); } fpc=fopen("C.file","W");//（写）打开C文件，输入数据 if(fpc==NULL) { printf("fpc文件打开失败！\n"); exit(0); } fgets(c,1000,fpa);//从A文件中读取数据 int len=strlen(c);//调用函数获取c的长度 fgets(c+len,1000,fpa);//从B文件中读取数据并存到a后面（都存到c里） printf("文件中的数据相连接之后的结果为：\n"); sort(c);//调用排序函数 printf("排完序后的字符串为：\n"); puts(c);//输出字符串 fputs(c,fpc);//写文件函数 fclose(fpa);//关闭文件 fclose(fpa); fclose(fpa); return 0; }

下面是修改后的代码，主要是修复了排序函数的错误：将 c[j] 赋值为 c[i] 而不是 t。

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

void sort(char *c)
{
    int n = strlen(c); 
    char t; 
    int i, j; 
    for(i = 0; i < n; i++) 
    { 
        for(j = 0; j < n - i - 1; j++) // 优化冒泡排序，减少比较次数
        { 
            if(c[j] > c[j+1]) 
            { 
                t = c[j]; 
                c[j] = c[j+1]; 
                c[j+1] = t; 
            } 
        } 
    } 
} 

int main() 
{ 
    FILE *fpa, *fpb, *fpc; 
    char c[2000] = {0}; // 将字符型数组初始化 
    fpa = fopen("A.file", "r"); // 打开三个文件夹 
    if(fpa == NULL) 
    { 
        printf("fpa文件打开失败！\n"); 
        exit(0); 
    } 
    fpb = fopen("B.file", "r"); 
    if(fpb == NULL) 
    { 
        printf("fpb文件打开失败！\n"); 
        exit(0); 
    } 
    fpc = fopen("C.file", "w"); // （写）打开C文件，输入数据 
    if(fpc == NULL) 
    { 
        printf("fpc文件打开失败！\n"); 
        exit(0); 
    } 
    fgets(c, 1000, fpa); // 从A文件中读取数据 
    int len = strlen(c); // 调用函数获取c的长度 
    fgets(c + len, 1000, fpb); // 从B文件中读取数据并存到a后面（都存到c里） 
    printf("文件中的数据相连接之后的结果为：\n"); 
    sort(c); // 调用排序函数 
    printf("排完序后的字符串为：\n"); 
    puts(c); // 输出字符串 
    fputs(c, fpc); // 写文件函数 
    fclose(fpa); // 关闭文件 
    fclose(fpb); 
    fclose(fpc); 
    return 0; 
}

优化说明：

1. 在冒泡排序中，通过减少比较次数优化算法，避免因为多余的比较操作而降低效率。

2. 将定义数组 c 的大小改为 2000，保证可以存储两个文件的内容。