如何在C++中检测文本文件变化且避免无限循环？

我之前做配置文件热更新的时候也踩过无限轮询的坑——虽然实现简单，但空转的时候太占CPU资源了。给你整理几个更高效、更优雅的方案：

1. 利用操作系统原生的文件系统通知API #

不同操作系统都提供了内核级的文件变化监听机制，不需要自己轮询，只有当文件真的发生变化时才会主动通知程序：

• Windows：使用ReadDirectoryChangesW API，它可以监听指定目录下的文件修改、创建、删除等事件，目标文件变化时会触发通知。
• Linux：用inotify接口，通过初始化监听句柄、添加文件监视后，程序可以阻塞等待事件触发，资源消耗极低。
• macOS：使用kqueue机制，同样是内核事件通知，能高效监听文件状态变化。

举个Linux下inotify的极简示例：

#include <sys/inotify.h>
#include <unistd.h>
#include <iostream>

int main() {
    int inotifyFd = inotify_init();
    if (inotifyFd == -1) {
        perror("inotify_init failed");
        return 1;
    }

    // 监听目标文件的修改事件
    int watchDesc = inotify_add_watch(inotifyFd, "/path/to/your/target/file", IN_MODIFY);
    if (watchDesc == -1) {
        perror("inotify_add_watch failed");
        close(inotifyFd);
        return 1;
    }

    char buffer[1024];
    std::cout << "Waiting for file changes..." << std::endl;
    // 阻塞等待事件，文件变化时read才会返回
    ssize_t bytesRead = read(inotifyFd, buffer, sizeof(buffer));
    
    // 此处处理文件变化逻辑，比如读取第一行判断翻转状态
    std::cout << "File changed! Start processing..." << std::endl;

    inotify_rm_watch(inotifyFd, watchDesc);
    close(inotifyFd);
    return 0;
}

2. 优化版定时轮询（基于文件元数据） #

如果不想依赖系统特定API，也可以改进你的轮询逻辑：不要无限空转，而是定时检查文件的元数据（比如修改时间mtime、文件大小），只有当元数据变化时，再去读取第一行内容判断是否翻转。

这样把轮询间隔设为合理值（比如1-5秒），既能降低CPU占用，也能满足大部分场景的实时性需求。示例代码：

#include <sys/stat.h>
#include <chrono>
#include <thread>
#include <fstream>
#include <string>

int main() {
    const char* filePath = "/path/to/your/target/file";
    struct stat fileStat;
    stat(filePath, &fileStat);
    time_t lastModifyTime = fileStat.st_mtime;
    std::string lastFirstLine;

    // 先读取初始第一行
    std::ifstream file(filePath);
    std::getline(file, lastFirstLine);
    file.close();

    while (true) {
        stat(filePath, &fileStat);
        if (fileStat.st_mtime != lastModifyTime) {
            lastModifyTime = fileStat.st_mtime;
            // 读取新的第一行判断变化
            std::ifstream newFile(filePath);
            std::string currentFirstLine;
            std::getline(newFile, currentFirstLine);
            newFile.close();

            if (currentFirstLine != lastFirstLine) {
                lastFirstLine = currentFirstLine;
                std::cout << "File content flipped! Execute corresponding function..." << std::endl;
                // 执行你的业务逻辑
            }
        }
        // 定时休眠，避免空转
        std::this_thread::sleep_for(std::chrono::seconds(2));
    }
    return 0;
}

3. 使用跨平台第三方库封装 #

如果需要跨平台支持，不想自己写多系统适配代码，可以用成熟的第三方库：

• Boost.Filesystem：提供directory_monitor类，封装了不同系统的文件监听机制，只需一套代码就能跨平台运行。
• Qt：QFileSystemWatcher类可以轻松监听文件变化，通过信号槽机制就能处理文件修改事件，上手简单。

比如Qt的极简用法：

#include <QCoreApplication>
#include <QFileSystemWatcher>
#include <QDebug>
#include <QFile>

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);
    QFileSystemWatcher watcher;
    QString filePath = "/path/to/your/target/file";
    watcher.addPath(filePath);

    QObject::connect(&watcher, &QFileSystemWatcher::fileChanged, [&](const QString& path) {
        QFile file(path);
        if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
            QString firstLine = file.readLine().trimmed();
            qDebug() << "File changed, first line:" << firstLine;
            // 此处判断第一行是否翻转，执行对应逻辑
            file.close();
        }
        // 重新添加监听（因为某些编辑操作会先删除再重建文件，导致监听失效）
        watcher.addPath(path);
    });

    return a.exec();
}

这些方案里，原生系统API效率最高，跨平台库最省心，优化版轮询则是最轻量的折中方案，你可以根据项目的平台需求、复杂度来选择～

内容的提问来源于stack exchange，提问作者pg2455