您如何在程序的后台运行功能（特别是自动保存功能）？ QT/C++

Question

In my code I would like to integrate an auto-save function that runs every couple seconds or so. I would like this to run in the background because I have other stuff that I am going to be running at the same time. So how would I do this?

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <fstream>
#include <QFile>
#include <QDebug>
using namespace std;

MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow) {
    ui->setupUi(this);

    // Setup code
    ui->textEdit->setReadOnly(true);
    ui->textEdit->append("Select one of the buttons on the left to pick a log");

}

MainWindow::~MainWindow() {
    delete ui;
}

string lastSavedText[] = {
    " ",

        " "
    };

QString qLastSavedTextHome, qLastSavedTextWork;

This is my first button

void MainWindow::on_homeButton_clicked() {
    // Preparing text edit
    ui->textEdit->setReadOnly(false);
    ui->textEdit->clear();
    ui->textEdit->setOverwriteMode(true);

    // Loading previously saved text
    QFile file { "home.apl" };
    if ( !file.open(QIODevice::ReadOnly | QIODevice::Text) ) {
        qDebug() << "Could not open file!";
        return;
    }

    const auto& lastSavedText = file.readAll();
    file.close();

    ui->textEdit->setPlainText( lastSavedText );
}

This is my second one

void MainWindow::on_workButton_clicked() {
    // Preparing text edit
    ui->textEdit->setReadOnly(false);
    ui->textEdit->clear();
    ui->textEdit->setOverwriteMode(true);

    // Loading previously saved text
    QFile file2 { "work.apl" };
    if ( !file2.open(QIODevice::ReadOnly | QIODevice::Text) ) {
        qDebug() << "Could not open file!";
        return;
    }

    const auto& lastSavedText = file2.readAll();
    file2.close();

    ui->textEdit->setPlainText( lastSavedText );

}

This is the save button I hope to eliminate with an autosave

void MainWindow::on_saveButton_clicked() {

    // Converts textEdit to string
    QString textEditText = ui->textEdit->toPlainText();
    lastSavedText[0] = textEditText.toStdString();

    // Saving files
    ofstream home;
    home.open("home.apl");
    home << lastSavedText[0];
    home.close();

    ofstream work;
    work.open("work.apl");
    work << lastSavedText[1];
    work.close();
}

Answer 1

There is 2 solutions.

Easy one

Use simply a timer that will execute the code of your save button. You can set the timer to execute any period of time.

QTimer

But this might cause the software to freeze if this operation takes too much time. In which case, you can put the function that saves inside a thread.

---

Threads

You can use threads to do that.

Thread, is basically a process that will detach from your main process and can be run at the same time, each thread doing its own work.

Note that to communicate between thread, the safest method is to use signals.

Qt Threads Documentation

Example

void MyObject::startWorkInAThread()
{
    WorkerThread *workerThread = new WorkerThread(this);
    connect(workerThread, SIGNAL(resultReady(QString)), this, SLOT(handleResults(QString)));
    connect(workerThread, SIGNAL(finished()), workerThread, SLOT(deleteLater()));
    workerThread->start();
}

Answer 2

You can use a QTimer with QtConcurrent::run, and then you get the simplicity with the benefit of running the saving on a different thread you don't need to manage. Practically, try

QTimer::singleShot(time, this, Qt::TimerType::CoarseTime, QtConcurrent::run(this,&MainWindow::on_saveButton_clicked));

Answer 3

Here's a first approximation using a background thread (for the sake of brevity, it inherits QThread - for your real application, consider decoupling the QThread base-class from this worker thread object. That will also make it possible to give a father-object for t ).

class Thread: public QThread {
Q_OBJECT
public:
Thread(QTextEdit *textEdit):textEdit(textEdit) { 
   QTimer *t = new QTimer;
   connect(t, SIGNAL(timeout()), SLOT(saveOnce()));
   t->moveToThread(this);
   t->start(2000);
}

protected:
QTextEdit *textEdit;
std::string lastSavedText[2];

private slots:   
QString text() const { return textEdit->toPlainText(); }  
void saveOnce() {
   QString textEditText;
   QMetaObject::invokeMethod(this, 
      "text", Qt::BlockingQueuedConnection, 
      Q_RETURN_ARG(QString,textEditText));

   lastSavedText[0] = textEditText.toStdString();

   // Saving files
   ofstream home;
   home.open("home.apl");
   home << lastSavedText[0];
   home.close();

   ofstream work;
   work.open("work.apl");
   work << lastSavedText[1];
   work.close();
} 
};

Care must be taken, when taking this approach with BlockingQueuedConnection, that the thread does not call invokeMethod while the main thread is waiting for it to exit - then a deadlock happens because the main-thread cannot process the text() queued call anymore.