精华内容
下载资源
问答
  • Qfile
    2021-07-08 16:11:10

    详细描述  

      QFile类提供了读取和写入文件的接口。  


        QFile是一个读写文本和二进制文件和资源的I/O设备。 QFile可以单独使用,或者更方便地与QTextStream或QDataStream一起使用。  


        文件名通常在构造函数中传递,但它可以在任何时候使用setFileName()设置。 无论操作系统如何,QFile都希望文件分隔符为“/”。 不支持使用其他分隔符(例如'\')。  


        您可以使用exists()检查文件是否存在,并使用remove()删除文件。 (更高级的文件系统相关操作由QFileInfo和QDir提供。)  


        文件用open()打开,用close()关闭,用flush()刷新。 数据通常使用QDataStream或QTextStream进行读写,但您也可以调用qiodevice继承的函数read()、readLine()、readAll()和write()。 QFile还继承了getChar()、putChar()和ungetChar(),它们一次工作一个字符。  


        文件的大小由size()返回。 您可以使用pos()获取当前的文件位置,或者使用seek()移动到一个新的文件位置。 如果到达了文件的末尾,atEnd()返回true。  

    直接阅读文件  

      下面的示例逐行读取文本文件:  

          QFile file("in.txt");
          if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
              return;
    
          while (!file.atEnd()) {
              QByteArray line = file.readLine();
              process_line(line);
          }

        传递给open()的QIODevice::Text标志告诉Qt将windows风格的行终止符("\r\n")转换为c++风格的终止符("\n")。默认情况下,QFile采用二进制格式,也就是说,它不会对存储在文件中的字节执行任何转换。

    使用流读取文件

      下一个例子使用QTextStream逐行读取文本文件:

          QFile file("in.txt");
          if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
              return;
    
          QTextStream in(&file);
          while (!in.atEnd()) {
              QString line = in.readLine();
              process_line(line);
          }

      

      QTextStream负责将存储在磁盘上的8位数据转换为16位Unicode QString。默认情况下,它假定使用用户系统的本地8位编码(例如,在大多数基于unix的操作系统上,UTF-8;详见QTextCodec::codecForLocale())。这可以通过QTextStream::setCodec()来改变。

        要写文本,我们可以使用operator<<(),它重载了左边的QTextStream和右边的各种数据类型(包括QString):

          QFile file("out.txt");
          if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
              return;
    
          QTextStream out(&file);
          out << "The magic number is: " << 49 << "\n";

        QDataStream与此类似,可以使用操作符<<()写入数据,使用操作符>>()读取数据。详细信息请参见类文档。


        当您使用QFile、QFileInfo和QDir访问使用Qt的文件系统时,您可以使用Unicode文件名。在Unix上,这些文件名被转换为8位编码。如果你想使用标准c++ api (<cstdio>或<iostream>)或特定于平台的api来访问文件而不是QFile,你可以使用encodeName()和decodeName()函数来在Unicode文件名和8位文件名之间进行转换。

        在Unix上,有一些特殊的系统文件(例如在/proc中),size()总是返回0,但是你仍然可以从这样的文件中读取更多的数据;生成数据是对调用read()的直接响应。然而,在这种情况下,您不能使用atEnd()来确定是否有更多的数据需要读取(因为atEnd()对于声明大小为0的文件将返回true)。相反,您应该调用readAll(),或反复调用read()或readLine(),直到无法读取更多的数据。下一个例子使用QTextStream逐行读取/proc/modules:

          QFile file("/proc/modules");
          if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
              return;
    
          QTextStream in(&file);
          QString line = in.readLine();
          while (!line.isNull()) {
              process_line(line);
              line = in.readLine();
          }


     

    信号

      与其他QIODevice实现(如QTcpSocket)不同,QFile不发出aboutToClose()、bytesWritten()或readyRead()信号。这个实现细节意味着QFile不适合读写某些类型的文件,比如Unix平台上的设备文件。

    特定于平台的问题

      在类unix系统和Windows系统上,文件权限的处理是不同的。在类unix系统上的非可写目录中,不能创建文件。这在Windows上并不总是如此,例如,“My Documents”目录通常是不可写的,但仍然可以在其中创建文件。
     

    Qt对文件权限的理解是有限的,这尤其影响QFile::setPermissions()函数。在Windows上,Qt只会设置旧的只读标志,并且只有当没有Write*标志被传递时才会设置。Qt不操作访问控制列表(acl),这使得该函数对NTFS卷几乎毫无用处。它可能仍然对使用VFAT文件系统的USB驱动器有用。POSIX acl也不被操作。


        请参见QTextStream、QDataStream、QFileInfo、QDir和Qt资源系统。

    更多相关内容
  • QFile 高通刷机软件

    2021-04-06 17:08:37
    QFile 高通刷机软件
  • QFile

    2022-09-14 13:57:17
    QFile

    QFile Class

    QFile 类提供读写文件的接口。

    属性方法
    Header:#include
    qmake:QT += core
    Inherits:QFileDevice
    Inherited By:QTemporaryFile

    注意: 类中所有函数都是 可重入的

    公共成员类型

    类型方法
    typedefDecoderFn

    公共成员函数

    类型方法
    QFile(const QString &name, QObject *parent)
    QFile(QObject *parent)
    QFile(const QString &name)
    QFile()
    virtual~QFile()
    boolcopy(const QString &newName)
    boolexists() const
    boollink(const QString &linkName)
    boolmoveToTrash()
    boolopen(FILE *fh, QIODevice::OpenMode mode, QFileDevice::FileHandleFlags handleFlags = DontCloseHandle)
    boolopen(int fd, QIODevice::OpenMode mode, QFileDevice::FileHandleFlags handleFlags = DontCloseHandle)
    boolremove()
    boolrename(const QString &newName)
    voidsetFileName(const QString &name)
    QStringsymLinkTarget() const

    重写公共函数

    类型方法
    virtual QStringfileName() const override
    virtual boolopen(QIODevice::OpenMode mode) override
    virtual QFileDevice::Permissionspermissions() const override
    virtual boolresize(qint64 sz) override
    virtual boolsetPermissions(QFileDevice::Permissions permissions) override
    virtual qint64size() const override

    静态公共成员

    类型方法
    boolcopy(const QString &fileName, const QString &newName)
    QStringdecodeName(const QByteArray &localFileName)
    QStringdecodeName(const char *localFileName)
    QByteArrayencodeName(const QString &fileName)
    boolexists(const QString &fileName)
    boollink(const QString &fileName, const QString &linkName)
    boolmoveToTrash(const QString &fileName, QString *pathInTrash = nullptr)
    QFileDevice::Permissionspermissions(const QString &fileName)
    boolremove(const QString &fileName)
    boolrename(const QString &oldName, const QString &newName)
    boolresize(const QString &fileName, qint64 sz)
    boolsetPermissions(const QString &fileName, QFileDevice::Permissions permissions)
    QStringsymLinkTarget(const QString &fileName)

    详细描述

    QFile 是用于读写文本及二进制的文件及资源的I/O设备。 一个QFile可以单独使用,或者更简单的,可以与 QTextStream 或 QDataStream 一同使用。

    文件名通常在构造时传递,但也可以在随时使用 setFileName()设置。QFile 需要目录分隔符为 ‘/’ 而不是依照操作系统。其他分隔符 (如 ‘\’) 不受支持。

    您可以通过 exists() 判断文件是否存在。(更多操作系统相关的操作在 QFileInfo 和 QDir 中提供)

    文件通过 open() 打开,通过 close() 关闭,通过 flush() 刷新。数据通常使用 QDataStream or QTextStream 读写,但您也可以使用 由 QIODevice 的继承函数 read(), readLine(), readAll(), write()。单字符的操作也可以使用 getChar(), putChar(), and ungetChar()。

    size() 返回文件大小。您可以通过 pos() 获取当前文件位置,或通过 seek() 移动到新的位置(译者注:此句中的“位置”指文件内操作的字节位置)。当您读到文件结尾, atEnd() 返回 true

    直接读文件

    如下例子逐行地直接读取文本文件:

        QFile file("in.txt");
        if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
            return;
    
        while (!file.atEnd()) {
            QByteArray line = file.readLine();
            process_line(line);
        }
    

    QIODevice::Text flag传递给 open() ,其告诉Qt将Windows风格的换行符 ("\r\n") 转换为 C++风格的换行符("\n")。默认情况下,QFile 假设为二进制模式读取,不做字节转换。

    通过流来读文件

    如下例子逐行地通过 QTextStream 读取文本文件:

        QFile file("in.txt");
        if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
            return;
    
        QTextStream in(&file);
        while (!in.atEnd()) {
            QString line = in.readLine();
            process_line(line);
        }
    

    QTextStream 会特意把8位文件中字节数据转换为QString中16位UTF-16字符。默认情况下,其假设用户使用系统默认编码(例如unix平台上是UTF-8;详情参看 QTextCodec::codecForLocale() )。编码可以通过 QTextStream::setCodec() 改变。

    要写入文本,您可以使用左移运算符运算符 operator<<(),在 QTextStream 中,其重载用于讲右侧内容追加的左侧,示例如下:

        QFile file("out.txt");
        if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
            return;
    
        QTextStream out(&file);
        out << "The magic number is: " << 49 << "\n";
    

    QDataStream 和上文很相似,详情请见相当应类的文档。

    当你使用 QFile, QFileInfo 以及 QDir 来访问系统中文件,你可以使用Unicode文件名。在Unix平台,文件名会转换为8位编码。如果您想使用C++标准API (<cstdio> 或 <iostream>) 或平台相关API来访问文件而不是使用 QFile,你可以使用 encodeName() 和 decodeName() 来在Unicode文件名和8位文件名间转换。

    在Unix平台,有一些特殊的系统文件 (例如 /proc 下的文件) ,对于这些文件,size() 会返回0,但你依然可以读取更多数据;这些数据在你调用 read() 时即时产生。在这种情况下,您便不能使用 atEnd() 来判断是否已经没有更多数据。(因为 atEnd() 通过文件大小是否到达结尾)。然而您可以通过连续调用 readAll(), read() 或 readLine() 指导没有数据来替代此功能。下面的例子使用 QTextStream 逐行读取/proc/modules :

        QFile file("/proc/modules");
        if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
            return;
    
        QTextStream in(&file);
        QString line = in.readLine();
        while (!line.isNull()) {
            process_line(line);
            line = in.readLine();
        }
    

    信号

    不像其他 QIODevice 的实现,例如 QTcpSocket,QFile 不会发出 aboutToClose(), bytesWritten(), 及 readyRead() 这些信号。这个实现细节意味着 QFile 不适用于读写某些特定类型的文件,比如Unix上的设备文件。

    平台相关信息

    文件权限和Unix和Windows上的处理并不相同。在Unix平台上,一个非 可写入 的目录,文件无法创建。但对于Windows并不一定如此,例如 ‘My Documents’ (我的文档)目录通常不可写入,但是在其中依然可以创建文件。

    Qt对于文件权限的理解有局限,尤其对于 QFile::setPermissions() 有影响。在Windows上,仅当没有任何 Write* flags被设置时,Qt 会设置旧版的只读 flag。Qt不会操作访问过滤表(access control lists , ACLs)这是的此函数在NTFS卷上基本上没什么用。对于VFAT格式的U盘,倒是有可能可用。POSIX 的 ACLs 也不会被修改。

    另请参见 QTextStreamQDataStreamQFileInfoQDir, 以及 The Qt Resource System

    成员类型文档

    typedef QFile::DecoderFn

    这个类型定义了一个如下形式的函数的指针:

    QString myDecoderFunc(const QByteArray &localFileName);
    

    另请参见 setDecodingFunction().

    成员函数文档

    QFile::QFile(const QString &nameQObject *parent)

    构造基于给定的父对象 parent 、文件名 name 指定的QFile对象。


    QFile::QFile(QObject *parent)

    构造基于给定的父对象 parent 的QFile对象。


    QFile::QFile(const QString &name)

    构造文件名 name 指定的QFile对象。


    QFile::QFile()

    构造一个QFile对象。


    [virtual]QFile::~QFile()

    销毁此QFile对象,如需要会自动关闭文件。


    bool QFile::copy(const QString &newName)

    将当前 fileName() 指定的文件复制为文件名 newName 指定的文件。如果成功,返回 true ;否则返回 false

    注意如果 newName 文件名的文件已存在,函数不会覆盖,直接返回 false 。

    源文件会在复制前关闭。

    另请参见 setFileName().


    [static]bool QFile::copy(const QString &fileName, const QString &newName)

    这是一个重载函数。

    将文件 fileName 复制为文件名 newName。如果成功,返回 true ;否则返回 false

    注意如果 newName 文件名的文件已存在,函数不会覆盖,直接返回 false 。

    另请参见 rename().


    [static]QString QFile::decodeName(const QByteArray &localFileName)

    和 QFile::encodeName() 操作恰恰相反。返回 localFileName 的Unicode形式。

    另请参见 encodeName().


    [static]QString QFile::decodeName(const char *localFileName)

    这是一个重载函数。返回 localFileName 的Unicode形式。

    详情参见 encodeName() 。


    [static]QByteArray QFile::encodeName(const QString &fileName)

    基于用户区域设置,将 fileName 转换为本地的8为表示。这对于用户选择的文件名足够使用。硬编码到程序中的文件名应当只使用7位ASCII字符。

    另请参见 decodeName().


    [static]bool QFile::exists(const QString &fileName)

    如果 fileName 对应的文件存在,返回 true 否则返回 false

    注意: 如果 fileName 是指向不存在文件的符号链接,返回 false


    bool QFile::exists() const

    这是一个重载函数。

    如果 fileName() 对应的文件存在,返回 true 否则返回 false

    另请参见 fileName() and setFileName().


    [override virtual]QString QFile::fileName() const

    重写函数: QFileDevice::fileName() const.

    返回 setFileName() 或构造函数设置的文件名。

    另请参见 setFileName() and QFileInfo::fileName().


    bool QFile::link(const QString &linkName)

    创建一个名为 linkName 的、指向 fileName() 文件的链接。链接的形式取决于底层文件系统(Windows上的快捷方式或Linux下的符号链接symlink)。如果成功,返回 true ;返回 false

    此函数不会覆盖文件系统上已经存在的链接;如果已存在,link() 将返回 false 并设置 error() 为 RenameError

    注意: 对于Windows平台,一个合法的链接名称必须包含 .lnk 后缀名。


    [static]bool QFile::link(const QString &fileName, const QString &linkName)

    这是一个重载函数。

    创建一个名为 linkName 的、指向 fileName 文件的链接。链接的形式取决于底层文件系统(Windows上的快捷方式或Linux下的符号链接symlink)。如果成功,返回 true ;否则返回 false


    bool QFile::moveToTrash()

    将fileName()文件移入回收站。如果成功返回 true ,并将 fileName() 设置为回收站中对应文件的路径;否则返回 false

    注意: 在API不能返回回收站中文件的路径的操作系统中,一旦文件被移动 fileName() 会被设置为空字符串。在没有回收站的操作系统,此函数总返回 false

    此函数引入自: Qt 5.15.


    [static]bool QFile::moveToTrash(const QString &fileNameQString *pathInTrash = nullptr)

    这是一个重载函数。

    将 fileName 文件移入回收站。如果成功返回 true ,并将 *pathInTrash 设置为回收站中对应文件的路径字符串的指针;否则返回 false

    注意: 在API不能返回回收站中文件的路径的操作系统中,一旦文件被移动 *pathInTrash 会被设置为空字符串。在没有回收站的操作系统,此函数总返回 false

    此函数引入自: Qt 5.15.


    [override virtual]bool QFile::open(QIODevice::OpenMode mode)

    重写函数: QIODevice::open(QIODevice::OpenMode mode)。

    使用 OpenMode mode 模式打开文件,如果成功,返回 true ;否则返回 false

    模式 mode 必须是 QIODevice::ReadOnlyQIODevice::WriteOnly, 或 QIODevice::ReadWrite。也可以有附加flags,例如 QIODevice::Text 和 QIODevice::Unbuffered

    注意: 在 WriteOnly 或 ReadWrite 模式,如果相关文件不存在,此函数会尝试在打开前新建。

    另请参见 QIODevice::OpenMode and setFileName().


    bool QFile::open(FILE *fhQIODevice::OpenMode modeQFileDevice::FileHandleFlags handleFlags = DontCloseHandle)

    这是一个重载函数。

    使用给出的模式 mode 打开已有的文件句柄 fhhandleFlags 可能会被用于指定附加选项。如果成功,返回 true ;否则返回 false

    例如:

    #include <stdio.h>
    
    void printError(const char* msg)
    {
        QFile file;
        file.open(stderr, QIODevice::WriteOnly);
        file.write(msg, qstrlen(msg));        // 写入 stderr
        file.close();
    }
    

    当一个 QFile 通过此函数被被打开,close() 的行为由 AutoCloseHandle flag决定。如果指定了 AutoCloseHandle ,且此函数执行成功,那么 close() 会关闭传入的句柄。否则,close() 不会关闭文件,只会刷新数据(flush)。

    警告:

    1. 如果 fh 并非指向常规文件,例如 stdinstdout, 或 stderr,你可能不能够使用 seek(),且size() 返回0。详见 QIODevice::isSequential()。
    2. 由于使用此函数打开的文件没有指定文件名,你不能通过 QFileInfo 读取相关信息。

    Windows平台的注意事项

    当访问文件或其他随机存取设备时,fh 必须以二进制模式打开(也就是 fopen() 的模式串必须包含’b’)。Qt 会转换行末字节如果您指定 QIODevice::Text 给 mode。顺序读取设备,例如标准输入输出,不受此限制影响。

    您需要启用控制台应用支持,才能在控制台使用标准输入输出。要启用,可以在项目文件中加入:

    CONFIG += console
    


    bool QFile::open(int fdQIODevice::OpenMode modeQFileDevice::FileHandleFlags handleFlags = DontCloseHandle)

    这是一个重载函数。

    使用给出的模式 mode 打开已有的文件描述符 fhhandleFlags 可能会被用于指定附加选项。如果成功,返回 true ;否则返回 false

    当一个 QFile 通过此函数被被打开,close() 的行为由 AutoCloseHandle flag决定。如果指定了 AutoCloseHandle ,且此函数执行成功,那么 close() 会关闭传入的句柄。否则,close() 不会关闭文件,只会刷新数据(flush)。

    通过此函数打开的文件会被自动设置为 raw 模式;这意味着文件I/O函数会很慢。如果您遇到了性能问题,可以尝试其他 open() 函数。

    警告:

    1. 如果 fd 不是一个常规文件,例如 0 (stdin), 1 (stdout), 或 2 (stderr),你可能不能够使用 seek(),且size() 返回0。详见 QIODevice::isSequential()。

    2. 由于使用此函数打开的文件没有指定文件名,你不能通过 QFileInfo 读取相关信息。


    [override virtual]QFileDevice::Permissions QFile::permissions() const

    重写函数: QFileDevice::permissions() const.


    [static]QFileDevice::Permissions QFile::permissions(const QString &fileName)

    这是一个重载函数。

    返回 fileName 文件经 OR(位或)后的权限 QFile::Permission 组合。


    bool QFile::remove()

    删除文件名 fileName() 的文件。

    如果成功,返回 true ;否则返回 false

    文件会在删除前关闭。


    [static]bool QFile::remove(const QString &fileName)

    这是一个重载函数。

    删除文件名 fileName 的文件。

    如果成功,返回 true ;否则返回 false


    bool QFile::rename(const QString &newName)

    把文件 fileName() 重命名为 newName。如果成功,返回 true ;否则返回 false

    注意如果 newName 文件名的文件已存在,函数不会覆盖,直接返回 false 。

    文件在重命名前关闭。

    如果直接重命名失败,Qt会尝试拷贝数据到 newName 新文件并删除旧文件来实现重命名。如果拷贝或删除失败,Qt会撤回新文件创建,返回原先状态。

    另请参见 setFileName().


    [static]bool QFile::rename(const QString &oldName, const QString &newName)

    这是一个重载函数。

    把文件 oldName 重命名为 newName。如果成功,返回 true ;否则返回 false

    注意如果 newName 文件名的文件已存在,函数不会覆盖,直接返回 false 。

    另请参见 rename().


    [override virtual]bool QFile::resize(qint64 sz)

    重写函数: QFileDevice::resize(qint64 sz).


    [static]bool QFile::resize(const QString &fileNameqint64 sz)

    这是一个重载函数。

    这是文件名 fileName 文件的大小为 sz 字节。如果修改大小成功返回 true,否则返回 false。如果 sz 比当前文件大小大,后面的数据会填充0;如果 sz 比当前文件大小小,会裁剪文件数据。

    警告: 如果文件不存在,调用会失败。


    void QFile::setFileName(const QString &name)

    设置文件名 name。名称可以不包含目录,包含相对目录或绝对目录。

    请不要在文件已经打开后调用此函数。

    如果文件名不包含路径,或者是相对路径,路径会基于应用程序调用 open() 时的当前路径。

    例如:

    QFile file;
    QDir::setCurrent("/tmp");
    file.setFileName("readme.txt");
    QDir::setCurrent("/home");
    file.open(QIODevice::ReadOnly);      // 打开Unix下文件 "/home/readme.txt"
    

    注意Qt中目录分隔符统一使用"/".

    另请参见QFileInfo, and QDir.


    [override virtual]bool QFile::setPermissions(QFileDevice::Permissions permissions)

    重写函数: QFileDevice::setPermissions(QFileDevice::Permissions permissions).

    为文件设置 permissions 权限。如果成功返回 true ,如果权限不能修改返回 false 。

    警告: 此函数不会操作修改 ACLs,这会限制函数功能。


    [static]bool QFile::setPermissions(const QString &fileNameQFileDevice::Permissions permissions)

    这是一个重载函数。

    为文件名 fileName 的文件设置 permissions 权限。


    [override virtual]qint64 QFile::size() const

    重写函数: QFileDevice::size() const.


    [static]QString QFile::symLinkTarget(const QString &fileName)

    返回符号链接(Unix上的symlink或Windows上快捷方式)fileName 指向的文件或目录的绝对路径。如果 fileName 不是一个符号链接,返回空字符串。

    名称可能并不是一个存在的文件,只是一个字符串路径。 QFile::exists()可以用来判断是否存在。

    此函数引入自: Qt 4.2.


    QString QFile::symLinkTarget() const

    这是一个重载函数。

    返回QFile对象对应的符号链接(Unix上的symlink或Windows上快捷方式)指向的文件或目录的绝对路径。如果 fileName 不是一个符号链接,返回空字符串。

    名称可能并不是一个存在的文件,只是一个字符串路径。QFile::exists()可以用来判断是否存在。

    展开全文
  • qfile烧软件.docx

    2019-11-18 07:02:25
    QFILE烧录软件操作说明,根据工具实际操作编写,可用于MSM8909的平台,主要用于低端机(美国运营商补贴采购),操作说明比较详细,可有效指导新员式进行操作。
  • QFile_test.rar,QFile_test,build-QFile_test-Desktop_Qt_5_14_1_MinGW_32_bit-Debug,ui_qfile_test.h,moc_predefs.h,text.txt,moc_qfile_test.cpp,main.o,qfile_test.o,QFile_test.exe,Makefile,moc_qfile_test.o,....
  • Qt文件操作类QFile简介 Qt中使用QFile类来操作文件的输入/输出。继承至QIODevice,QIODevice类是输入/输出设备的基类, 为设备提供了公共实现和抽象接口用于读写块数据。QIODevice又继承至QObject。 1、使用QFile类...
  • Qt QFile文件操作详解

    千次阅读 2022-01-26 12:57:47
    Qt QFile文件操作详解 很多应用程序都需要具备操作文件的能力,包括对文件内容进行读/写、创建和删除文件等,甚至某些应用程序的诞生纯粹是为了操作文件,比如 WPS Office、PDFedit 等。为此,Qt 框架提供了 QFile ...

    Qt QFile文件操作详解

    很多应用程序都需要具备操作文件的能力,包括对文件内容进行读/写、创建和删除文件等,甚至某些应用程序的诞生纯粹是为了操作文件,比如 WPS Office、PDFedit 等。为此,Qt 框架提供了 QFile 类专门用来操作文件。

    QFile文件操作

    QFile 类支持对文件进行读取、写入、删除、重命名、拷贝等操作,它既可以操作文件文件,也可以操作二进制文件。

    使用 QFile 类操作文件之前,程序中需引入头文件。创建 QFile 类的对象,常用的构造函数有:

    QFile::QFile()
    QFile::QFile(const QString &name)
    

    参数 name 用来指定要操作的目标文件,包含文件的存储路径和文件名,存储路径可以使用绝对路径(比如 “D:/Demo/test.txt”)或者相对路径(比如"./Demo/test.txt"),路径中的分隔符要用 “/” 表示。

    通常情况下,我们会调用第二个构造函数,直接指明要操作的文件。对于第一个构造函数创建的 QFile 对象,需要再调用 setFileName() 方法指明要操作的文件。

    与 C++ 读写文件的规则一样,使用 QFile 读写文件之前必须先打开文件,调用 open() 成员方法即可,常用的语法格式为:

    bool QFile::open(OpenMode mode)
    

    mode 参数用来指定文件的打开方式,下表罗列了此参数的可选值以及各自的含义:

    表 1 QFile文件打开方式

    打开方式含 义
    QIODevice::ReadOnly只能对文件进行读操作
    QIODevice::WriteOnly只能对文件进行写操作,如果目标文件不存在,会自行创建一个新文件。
    QIODevice::ReadWrite等价于 ReadOnly
    QIODevice::Append以追加模式打开文件,写入的数据会追加到文件的末尾(文件原有的内容保留)。
    QIODevice::Truncate以重写模式打开,写入的数据会将原有数据全部清除。注意,此打开方式不能单独使用,通常会和 ReadOnly 或 WriteOnly 搭配。
    QIODevice::Text读取文件时,会将行尾结束符(Unix 系统中是 “\n”,Windows 系统中是 “\r\n”)转换成‘\n’;将数据写入文件时,会将行尾结束符转换成本地格式,例如 Win32 平台上是‘\r\n’。

    根据需要,可以为 mode 参数一次性指定多个值,值和值之间用|分割。比如:

    QIODevice::ReadOnly | QIODevice::Text:表示只允许对文件进行读操作,读取文件时,会将行尾结束符转换为 ‘\n’;

    QIODevice::WriteOnly | QIODevice::Text:表示只允许对文件进行写操作,将数据写入文件时,会将行尾结束符转换为本地格式;

    QIODevice::ReadWrite | QIODevice::Append | QIODevice::Text:表示对文件进行写操作,写入的数据会存放到文件的尾部,同时数据中的行尾结束符转换为本地格式。

    注意,传递给 mode 参数的多个值之间不能相互冲突,比如 Append 和 Truncate 不能同时使用。

    如果文件成功打开,open() 函数返回 true,否则返回 false。

    QFile 类提供了很多功能实用的方法,可以快速完成对文件的操作,下表列举了常用的一些:

    表 2 QFile常用方法

    普通成员方法功 能
    qint64 QFile::size() const获取当前文件的大小。对于打开的文件,该方法返回文件中可以读取的字节数。
    bool QIODevice::getChar(char *c)从文件中读取一个字符,并存储到 c 中。读取成功时,方法返回 true,否则返回 false。
    bool QIODevice::putChar(char c)向文件中写入字符 c,成功时返回 true,否则返回 false。
    QByteArray QIODevice::read(qint64 maxSize)从文件中一次性最多读取 maxSize 个字节,然后返回读取到的字节。
    qint64 QIODevice::read(char *data, qint64 maxSize)从文件中一次性对多读取 maxSize 个字节,读取到的字节存储到 data 指针指定的内存控件中。该方法返回成功读取到的字节数。
    QByteArray QIODevice::readAll()读取文件中所有的数据。
    qint64 QIODevice::readLine(char *data, qint64 maxSize)每次从文件中读取一行数据或者读取最多 maxSize-1 个字节,存储到 data 中。该方法返回实际读取到的字节数。
    qint64 QIODevice::write(const char *data, qint64 maxSize)向 data 数据一次性最多写入 maxSize 个字节,该方法返回实际写入的字节数。
    qint64 QIODevice::write(const char *data)将 data 数据写入文件,该方法返回实际写入的字节数。
    qint64 QIODevice::write(const QByteArray &byteArray)将 byteArray 数组中存储的字节写入文件,返回实际写入的字节数。
    bool QFile::copy(const QString &newName)将当前文件的内容拷贝到名为 newName 的文件中,如果成功,方法返回 true,否则返回 false。copy 方法在执行复制操作之前,会关闭源文件。
    bool QFile::rename(const QString &newName)对当前文件进行重命名,新名称为 newName,成功返回 true,失败返回 false。
    bool QFile::remove()删除当前文件,成功返回 true,失败返回 false。

    【实例一】演示了 QFile 类读写文本文件的过程。

    #include <QFile>
    #include <QDebug>
    int main(int argc, char *argv[])
    {
        //创建 QFile 对象,同时指定要操作的文件
        QFile file("D:/demo.txt");
        //对文件进行写操作
        if(!file.open(QIODevice::WriteOnly|QIODevice::Text)){
            qDebug()<<"文件打开失败";
        }
        //向文件中写入两行字符串
        file.write("C语言\n");
        file.write("http://c.tttttt.net");
        //关闭文件
        file.close();
        //重新打开文件,对文件进行读操作
        if(!file.open(QIODevice::ReadOnly|QIODevice::Text)){
            qDebug()<<"文件打开失败";
        }
        //每次都去文件中的一行,然后输出读取到的字符串
        char * str = new char[100];
        qint64 readNum = file.readLine(str,100);
        //当读取出现错误(返回 -1)或者读取到的字符数为 0 时,结束读取
        while((readNum !=0) && (readNum != -1)){
            qDebug() << str;
            readNum = file.readLine(str,100);
        }
        file.close();
        return 0;
    }
    

    执行程序,“C语言” 和 “http://c.ttttt.net” 先写入 D 盘的 demo.txt 文件,然后再从文件中将它们读取出来。

    【实例二】演示 QFile 读写二进制文件的过程。

    #include <QFile>
    #include <QDebug>
    int main(int argc, char *argv[])
    {
        //指定要写入文件的数据
        qint32 nums[5]={1,2,3,4,5};
        //写入文件之前,要将数据以二进制方式存储到字节数组中
        QByteArray byteArr;
        byteArr.resize(sizeof(nums));
        for(int i=0;i<5;i++){
            //借助指针,将每个整数拷贝到字节数组中
            memcpy(byteArr.data()+i*sizeof(qint32),&(nums[i]),sizeof(qint32));
        }
        //将 byteArr 字节数组存储到文件中
        QFile file("D:/demo.dat");
        file.open(QIODevice::WriteOnly);
        file.write(byteArr);
        file.close();
        //再次打开文件,读取文件中存储的二进制数据
        file.open(QIODevice::ReadOnly);
        QByteArray resArr = file.readAll();
        //输出读取到的二进制数据
        qDebug()<<"resArr: "<<resArr;
        //将二进制数据转化为整数
        char* data = resArr.data();
        while(*data){
            qDebug() << *(qint32*)data;
            data += sizeof(qint32);
        }
        return 0;
    }
    

    执行程序,demo.dat 文件中会存储 {1,2,3,4,5} 这 5 个整数的二进制形式,同时输出以下内容:

    resArr: “\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00”
    1
    2
    3
    4
    5

    单独使用 QFile 类读写文件的过程既繁琐又复杂,Qt 提供了两个辅助类 QTextStream 和 QDataStream,前者用来读写文件文件,后者用来读写二进制文件,QFile 可以和它们搭配使用,从整体上提高读写文件的开发效率。

    QFile+QTextStream

    和单独使用 QFile 类读写文本文件相比,QTextStream 类提供了很多读写文件相关的方法,还可以设定写入到文件中的数据格式,比如对齐方式、写入数字是否带前缀等等。

    使用 QTextStream 类之前,程序中要先引入头文件。QTextStream 类提供了很多种构造函数,常用的是:

    QTextStream(QIODevice *device)
    

    QIODevice 是 QFile 的父类,因此在构造 QTextStream 类的对象时,需要传递一个 QFile 类的对象。

    下表罗列了 QTextStream 类常用的一些方法:

    表 3 QTextStream常用方法

    成员方法功 能
    bool QTextStream::atEnd()const 判断是否读到文件末尾,如果已经达到末尾,返回 true,否则返回 false。
    QString QTextStream::read(qint64 maxlen)从文件中读最多 maxlen 个字符,返回这些字符组成的 QString 字符串。
    QString QTextStream::readAll()从文件中读取所有内容,返回由读取内容组成的 QString 字符串。
    QString QTextStream::readLine(qint64 maxlen = 0)默认读取一行文本,如果手动指定 maxlen 的值,则最多读取 maxlen 个字符,并返回读取内容组成的 QString 字符串。
    void QTextStream::setFieldAlignment(FieldAlignment mode)设置对齐方式,通常与 setFieldWidth() 一起使用。
    void QTextStream::setFieldWidth(int width)设置每份数据占用的位置宽度为 width。

    QTextStream 类重载了>>输入运算符和>>输出运算符,使读写文本文件变得更简单。例如,用 QTextStream 实现【实例一】的程序如下:

    #include <QFile>
    #include <QDebug>
    #include <QString>
    #include <QTextStream>
    int main(int argc, char *argv[])
    {
        //创建 QFile 对象,同时指定要操作的文件
        QFile file("D:/demo.txt");
        //对文件进行写操作
        if(!file.open(QIODevice::WriteOnly|QIODevice::Text)){
            qDebug()<<"文件打开失败";
        }
        QTextStream out(&file);
        //向文件中写入两行字符串
        out << (QString)"C语言中文网\n" << (QString)"http://c.biancheng.net";
        //关闭文件
        file.close();
        //重新打开文件,对文件进行读操作
        if(!file.open(QIODevice::ReadOnly|QIODevice::Text)){
            qDebug()<<"文件打开失败";
        }
        QTextStream in(&file);
        //一直读,直至读取失败
        while(!in.atEnd()){
            QString str;
            //从文件中读取一个字符串
            in >> str;
            qDebug() << str;
        }
        file.close();
        return 0;
    }
    

    和类似,QTextStream 类提供了两种格式化输出的方法,一种是调用该类的成员方法,例如表 3 中的 setFieldAlignment()、setFieldWidth 等,另一种是调用 QTextStream 类提供的格式描述符,下表罗列了常用的一些:

    表 4 QTextStream常用格式描述符

    描述符功能相同的方法功 能
    Qt::hexQTextStream::setIntegerBase(16)将指定整数对应的 16 进制数写入到文件中。
    Qt::showbaseQTextStream::setNumberFlags(numberFlags() ShowBase)对于非十进制数,写入到文件中时带上相应的前缀。二进制数前缀是 0b,八进制数前缀是 0,十六进制数前缀是 0x。
    Qt::forcesignQTextStream::setNumberFlags(numberFlags() ForceSign)将数字写入文件时,带上正负号。
    Qt::fixedQTextStream::setRealNumberNotation(FixedNotation)将浮点数以普通小数的形式写入文件。
    Qt::scientificQTextStream::setRealNumberNotation(ScientificNotation)将浮点数以科学计数法的形式写入文件。
    Qt::leftQTextStream::setFieldAlignment(AlignLeft)左对齐
    Qt::rightQTextStream::setFieldAlignment(AlignRight)右对齐
    Qt::centerQTextStream::setFieldAlignment(AlignCenter)居中对齐

    举个简单的例子:

    #include <QFile>
    #include <QDebug>
    #include <QString>
    #include <QTextStream>
    int main(int argc, char *argv[])
    {
        QFile file("D:/demo.txt");
        if(!file.open(QIODevice::WriteOnly|QIODevice::Text)){
            qDebug()<<"文件打开失败";
        }
        QTextStream out(&file);
        //将 10 的十六进制数写入文件
        out << hex << 10;
        //设置每份数据占用 10 个字符的位置
        out.setFieldWidth(10);
        //以右对齐的方式写入 3.14
        out << left << 3.14;
        //后续数据以左对齐的方式写入文件
        out.setFieldAlignment(QTextStream::AlignRight);
        out << 2.7;
        //关闭文件
        file.close();
        return 0;
    }
    

    程序运行后,demo.txt 存储的文本内容为:

    a3.14 2.7

    QFile+QDataStream

    QDataStream 类的用法和 QTextStream 非常类似,最主要的区别在于,QDataStream 用于读写二进制文件。

    使用 QDataStream 类之前,程序中要引入头文件。创建 QDataStream 对象常用的构造函数为:

    QDataStream::QDataStream(QIODevice *d)
    

    下表罗列了 QDataStream 类常用的成员方法:

    表 5 QDataStream常用方法

    成员方法功 能
    bool QDataStream::atEnd() const判断是否读到文件末尾,如果已经达到末尾,返回 true,否则返回 false。
    QDataStream &QDataStream::readBytes(char *&s, uint &l)对于用 writeBytes() 方法写入文件的 l 和 s,只能使用 readBytes() 方法读取出来。
    int QDataStream::readRawData(char *s, int len)从文件中读取最多 len 字节的数据到 s 中,返回值表示实际读取的字节数。注意,调用该方法之前,需要先给 s 参数分配好内存空间。
    void QDataStream::setVersion(int v)不同版本的 Qt 中,同名称的数据类型也可能存在差异,通过调用此方法手动指定版本号,可以确保读取数据的一致性。
    int QDataStream::skipRawData(int len)跳过文件中的 len 个字节,返回实际跳过的字节数。
    QDataStream &QDataStream::writeBytes(const char *s, uint len)将长度 len 和 s 一起写入到文件中,对于 writeBytes() 写入的数据,只能用 readBytes() 方法读取。
    int QDataStream::writeRawData(const char *s, int len)将 s 中前 len 字节的数据写入文件,返回值表示成功写入的字节数。

    QDataStream 类也对<<和>>进行了重载,举个简单的例子,用 QDataStream 重新实现实例二:

    
    

    #include
    #include
    #include
    int main(int argc, char *argv[])
    {
    //指定要写入文件的数据
    qint32 nums[5]={1,2,3,4,5};
    QFile file(“D:/demo.dat”);
    file.open(QIODevice::WriteOnly);
    //创建 QDataStream 对象
    QDataStream out(&file);
    //将 nums 数组中的整数逐个写入到二进制文件中
    for(int i=0;i<5;i++){
    out << nums[i];
    }
    file.close();
    //再次打开文件,读取文件中存储的二进制数据
    file.open(QIODevice::ReadOnly);
    QDataStream in(&file);
    //读取二进制文件中的数据
    while(!in.atEnd()){
    //每次读取一个整数
    qint32 num;
    in >> num;
    qDebug() << num;
    }
    return 0;
    }

    输出结果为:

    1
    2
    3
    4
    5

    展开全文
  • 07_QFile.rar

    2020-05-31 23:58:41
    07_QFile.rar,07_QFile,widget.h,widget.ui,07_QFile.pro.user,main.cpp,07_QFile.pro,widget.cpp
  • QFile和QDataStream二进制文件读写第三集 一、QFile和QDataStream说明 二、QFile和QDataStream举例.stm 三、QFile和QDataStream举例.dat

    在这里插入图片描述

    在这里插入图片描述
    想看更多精彩内容内容,锁定:
    在这里插入图片描述


    Qt设计师专栏


    文件读写共计3集,想看全集记得去Qt专栏

    一、QFile和QDataStream说明

    除了文本文件,其他都称为二进制文件,QFile负责文件的IO设备接口,QDataStream 以数据流的方式读取文件内容或写入文件内容。QDataStream有两种格式:
    【1】.stm ->写入时,使用Qt预定义的编码。[应用:表格]
    【2】.dat ->写入时,使用二进制原本的格式。[应用:表格]
    【3】QDataStream datastream(&file);//创建数据流栈对象
    datastream.setVersion(QDataStream::Qt_5_9);//流版本号,写入和读取要兼容
    【4】写时推荐使用<<,读取时>>,QDateStream还支持写:QBrush、QColor、QImage、 QIcon等。
    【5】写文件时各种数据类型记住,读取时按照数据类型读取,去看文件是乱码,二进 制一般不支持在线看,除非使用第三方工具。
    【6】Qt预定义编码stm,文件格式不透明,不知字节定义,支持的编程语言少。
    【7】标准编码dat,文件格式透明,知道字节的定义,支持任何编程语言读写文件程序。
    【8】dat读写时,需要指定字节顺序,QDataStream datastream(&file);
    datastream.setByteOrder(QDataStream::LittleEndian);//小端字节序
    小端序:低字节数据存放在内存低地址处;高字节存放在内存高地址处;
    大端序:刚好相反;

    【9】dat写文件:writeRawData()负责整形//writeBytes()负责字符串(推荐)
    在这里插入图片描述

    二、QFile和QDataStream举例.stm

    main.c

    #include "mainwindow.h"
    #include <QApplication>
    #include <QTextCodec>
    int main(int argc, char *argv[])
    {
        //解决中文乱码
        QTextCodec*codec =QTextCodec::codecForName("UTF-8");
        QTextCodec::setCodecForLocale(codec);
        QApplication a(argc, argv);
        MainWindow w;
        w.show();
    
        return a.exec();
    }
    

    mainwindow.h

    
    #include <QMainWindow>
    #include <QFile>
    #include <QFileDialog>
    #include <QDataStream>
    #include <QDir>
    #include <QLabel>
    #include <QStandardItemModel>//数据模型
    #include <QMessageBox>
    #include <QTableView>
    #include <QStringList>
    
    private slots:
        void on_PB_stm_clicked();
        void on_PB_savestm_clicked();
    

    mainwindow.cpp

    #include "mainwindow.h"
    #include "ui_mainwindow.h"
    #include <QDebug>
    MainWindow::MainWindow(QWidget *parent) :
        QMainWindow(parent),
        ui(new Ui::MainWindow)
    {
        ui->setupUi(this);
    }
    MainWindow::~MainWindow()
    {
        delete ui;
    }
    //以Qt预定义编码保存stm文件
    void MainWindow::on_PB_stm_clicked()
    {
        QString curPath = QDir::currentPath();//打开一个目录 并返回目录路径
        qDebug()<<"curPath="<<curPath<<endl;
        QString fileName = QFileDialog::getOpenFileName(this,"选择保存的文件",curPath,"文件类型(*.stm);;所有文件(*.*)");//返回文件的绝对路径
        qDebug()<<"fileName="<<fileName<<endl;
        if(fileName.isEmpty())
            return;
        if(saveStm(fileName))
            QMessageBox::information(this,"提示","文件保存成功");
    }
    //保存stm文件
    bool MainWindow::saveStm(QString &fileName)
    {
        QFile file(fileName);//创建文件栈对象
        if(!(file.open(QIODevice::WriteOnly|QIODevice::Truncate)))
            return false;
        QDataStream datastream(&file);//创建数据流栈对象
        datastream.setVersion(QDataStream::Qt_5_9);//流版本号,写入和读取要兼容
        qint16 rowCount = 1;
        qint16 colCount = 2;
        qreal speed =12.7;
        QString str ="今天写stm";
        //追加方式
        datastream<<rowCount;
        datastream<<colCount;
        datastream<<str;
        datastream<<speed;
        file.close();
        return true;
    }
    //保存stm文件
    void MainWindow::on_PB_savestm_clicked()
    {
        QString curPath = QDir::currentPath();
        qDebug()<<"curPath="<<curPath<<endl;
        QString fileName = QFileDialog::getOpenFileName(this,"选择保存的文件",curPath,"文件类型(*.stm);;所有文件(*.*)");
        qDebug()<<"fileName="<<fileName<<endl;
        if(fileName.isEmpty())
            return ;
        if(openStm(fileName))
            QMessageBox::information(this,"提示","文件打开成功");
    }
    //打开stm文件,读取内容
    bool MainWindow::openStm(QString &fileName)
    {
        QFile file(fileName);//创建文件栈对象
        if(!(file.open(QIODevice::ReadOnly)))
            return false;
        QDataStream datastream(&file);//创建数据流栈对象
        datastream.setVersion(QDataStream::Qt_5_9);//流版本号,写入和读取要兼容
        qint16 rowCount ;
        qint16 colCount;
        QString str ;
        qreal speed ;
        //读取一定要和写时:数据类型相同,箭头相反
        datastream>>rowCount;
        datastream>>colCount;
        datastream>>str;
        datastream>>speed;
    
        QString add = tr("qint16=%1 qint16=%2 str=%3 speed=%4").arg(rowCount).arg(colCount).arg(str).arg(speed);
        ui->textEdit->append(add);
        file.close();
        return true;
    }
    

    截图:
    写入文件
    在这里插入图片描述


    在这里插入图片描述


    读取文件
    在这里插入图片描述

    三、QFile和QDataStream举例.dat

    头文件内容:

    #include <QMainWindow>
    #include <QFile>
    #include <QFileDialog>
    #include <QDataStream>
    #include <QDir>
    #include <QLabel>
    #include <QMessageBox>
    private slots:
        void on_PB_writedat_clicked();
        void on_PB_readdat_clicked();
    private:
        bool saveDat(QString & fileName);
        bool openDat(QString &fileName);
    

    mainwindow.cpp文件

    /*=======================================================================*/
    //保存dat文件
    void MainWindow::on_PB_writedat_clicked()
    {
        QString curPath = QDir::currentPath();
        qDebug()<<"curPath="<<curPath<<endl;
        QString fileName = QFileDialog::getOpenFileName(this,"选择写入的文件",curPath,"文件类型(*.dat);;所有文件(*.*)");
        qDebug()<<"fileName="<<fileName<<endl;
        if(fileName.isEmpty())
            return;
        if(saveDat(fileName))
            QMessageBox::information(this,"提示","文件写入成功");
    }
    bool MainWindow::saveDat(QString &fileName)
    {
        QFile file(fileName);//创建文件栈对象
        if(!(file.open(QIODevice::WriteOnly|QIODevice::Truncate)))
            return false;
        QDataStream datastream(&file);//创建数据流栈对象
        datastream.setByteOrder(QDataStream::LittleEndian);//小端字节序 X86
        //datastream.setByteOrder(QDataStream::BigEndian);//大端字节序 其他嵌入式平台
        //开始写入
        qint16 rowCount = 3;
        qDebug()<<"rowCount->sizeof="<<sizeof(qint16)<<endl;//2字节
        qint16 colCount = 4;
        qreal speed =15.7;
        qDebug()<<"speed->sizeof="<<sizeof(qreal)<<endl;//8字节
        QString str ="今天写dat";
        qDebug()<<"str->sizeof="<<sizeof(QString)<<endl;//4字节
        //写入文件流
        datastream.writeRawData((char *)&rowCount,sizeof(qint16));
        datastream.writeRawData((char *)&colCount,sizeof(qint16));
        datastream.writeRawData((char *)&speed,sizeof(qreal));
        //读取时,如果不知写入时的大小,可能读取错,测试无法获取数据
        //datastream.writeRawData((char *)str,str.length());//1
        //写入时大小已知,方便读取
        datastream.writeBytes(str.toUtf8(),str.toUtf8().length());//写入字符串 2
    
        file.close();
        return true;
    }
    //打开dat文件
    void MainWindow::on_PB_readdat_clicked()
    {
        QString curPath = QDir::currentPath();
        qDebug()<<"curPath="<<curPath<<endl;
        QString fileName = QFileDialog::getOpenFileName(this,"选择保存的文件",curPath,"文件类型(*.dat);;所有文件(*.*)");
        qDebug()<<"fileName="<<fileName<<endl;
        if(fileName.isEmpty())
            return;
        if(openDat(fileName))
            QMessageBox::information(this,"提示","文件保存成功");
    }
    bool MainWindow::openDat(QString &fileName)
    {
        QFile file(fileName);//创建文件栈对象
        if(!(file.open(QIODevice::ReadOnly)))
            return false;
        QDataStream datastream(&file);//创建数据流栈对象
        datastream.setByteOrder(QDataStream::LittleEndian);//小端模式
        qint16 rowCount , colCount ;
        qreal speed ;
        //读取开始  怎么写的则么读
        datastream.readRawData((char *)&rowCount,sizeof(qint16));
        datastream.readRawData((char *)&colCount,sizeof(qint16));
        datastream.readRawData((char *)&speed,sizeof(qreal));
        qDebug()<<"speed = "<<speed<<endl;
        //错误形式
        //datastream.readRawData((char *)&str,sizeof(QString));
        //datastream.readRawData((char *)&str,str.length());
    
        char *buf = nullptr;
        uint strlen;
        datastream.readBytes(buf,strlen);//同时读取内容,和大小
        QString str =QString::fromLocal8Bit(buf,strlen);//字节数组转化为字符串
        qDebug()<<"str = "<<buf<<"strlen = "<<strlen<<endl;
    
        ui->textEdit->append(QString("rowCount=%1 colCount=%2 speed=%3 list=%4 ").arg(rowCount).arg(colCount)
                             .arg(speed).arg(str));
        buf=nullptr;//对指针的操作需要复位  防止野指针
        file.close();
        return true;
    }
    

    截图:
    写入文件
    在这里插入图片描述


    在这里插入图片描述


    读取文件:
    在这里插入图片描述


    在这里插入图片描述

    文件读写三集 完

    展开全文
  • QFileDevice、QFile、QSaveFile、QTemporaryFile
  • QFile文件读写

    千次阅读 2022-05-03 17:43:17
    文章目录简介常用apiQFile类读写文件QFile+QTextStream读写文件 简介 QFile类提供了一个读取和写入文件的接口,一个读写文本、二进制文件和资源的I/O设备。 QFile读写文件的两种方式: 1.QFile可以单独使用。 2....
  • Qt之QFile

    2022-04-14 15:41:54
    QFile QFile link()函数出错分析
  • Qt的QFile

    千次阅读 2019-10-13 20:04:15
    在这里可以说是Qt的帮助文档一样了!确定不进来看看QFile这个东西怎么用么!
  • Qt中文文档-QFile

    2020-10-11 22:21:25
    QFile Class QFile 类提供读写文件的接口。 属性 方法 Header: #include qmake: QT += core Inherits: QFileDevice Inherited By: QTemporaryFile 包含继承成员的成员列表 废弃的成员 注意: 类...
  • 在Qt中读写文件我们常常会用到QFile、QByteArray、QDataStream和QTextStream,他们之间有什么区别呢?
  • QFile文件处理

    2022-04-05 17:08:56
    QFile文件处理 QFile类用于文件操作,它提供了读写文件的接口,可以读写文件、二进制文件和Qt资源文件。 处理文本文件和二进制文件,可以使用QTextStream类和QDataStream类。处理临时文件可以使用QTemporaryFile,...
  • 想用Qt5.9的QFile内容写入ini保存参数, 但是这里写好了以后发现英文部分正常,但中文部分并不能读取参数, ini我手动使用txt打开中文部分是“?”,qDebug控制台输出是 不认识的中文字符 网上查询应该是编码格式...
  • Qfile

    2019-05-02 17:36:00
    打开方式: 1 void AddStudents::write_to_file(QString src){ ... 2 QFile file("stu.txt"); 3 if (!file.open(QIODevice::Append | QIODevice::Text)){ 4 QMessageBox::critical(this,"打开文...
  • QFile读文件

    2022-06-04 10:33:57
    QFile 文件读写
  • Qt文件QFile

    2022-07-18 18:41:51
    QFile
  • Qt -- QFile文件读写操作

    千次阅读 2022-02-09 16:14:40
    而在 Qt 中也有一套,即使用 QFile 对文件进行读和写操作。 首先创建一个新的工程,以下操作为了迎合 嵌入式Linux 开发,决定在 ubuntu 中进行,并使用 rsync 进行远程调试。 首先,窗体中搭建一个场景,并且将窗体...
  • 案例: 该文件是nginx服务的配置文件,需要做的是替换文件中 listen后的的端口号 先上代码: QFile fileRead(filePath); //先读取文件信息,QIODevice::Text能将换行转为\n QString arryRead; if(fileRead.open...
  • QFile文件处理对象
  • Qt QFile文件操作

    2022-02-17 19:45:28
    文章目录1、文件读写操作2、文件详细信息操作 1、文件读写操作 文件文本流操作 // 文件写入 double dPI = 3.1415926;... if(dataFile.open(QFile::WriteOnly|QFile::Truncate)) { // 文本流 QTextStream out
  • 实战PyQt5: 126-使用QFile进行文件操作

    千次阅读 2020-12-30 17:06:49
    在本文将详细介绍Qt中的文件操作接口类QFile来处理文件的I/O操作。 QFile简介 QFile类提供用于读取和写入文件的接口。QFile是用于读取和写入文本及二进制文件的I/O设备。QFile可以单独使用,也可以和QTextStream或...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,346
精华内容 6,538
关键字:

Qfile