Truy xuất thông tin dung lượng ổ đĩa với QStorageInfo

Trong các ứng dụng cần tương tác sâu với hệ thống tệp tin, việc giám sát sức chứa ổ lưu trữ là yêu cầu cơ bản. Qt cung cấp lớp QStorageInfo, cho phép nhà phát triển truy vấn các thông số chi tiết về các thiết bị lưu trữ đang được gắn kết (mount) trên hệ thống. Thông qua lớp này, chúng ta có thể lấy được dung lượng tổng cộng, không gian trống còn lại, cũng như định dạng file system và trạng thái mount của ổ đĩa.

Xác định tổng dung lượng và không gian khả dụng

Lớp QStorageInfo đóng vai trò như một giao diện trừu tượng hóa các API hệ điều hành底层 (low-level). Để lấy thông tin, chúng ta khởi tạo đối tượng QStorageInfo với đường dẫn mong muốn hoặc sử dụng phương thức tĩnh mountedVolumes() để lấy danh sách tất cả các phân vùng.

Dưới đây là ví dụ minh họa việc duyệt qua các ổ đĩa và hiển thị thông tin chi tiết:

#include <QCoreApplication>
#include <QStorageInfo>
#include <QDebug>

void analyzeDiskSpace() {
    // Lấy danh sách tất cả các thiết bị lưu trữ được gắn kết
    QList<QStorageInfo> volumes = QStorageInfo::mountedVolumes();

    for (const QStorageInfo &volume : volumes) {
        // Kiểm tra xem thiết bị có hợp lệ và có sẵn sàng không
        if (volume.isValid() && volume.isReady()) {
            // Lấy các thông số cần thiết
            QString rootPath = volume.rootPath();
            qint64 totalBytes = volume.bytesTotal();
            qint64 freeBytes = volume.bytesAvailable();
            QString fileSystemType = volume.fileSystemType();

            // Chuyển đổi sang Gigabyte để dễ đọc
            double totalGB = totalBytes / (1024.0 * 1024.0 * 1024.0);
            double freeGB = freeBytes / (1024.0 * 1024.0 * 1024.0);

            qDebug() << "Đường dẫn:" << rootPath;
            qDebug() << "Hệ thống tệp:" << fileSystemType;
            qDebug() << "Tổng dung lượng:" << QString::number(totalGB, 'f', 2) << "GB";
            qDebug() << "Dung lượng trống:" << QString::number(freeGB, 'f', 2) << "GB";
            qDebug() << "----------------------------------";
        }
    }
}

int main(int argc, char *argv[]) {
    QCoreApplication app(argc, argv);
    analyzeDiskSpace();
    return 0;
}

Đoạn mã trên sử dụng phương thức bytesTotal() để lấy tổng dung lượng và bytesAvailable() để lấy lượng không gian còn có thể ghi dữ liệu. Việc chuyển đổi đơn vị từ byte sang GB giúp dữ liệu trực quan hơn cho người dùng cuối.

Thuật toán tính toán kích thước thư mục

Nguyên lý hoạt động của việc tính toán dung lượng

Khác với việc lấy thông tin ổ đĩa (được hệ thống quản lý trong siêu dữ liệu), việc tính kích thước một thư mục cụ thể yêu cầu thao tác duyệt qua hệ thống tệp tin. Kích thước thư mục được định nghĩa là tổng kích thước của tất cả các tệp tin bên trong nó, cộng với kích thước của tất cả các tệp tin trong các thư mục con (tính đệ quy). Quy trình này phải xử lý các vấn đề như quyền truy cập tệp, liên kết tượng trưng (symbolic links) để tránh tính toán trùng lặp hoặc thiếu sót.

Phương pháp tiếp cận đệ quy sử dụng QDir

Qt cung cấp lớp QDir để thao tác với cấu trúc thư mục. Chúng ta có thể xây dựng một hàm đệ quy để duyệt cây thư mục. Hàm này sẽ lấy danh sách các mục nhập (entries), kiểm tra xem đó là tệp hay thư mục. Nếu là tệp, cộng dồn kích thước; nếu là thư mục, gọi đệ quy chính nó.

#include <QDir>
#include <QFileInfo>
#include <QDebug>

// Hàm tính toán kích thước thư mục theo cách đệ quy
qint64 calculateRecursiveSize(const QString &path) {
    QDir currentDir(path);
    qint64 totalSize = 0;

    // Lấy danh sách tất cả các mục (bao gồm file và thư mục), bỏ qua . và ..
    // Đồng thời bao gồm cả các file ẩn
    QFileInfoList entries = currentDir.entryInfoList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot | QDir::Hidden | QDir::System);

    for (const QFileInfo &entry : entries) {
        if (entry.isDir()) {
            // Nếu là thư mục, gọi đệ quy để tính kích thước thư mục con
            totalSize += calculateRecursiveSize(entry.absoluteFilePath());
        } else if (entry.isFile()) {
            // Nếu là tệp, cộng trực tiếp kích thước
            totalSize += entry.size();
        }
        // Lưu ý: Có thể cần xử lý symlink tùy theo yêu cầu cụ thể
    }

    return totalSize;
}

void testFolderSize() {
    QString targetPath = "/path/to/directory";
    qint64 size = calculateRecursiveSize(targetPath);
    
    // Hiển thị kết quả dưới dạng MB
    qDebug() << "Kích thước thư mục:" << (size / (1024.0 * 1024.0)) << "MB";
}

Cách tiếp cận này hiệu quả nhưng có nhược điểm là phải tải toàn bộ danh sách tệp của thư mục hiện tại vào bộ nhớ trước khi xử lý, dẫn đến tiêu tốn RAM khi xử lý các thư mục chứa hàng nghìn tệp.

Tối ưu hóa hiệu suất với QDirIterator

Lợi ích của việc sử dụng Iterator

Để giải quyết vấn đề bộ nhớ khi duyệt thư mục lớn, Qt cung cấp QDirIterator. Lớp này hoạt động theo cơ chế "lazy loading" (tải lười), nghĩa là nó chỉ đọc thông tin của một tệp tại mỗi bước lặp thay vì tải toàn bộ danh sách vào bộ nhớ. Điều này giúp giảm thiểu tối đa mức tiêu thụ RAM và thường có hiệu suất tốt hơn khi duyệt cây thư mục sâu.

Ví dụ thực hiện với QDirIterator

Đoạn mã dưới đây thể hiện việc tính toán kích thước thư mục sử dụng QDirIterator, cho phép duyệt qua cả các thư mục con một cách liền mạch nhờ cờ Subdirectories.

#include <QDirIterator>
#include <QDebug>

qint64 calculateSizeWithIterator(const QString &rootPath) {
    qint64 accumulatedSize = 0;
    
    // Khởi tạo iterator với cờ Subdirectories để duyệt đệ tự động
    // QDirIterator::FollowSymlinks để tuân theo liên kết biểu tượng (tùy chọn)
    QDirIterator it(rootPath, QDir::Files | QDir::NoDotAndDotDot, QDirIterator::Subdirectories);

    while (it.hasNext()) {
        it.next(); // Chuyển đến phần tử tiếp theo
        QFileInfo fileInfo = it.fileInfo();
        
        if (fileInfo.isFile()) {
            accumulatedSize += fileInfo.size();
        }
    }
    return accumulatedSize;
}

int main() {
    QString largeDir = "/usr/lib"; // Ví dụ một thư mục lớn
    qint64 total = calculateSizeWithIterator(largeDir);
    qDebug() << "Tổng dung lượng (tính bằng Iterator):" << total << "bytes";
    return 0;
}

Việc sử dụng QDirIterator không chỉ làm cho code gọn gàng hơn mà còn tránh được lỗi tràn bộ nhớ (stack overflow) do đệ quy quá sâu, và tránh lỗi thiếu bộ nhớ (heap allocation) do nạp danh sách tệp quá lớn.

Thiết kế lớp tiện ích xử lý FileSystem

Để tái sử dụng mã nguồn và duy trì tính sạch sẽ của kiến trúc ứng dụng, chúng ta nên đóng gói các chức năng trên vào một lớp tiện ích (Utility Class). Lớp này sẽ cung cấp các phương thức tĩnh (static methods) để tiện lợi cho việc gọi từ bất kỳ đâu trong dự án.

#include <QString>
#include <QStorageInfo>
#include <QDir>

class FileSystemHelper {
public:
    // Lấy chuỗi định dạng dung lượng (ví dụ: "25.5 GB")
    static QString formatSize(qint64 bytes) {
        if (bytes < 1024) return QString::number(bytes) + " B";
        if (bytes < 1024 * 1024) return QString::number(bytes / 1024.0, 'f', 2) + " KB";
        if (bytes < 1024 * 1024 * 1024) return QString::number(bytes / (1024.0 * 1024.0), 'f', 2) + " MB";
        return QString::number(bytes / (1024.0 * 1024.0 * 1024.0), 'f', 2) + " GB";
    }

    // Lấy dung lượng trống của ổ đĩa chứa đường dẫn path
    static qint64 getAvailableDiskSpace(const QString &path) {
        QStorageInfo storage(path);
        if (storage.isValid() && storage.isReady()) {
            return storage.bytesAvailable();
        }
        return -1; // Mã lỗi
    }

    // Tính kích thước thư mục (sử dụng phương pháp tối ưu)
    static qint64 getDirectorySize(const QString &path) {
        qint64 total = 0;
        QDirIterator it(path, QDir::Files | QDir::Hidden | QDir::System, QDirIterator::Subdirectories);
        while (it.hasNext()) {
            it.next();
            total += it.fileInfo().size();
        }
        return total;
    }
};

// Ví dụ sử dụng trong dự án
// void logSystemStatus() {
//     qint64 freeSpace = FileSystemHelper::getAvailableDiskSpace("/home/user");
//     qDebug() << "Remaining Space:" << FileSystemHelper::formatSize(freeSpace);
// }

Lớp FileSystemHelper ở trên đã trừu tượng hóa các thao tác phức tạp liên quan đến QStorageInfo và QDirIterator. Việc tách biệt logic định dạng (formatting) và logic tính toán (calculation) giúp mã nguồn dễ dàng bảo trì và mở rộng trong tương lai.