QByteArray 作比较

在Qt中，QByteArray是一个用于存储和操作字节数组的类。如果要比较两个QByteArray对象，可以使用QByteArray的比较运算符，例如：

QByteArray ba1 = "Hello";
QByteArray ba2 = "World";
if (ba1 == ba2) {
    // do something
}

上述代码中，使用等于运算符比较了两个QByteArray对象，如果它们的内容相同，则执行if语句中的代码。

也可以使用QByteArray的compare()函数进行比较，例如：

QByteArray ba1 = "Hello";
QByteArray ba2 = "World";
if (ba1.compare(ba2) == 0) {
    // do something
}

上述代码中，使用compare()函数比较了两个QByteArray对象，如果它们的内容相同，则返回0，执行if语句中的代码。如果不相同，则返回一个非零值，可用于判断大小关系。

相关问题

Qt C++，QByteArray读取一个超过2GB的文件，写一类封装一下

Qt C++ 提供了一套强大的库用于处理文件操作，包括大数据量文件的读写。如果你需要处理超过2GB的大文件，并希望将其封装成一个易于使用的类，可以这样做：

#include <QObject>
#include <QFile>
#include <QByteArray>

class LargeFileHandler : public QObject
{
public:
    explicit LargeFileHandler(const QString& filePath) : file(filePath) {}

private slots:
    void readAllData();
    void writeData(QByteArray data);

signals:
    void dataReadFinished(QByteArray data);
    void writingProgress(int progress); // 可选信号，用于反馈写入进度

private:
    QFile file;
    QByteArray buffer;

    qint64 fileSize() const { return file.size(); }

    // 分块读取大文件，避免一次性加载到内存
    void readDataChunk(qint64 start, qint64 end) {
        qint64 remaining = end - start + 1;
        if (remaining <= buffer.size()) {
            file.seek(start);
            file.read(buffer.data(), remaining);
            emit dataReadFinished(buffer);
        } else {
            qint64 toRead = buffer.size();
            file.seek(start);
            file.read(buffer.data(), toRead);
            emit dataReadFinished(buffer);
            // 递归读取剩余部分
            readDataChunk(start + toRead, end);
        }
    }

    // 封装写数据的部分，这里仅作示例，通常会添加错误处理和进度更新机制
    void writeDataImpl(QByteArray data) {
        if (file.isOpen()) {
            int written = file.write(data);
            emit writingProgress(written);
        }
    }
};

// 使用方法示例
void LargeFileHandler::readAllData() {
    if (!file.open(QIODevice::ReadOnly)) {
        qWarning("Failed to open file");
        return;
    }
    qint64 totalSize = fileSize();
    qint64 chunkSize = std::min(totalSize, qint64(1024 * 1024 * 1024)); // 1GB大小的块
    qint64 start = 0;
    while (start < totalSize) {
        readDataChunk(start, std::min(start + chunkSize, totalSize));
        start += chunkSize;
    }
}

// 示例写入数据
void writeLargeFile(LargeFileHandler* handler, QByteArray data) {
    if (!handler->file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
        qCritical("Failed to open file for writing");
        return;
    }
    handler->writeDataImpl(data);
    handler->file.close();
}

这个`LargeFileHandler`类封装了大文件的读写操作，通过分块处理避免一次性加载整个文件到内存。在实际应用中，你可以创建并管理这样的对象，通过`readAllData()`读取文件内容，`writeData(QByteArray data)`方法用于写入数据。

QT c语言 文件读取10GB 文件 qbytearray接收， 如果文件读取大于2GB 就将文件以2GB一个文件大小保存 写出程序

在Qt中使用C++编写这样的程序涉及到大型文件的分段读取和处理。由于QT本身不直接支持超过2GB单文件操作，所以我们需要借助于一些策略来处理这种情况。这里是一个简化版的示例，使用了`QFile`、`QByteArray`以及`std::vector<quint64>`来存储每个部分的文件内容：

#include <QObject>
#include <QFile>
#include <QByteArray>
#include <vector>

class LargeFileHandler : public QObject
{
public:
    LargeFileHandler(const QString& filePath)
        : m_filePath(filePath), m_currentSize(0), m_maxFileSize((1 << 31) - 1)
    {}

    void processFile()
    {
        QFile file(m_filePath, QIODevice::ReadOnly);

        if (!file.open(QIODevice::ReadOnly)) {
            qCritical() << "Failed to open the file: " << file.errorString();
            return;
        }

        QByteArray buffer;
        while (!file.atEnd()) {
            int bytesToRead = qMin(file.bytesAvailable(), m_maxFileSize);
            file.read(&buffer[0], bytesToRead);
            handleChunk(buffer.data(), bytesToRead);
            m_currentSize += bytesToRead;

            if (m_currentSize >= m_maxFileSize) {
                saveCurrentChunk();
                m_currentSize = 0;
                buffer.clear();
            }
        }

        if (m_currentSize > 0) { // Process any remaining data
            saveCurrentChunk();
        }

        file.close();
    }

private:
    void handleChunk(char* data, qint64 size)
    {
        // 在此处处理每个小块，如解析、存储等操作
        // ...

        emit chunkProcessed(size);
    }

    void saveCurrentChunk()
    {
        QByteArray chunk = QByteArray(data, m_currentSize);
        // 实现将chunk写入新的文件或存储系统，这里仅作简单说明
        QString newFilePath = m_filePath + "_part_" + QByteArray::number(chunk.size());
        QFile outputFile(newFilePath, QIODevice::WriteOnly);
        outputFile.write(chunk);
        outputFile.close();
    }

    QString m_filePath;
    qint64 m_currentSize;
    qint64 m_maxFileSize;
};

// 使用该类的示例：
LargeFileHandler handler("large_file.txt");
QObject::connect(&handler, &LargeFileHandler::chunkProcessed, [] (qint64 size) { /* Handle each chunk processed */ });
handler.processFile();

注意，这个示例只是一个基础框架，实际应用中你需要实现`handleChunk`函数来处理每个读取的小块，同时可能还需要处理错误情况并可能添加进度报告等。另外，对于非常大的文件，你可能还会考虑使用更专业的文件系统API，如Linux的`preadv`等。