QT 文件

QT(11)文件

QFile 是 Qt 中用于文件操作的类，提供了对文件的读写功能。

它是一个方便的文件操作接口，可以用于打开、读取、写入和关闭文件。

主要功能

打开文件：
使用 open(QIODevice::OpenMode mode) 方法打开文件，mode 参数指定了文件的打开模式（如只读、只写、读写等）。

读取文件：
使用 read(char *data, qint64 maxSize) 或 readAll() 方法读取文件内容。
使用 readLine(char *data, qint64 maxSize) 方法读取一行内容。

写入文件：
使用 write(const char *data, qint64 maxSize) 或 write(const QByteArray &data) 方法写入数据。

关闭文件：
使用 close() 方法关闭文件。

文件信息：
使用 size() 方法获取文件大小。
使用 fileName() 方法获取文件名。

类成员

// QFile 类是 Qt 框架中用于文件操作的重要类。以下是 QFile 类的所有成员函数和枚举类型的详细列表：

// 枚举类型
enum QFile::FileError {
    NoError,          // 没有错误
    ReadError,        // 读取错误
    WriteError,       // 写入错误
    FatalError,       // 致命错误
    ResourceError,    // 资源错误
    OpenError,        // 打开错误
    AbortError,       // 中止错误
    TimeOutError,     // 超时错误
    UnspecifiedError, // 未指定错误
    RemoveError,      // 删除错误
    RenameError,      // 重命名错误
    PositionError,    // 位置错误
    ResizeError,      // 调整大小错误
    PermissionsError, // 权限错误
    CopyError         // 复制错误
};

enum QFile::FileHandleFlag {
    AutoCloseHandle,  // 自动关闭文件句柄
    DontCloseHandle   // 不关闭文件句柄
};

enum QFile::MemoryMapFlags {
    NoOptions         // 无选项
};

// 构造函数
QFile();
QFile(const QString &name);
QFile(QObject *parent);
QFile(const QString &name, QObject *parent);

// 析构函数
~QFile();

// 公共成员函数
bool atEnd() const; // 检查文件是否在末尾
bool copy(const QString &newName); // 复制文件到新名称
bool exists() const; // 检查文件是否存在
bool flush(); // 刷新文件缓冲区
int handle() const; // 返回文件句柄
bool isOpen() const; // 检查文件是否打开
bool isReadable() const; // 检查文件是否可读
bool isSequential() const; // 检查文件是否是顺序访问的
bool isTextModeEnabled() const; // 检查文件是否在文本模式下打开
bool isWritable() const; // 检查文件是否可写
bool link(const QString &linkName); // 创建文件的链接
bool open(OpenMode mode); // 以指定模式打开文件
bool open(FILE *f, OpenMode mode, FileHandleFlags handleFlags = DontCloseHandle); // 使用现有文件指针打开文件
bool open(int fd, OpenMode mode, FileHandleFlags handleFlags = DontCloseHandle); // 使用现有文件描述符打开文件
qint64 pos() const; // 返回文件当前位置
bool remove(); // 删除文件
bool rename(const QString &newName); // 重命名文件
bool resize(qint64 sz); // 调整文件大小
void setFileName(const QString &name); // 设置文件名
void setTextModeEnabled(bool enabled); // 设置文件的文本模式
qint64 size() const; // 返回文件大小
bool unmap(uchar *address); // 解除内存映射
uchar *map(qint64 offset, qint64 size, MemoryMapFlags flags = NoOptions); // 内存映射文件

下面是一个示例代码：

#include "mainwindow.h"

#include <QApplication>
#include <QFile>
#include <QDir>
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    //设置当前路径
    //QDir::setCurrent(QCoreApplication::applicationDirPath());
    QFile qfs("A://QT_WORK//q70//a.txt");

    //打开文件
    if(qfs.open(QIODevice::ReadWrite | QIODevice::Text))
    {
        //读取文件内容
        QTextStream in(&qfs);//读取文件流,文本流最大读4G
        QString str = in.readAll();//读取全部内容
        qDebug() << str; // qqqqqqqq\n

    } else{
        qDebug() << "文件打开失败";
    }


    //写入文件
    qfs.write("hello world");
    qfs.write("hello world\n");
    qfs.write("hello world\n");

    //重置文件指针到开头
    qfs.seek(0);

    char *p = new char[200]; //分配内存
    //读取一行
    //@param p 指向存放读取内容的内存地址
    //@param maxlen 最大读取长度
    //@return 返回读取的长度
    qint64 len= qfs.readLine(p, 200);

    while((len!=0)&&(len!= -1)){//读取到文件末尾时len为-1
        qDebug() << QString(p); //打印读取的内容
        len= qfs.readLine(p, 200);
    }
    qfs.close();

    //二进制写入文件
    QFile qfs2("A://QT_WORK//q70//b.dat");
    //二进制打开文件
    if(!qfs2.open(QIODevice::ReadWrite ))
    {
        qDebug() << "文件打开失败";
    }

    qint32 qnumber[3]={1,2,3};
    //将数组转换为QByteArray
    QByteArray qba = QByteArray((char*)qnumber, sizeof(qnumber));

    //写入二进制数据
    qfs2.write(qba);

    //读取二进制数据
     qfs2.seek(0); //设置文件指针到开头
     QByteArray q = qfs2.readAll(); //读取全部数据
     //二进制输出
     qDebug() << q; //打印读取的字节数

     //转换为int数组
     qint32 *p2 = (qint32*)q.data(); //转换为int指针
     qDebug() << *p2 << *(p2+1) << *(p2+2); //打印int值
    //关闭文件
    qfs2.close();

    return a.exec();
}

QTextStream 和 QDataStream

QTextStream 和 QDataStream 都是 Qt 中的流类，用于读写文本和二进制数据。

QTextStream 用于读写文本文件，QDataStream 用于读写二进制文件。

QTextStream
主要用途：用于处理基于文本的I/O操作。
支持的编码：可以处理多种文本编码，如UTF-8、UTF-16等。
适用场景：适合用于读写人类可读的文本文件，或在网络中的文本流数据。
操作特性：可以方便地处理字符串、整数、浮点数等的输入和输出，并提供格式化功能，比如设置域宽、对齐方式等。

QDataStream
主要用途：用于处理基于二进制的I/O操作。
适用场景：适合用于读写二进制文件或在网络中传输二进制数据。
操作特性：能够确保跨平台的兼容性，自动处理字节顺序（字节序），并支持Qt核心数据类型如QByteArray, QString, QVariant等的序列化和反序列化。
数据完整性：相较于QTextStream，QDataStream适合需要精确控制数据格式和大小的场景。

QTextStream 类成员

// QTextStream 类是 Qt 框架中用于文本流操作的重要类。以下是 QTextStream 类的所有成员函数和枚举类型的详细列表：

// 枚举类型
enum QTextStream::NumberFlag {
    ShowBase,          // 显示基数前缀
    ForcePoint,        // 强制显示小数点
    ForceSign,         // 强制显示符号
    UppercaseBase,     // 基数前缀大写
    UppercaseDigits    // 数字大写
};

enum QTextStream::RealNumberNotation {
    ScientificNotation, // 科学计数法
    FixedNotation,      // 固定小数点表示法
    SmartNotation       // 智能表示法
};

enum QTextStream::FieldAlignment {
    AlignLeft,         // 左对齐
    AlignRight,        // 右对齐
    AlignCenter,       // 居中对齐
    AlignAccountingStyle // 会计样式对齐
};

enum QTextStream::Status {
    Ok,                // 状态正常
    ReadPastEnd,       // 读取超过末尾
    ReadCorruptData,   // 读取损坏数据
    WriteFailed        // 写入失败
};

// 构造函数
QTextStream();
QTextStream(QIODevice *device);
QTextStream(FILE *fileHandle, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
QTextStream(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
QTextStream(QByteArray *array, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
QTextStream(const QByteArray &array, QIODevice::OpenMode openMode = QIODevice::ReadOnly);

// 析构函数
~QTextStream();

// 公共成员函数
bool atEnd() const; // 检查是否在流的末尾
void flush(); // 刷新流
bool generateByteOrderMark() const; // 检查是否生成字节顺序标记
QTextCodec *codec() const; // 返回当前编码
int integerBase() const; // 返回整数基数
QTextStream::NumberFlags numberFlags() const; // 返回数字格式标志
QChar padChar() const; // 返回填充字符
QString readAll(); // 读取所有数据
QString readLine(qint64 maxlen = 0); // 读取一行数据
bool readLineInto(QString *line, qint64 maxlen = 0); // 读取一行数据到指定字符串
QTextStream::RealNumberNotation realNumberNotation() const; // 返回实数表示法
int realNumberPrecision() const; // 返回实数精度
void reset(); // 重置流
void resetStatus(); // 重置状态
bool seek(qint64 pos); // 定位到指定位置
void setByteOrder(QDataStream::ByteOrder bo); // 设置字节顺序
void setCodec(QTextCodec *codec); // 设置编码
void setCodec(const char *codecName); // 设置编码
void setGenerateByteOrderMark(bool generate); // 设置是否生成字节顺序标记
void setIntegerBase(int base); // 设置整数基数
void setNumberFlags(QTextStream::NumberFlags flags); // 设置数字格式标志
void setPadChar(QChar ch); // 设置填充字符
void setFieldAlignment(QTextStream::FieldAlignment alignment); // 设置字段对齐方式
void setFieldWidth(int width); // 设置字段宽度
void setRealNumberNotation(QTextStream::RealNumberNotation notation); // 设置实数表示法
void setRealNumberPrecision(int precision); // 设置实数精度
void setStatus(QTextStream::Status status); // 设置状态
void setString(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite); // 设置字符串
void skipWhiteSpace(); // 跳过空白字符
QTextStream::Status status() const; // 返回状态
QString *string() const; // 返回当前字符串

QDataStream 类成员

// QDataStream 类是 Qt 框架中用于二进制数据流操作的重要类。以下是 QDataStream 类的所有成员函数和枚举类型的详细列表：

// 枚举类型
enum QDataStream::ByteOrder {
    BigEndian,    // 大端字节序
    LittleEndian  // 小端字节序
};

enum QDataStream::FloatingPointPrecision {
    SinglePrecision, // 单精度浮点数
    DoublePrecision  // 双精度浮点数
};

enum QDataStream::Status {
    Ok,            // 状态正常
    ReadPastEnd,   // 读取超过末尾
    ReadCorruptData, // 读取损坏数据
    WriteFailed    // 写入失败
};

enum QDataStream::Version {
    Qt_1_0 = 1,
    Qt_2_0 = 2,
    Qt_2_1 = 3,
    Qt_3_0 = 4,
    Qt_3_1 = 5,
    Qt_3_3 = 6,
    Qt_4_0 = 7,
    Qt_4_1 = 8,
    Qt_4_2 = 9,
    Qt_4_3 = 10,
    Qt_4_4 = 11,
    Qt_4_5 = 12,
    Qt_4_6 = 13,
    Qt_4_7 = 14,
    Qt_4_8 = 15,
    Qt_4_9 = 16,
    Qt_5_0 = 17,
    Qt_5_1 = 18,
    Qt_5_2 = 19,
    Qt_5_3 = 20,
    Qt_5_4 = 21,
    Qt_5_5 = 22,
    Qt_5_6 = 23,
    Qt_5_7 = 24,
    Qt_5_8 = 25,
    Qt_5_9 = 26,
    Qt_5_10 = 27,
    Qt_5_11 = 28,
    Qt_5_12 = 29,
    Qt_5_13 = 30,
    Qt_5_14 = 31,
    Qt_5_15 = 32,
    Qt_6_0 = 33
};

// 构造函数
QDataStream();
QDataStream(QIODevice *d);
QDataStream(QByteArray *a, QIODevice::OpenMode mode);
QDataStream(const QByteArray &a);

// 析构函数
~QDataStream();

// 公共成员函数
bool atEnd() const; // 检查是否在流的末尾
QIODevice *device() const; // 返回当前设备
QDataStream::ByteOrder byteOrder() const; // 返回字节顺序
bool floatingPointPrecision() const; // 返回浮点数精度
bool isRawDataEnabled() const; // 检查是否启用原始数据
bool isVersionEnabled() const; // 检查是否启用版本
QDataStream::Status status() const; // 返回状态
QDataStream::Version version() const; // 返回版本
void setByteOrder(QDataStream::ByteOrder bo); // 设置字节顺序
void setDevice(QIODevice *d); // 设置设备
void setFloatingPointPrecision(QDataStream::FloatingPointPrecision precision); // 设置浮点数精度
void setRawData(const char *data, int len); // 设置原始数据
void setStatus(QDataStream::Status status); // 设置状态
void setVersion(int v); // 设置版本
void unsetDevice(); // 取消设置设备
void resetStatus(); // 重置状态
void skipRawData(int len); // 跳过原始数据

#include "mainwindow.h"

#include <QApplication>
#include <QFile>
#include <QDir>
#include <QTextStream>
#include <QDataStream>
#include <iostream>


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

    //测试QTextStream
    //设置当前目录为程序运行目录
    QDir::setCurrent(QCoreApplication::applicationDirPath());
    //打开文件
    QFile file("test.txt");
    if (!file.open(QIODevice::ReadWrite | QIODevice::Text)) {
        qDebug() << "文件打开失败";
        return 1;
    }
    //写入数据
    QTextStream out(&file); //将文件流绑定到out
    out << "Hello, world!" << Qt::endl;
    out << "你好，世界！" <<Qt::endl;

    //读取数据
    file.seek(0); //将文件指针移动到开头
    QTextStream in(&file); //将文件流绑定到in
    while (!in.atEnd()) { //判断是否到达文件末尾
        QString line = in.readLine(); //读取一行数据
        //in >> line; //读取一行数据
        std::cout <<"读出的数据: "<< line.toStdString() << std::endl; //输出数据
    }


    file.close();


    //测试QDataStream
    //设置当前目录为程序运行目录
    QDir::setCurrent(QCoreApplication::applicationDirPath());
    //打开文件
    QFile file2("test.dat");
    if (!file2.open(QIODevice::ReadWrite | QIODevice::Text)) {
        qDebug() << "文件打开失败";
        return 1;
    }
    //写入二进制数据

    QByteArray data;
    data.append("Hello, world!");
    data.append("你好，世界!");
    QDataStream out2(&file2); //将文件流绑定到out3
    out2 << data;


    //读取数据
    file2.seek(0); //将文件指针移动到开头
    QDataStream in2(&file2); //将文件流绑定到in2
    while (!in2.atEnd()) { //判断是否到达文件末尾
        //读二进制数据
        QByteArray data;
        in2 >> data;
        std::cout <<"读出的数据: "<< data.data() << std::endl; //输出数据

    }


    file2.close();



    return a.exec();
}

QTextStream 使用注意事项

1. 编码设置：

   • 确保在读写文件时设置了正确的编码，特别是在处理多语言文本时。
   • 例如，使用setCodec方法设置编码：

     QTextStream stream(&file);
     stream.setCodec("UTF-8");
     

2. 换行符处理：

   • 不同操作系统有不同的换行符（例如，Windows使用\r\n，Unix/Linux使用\n）。QTextStream会自动处理这些差异。

3. 错误处理：

   • 检查文件是否成功打开，并处理可能的I/O错误。
   • 使用QFile的error方法检查错误状态。

4. 性能考虑：

   • 对于大文件，考虑使用缓冲区来提高性能。

QDataStream 使用注意事项

1. 版本控制：

   • 在序列化和反序列化数据时，确保使用相同的QDataStream版本，以避免兼容性问题。
   • 使用setVersion方法设置版本：

     QDataStream stream(&file);
     stream.setVersion(QDataStream::Qt_5_0);
     

2. 字节顺序：

   • 确保在不同平台之间传输数据时，字节顺序（字节序）一致。
   • 使用setByteOrder方法设置字节顺序：

     stream.setByteOrder(QDataStream::LittleEndian);
     

3. 数据类型：

   • 确保在序列化和反序列化时，使用的数据类型是兼容的。
   • 例如，QDataStream支持Qt核心数据类型，但不支持所有C++标准库类型。

4. 错误处理：

   • 检查文件是否成功打开，并处理可能的I/O错误。
   • 使用QFile的error方法检查错误状态。

5. 数据完整性：

   • 在传输重要数据时，考虑添加校验和或其他数据完整性检查机制，以确保数据在传输过程中未被损坏。

序列化操作

序列化是将数据结构转换为二进制流的过程。以下是一个简单的示例，展示如何使用QDataStream进行序列化：

#include <QFile>
#include <QDataStream>
#include <QDebug>

// 自定义数据结构
struct MyData {
    int id;
    QString name;
    double value;
};

// 重载QDataStream的<<操作符
QDataStream &operator<<(QDataStream &out, const MyData &data) {
    out << data.id << data.name << data.value;
    return out;
}

int main() {
    QFile file("data.dat");
    if (!file.open(QIODevice::WriteOnly)) {
        qWarning("无法打开文件进行写操作");
        return -1;
    }

    QDataStream out(&file);// 将文件流绑定到out
    out.setVersion(QDataStream::Qt_5_0);// 设置版本

    MyData data;
    data.id = 1;
    data.name = "Example";
    data.value = 3.14;

    out << data; // 序列化数据

    file.close();
    return 0;
}

反序列化操作

反序列化是将二进制流转换回原始数据结构的过程。

#include <QFile>
#include <QDataStream>
#include <QDebug>

// 自定义数据结构
struct MyData {
    int id;
    QString name;
    double value;
};

// 重载QDataStream的>>操作符
QDataStream &operator>>(QDataStream &in, MyData &data) {
    in >> data.id >> data.name >> data.value;
    return in;
}

int main() {
    QFile file("data.dat");
    if (!file.open(QIODevice::ReadOnly)) {
        qWarning("无法打开文件进行读操作");
        return -1;
    }

    QDataStream in(&file);
    in.setVersion(QDataStream::Qt_5_0);

    MyData data;
    in >> data; // 反序列化数据

    qDebug() << "ID:" << data.id;
    qDebug() << "Name:" << data.name;
    qDebug() << "Value:" << data.value;

    file.close();
    return 0;
}

关键点总结

自定义数据结构：定义需要序列化和反序列化的数据结构。

重载操作符：重载QDataStream的<<和>>操作符，以便能够序列化和反序列化自定义数据结构。

设置版本：使用setVersion方法设置QDataStream的版本，以确保兼容性。

文件操作：使用QFile打开文件进行读写操作，并使用QDataStream进行数据的序列化和反序列化。