Utilisez QThread de QT pour encapsuler la classe qui surveille les modifications dans les fichiers de dossiers

Ce qui suit est une classe qui utilise le package QThread de QT pour surveiller les modifications dans les fichiers de dossiers :

```cpp
// MyWatcherThread.h 文件
#ifndef MYWATCHERTHREAD_H
#define MYWATCHERTHREAD_H

#include <QObject>
#include <QThread>
#include <QFileSystemWatcher>

classe MyWatcherThread : public QThread
{     Q_OBJECT

public :
    explicite MyWatcherThread (const QString &folder, QObject *parent = nullptr);
    ~MonWatcherThread();

signaux :
    void fileChanged(const QString &file);

private :
    remplacement de void run() ;

    QString m_dossier ;
    QFileSystemWatcher m_watcher;
} ;

#endif // MA WATCHERTHREAD_H

// Fichier MyWatcherThread.cpp
#include "MyWatcherThread.h"

MyWatcherThread::MyWatcherThread(const QString &folder, QObject *parent)
    : QThread(parent), m_folder(folder)
{ }

MyWatcherThread::~MyWatcherThread()
{     quit();     attendez(); }

void MyWatcherThread::run()
{     m_watcher.addPath(m_folder);     connect(&m_watcher, SIGNAL(fileChanged(QString)), this, SLOT(emitFileChanged(QString)));     exec(); }

void MyWatcherThread::emitFileChanged(const QString &path)
{     submit fileChanged(path); } ```

Créez un objet MyWatcherThread dans l'interface principale et connectez le signal fileChanged pour obtenir des informations sur les modifications de fichier. Par exemple:

```cpp
#include <QApplication>
#include "MyWatcherThread.h"

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

    MyWatcherThread *watcherThread = new MyWatcherThread("Chemin du dossier surveillé");
    QObject::connect(watcherThread, SIGNAL(fileChanged(QString)), [](const QString &file){         qDebug() << "Fichier modifié : " < < fichier ;     });     watcherThread->start();

    retourner a.exec();
}
```

Notez que QT += core doit être ajouté au fichier pro, sinon une erreur sera signalée.

 Voici un exemple de code qui utilise QThread de QT pour surveiller les modifications dans les fichiers de dossiers :

```cpp
// Fichier MyWatcher.h
#ifndef MYWATCHER_H
#define MYWATCHER_H

#include <QObject>
#include <QThread>
#include <QFileSystemWatcher>

classe MyWatcher : public QObject
{     Q_OBJECT

public :
    explicite MyWatcher (QObject *parent = nullptr);
    ~MonObservateur();

signaux :
    void fileChanged(const QString &file);

emplacements privés :
    void slotDirectoryChanged(const QString &path);
    void slotFileChanged(const QString &path);

privé :
    QThread m_thread ;
    QFileSystemWatcher m_watcher;
} ;

#endif // MYWATCHER_H

// Fichier MyWatcher.cpp
#include "MyWatcher.h"

MyWatcher::MyWatcher(QObject *parent)
    : QObject(parent)
{     m_watcher.moveToThread(&m_thread);     connect(&m_watcher, SIGNAL(directoryChanged(QString)), this, SLOT(slotDirectoryChanged(QString)));     connect(&m_watcher, SIGNAL(fileChanged(QString)), this, SLOT(slotFileChanged(QString)));     m_thread.start(); }

MonObservateur::~MonObservateur()
{     m_thread.quit();     m_thread.attendre(); }

void MyWatcher::slotDirectoryChanged(const QString &path)
{     qDebug() << "Répertoire modifié : " << chemin ; }

void MyWatcher::slotFileChanged(const QString &path)
{     qDebug() << "Fichier modifié : " << chemin ;     émettre fileChanged(chemin); } ```

Créez un objet MyWatcher dans l'interface principale, puis connectez le signal fileChanged pour obtenir des informations sur les modifications de fichier. Par exemple:

```cpp
#include <QApplication>
#include "MyWatcher.h"

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

    MonObservateur *watcher = new MonObservateur();
    QObject::connect(watcher, SIGNAL(fileChanged(QString)), [](const QString &file){         qDebug() << "Fichier modifié : " << fichier;     });

    watcher->m_watcher.addPath("Chemin du dossier surveillé");

    retourner a.exec();
}
```

Notez que QT += core doit être ajouté au fichier pro, sinon une erreur sera signalée.

Voici le code basé sur QThread de QT pour surveiller les modifications dans les fichiers de dossiers :

```cpp
#include <QThread>
#include <QFileSystemWatcher>
#include <QDebug>

classe FolderWatcher : public QThread
{     Q_OBJECT

public :
    FolderWatcher (const QString& chemin, QObject *parent = nullptr) 
        : QThread (parent), m_path (chemin) {}

signaux :
    void fileChanged(const QString& filePath);

protégé :
    void run() override
    {         Observateur QFileSystemWatcher ;         watcher.addPath(m_path);

        while(!isInterruptionRequested())
        {             if(watcher.directories().isEmpty())                 watcher.addPath(m_path);

            if(watcher.files().isEmpty())
                watcher.addPath(m_path + "/*");

            if(watcher.directories().isEmpty() || watcher.files().isEmpty())
                continue;

            watcher.waitForChanged(-1);

            const QStringList files = watcher.files();
            for(const QString& filePath: files)
            {                 if(!QFile::exists(filePath))                     continue;                 émettre fileChanged(filePath);             }         }     }

privé :
    QString m_path ;
} ;
```

Il s'agit d'un moniteur de dossier basé sur QThread et QFileSystemWatcher. Lorsque les fichiers du dossier changent, il enverra le chemin du fichier modifié via le signal fileChanged.

Lorsque vous utilisez cette classe, vous pouvez écrire :

```cpp
FolderWatcher* watcher = new FolderWatcher("C:/MyFolder", this);
connect(watcher, &FolderWatcher::fileChanged, [=] (const QString& filePath) {     qInfo() << "Fichier modifié : " << filePath; });

observateur->start();
```

Dans cet exemple, nous créons un moniteur de dossiers et surveillons le répertoire « C:/MyFolder ». Lorsque les fichiers de ce dossier changent, les informations du journal sont générées via la fonction lambda.