就业培训     下载中心     Wiki     联络 登录   注册
  1. 首页
  2. Qt 6.5.1
  3. Qt Core
  4. C++ 类
  5. QIODevice

QIODevice 类

QIODevice 类是 Qt 中所有 I/O 设备的基接口类。 更多...

头： #include <QIODevice>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core
继承： QObject and QIODeviceBase
继承者： QAbstractSocket , QBluetoothSocket , QBuffer , QCoapReply , QFileDevice , QLocalSocket , QNetworkReply , QProcess ，和 QSerialPort

注意： 此类的所有函数 可重入 .

公共函数

QIODevice ()
QIODevice (QObject * parent )
virtual ~QIODevice ()
virtual bool atEnd () const
virtual qint64 bytesAvailable () const
virtual qint64 bytesToWrite () const
virtual bool canReadLine () const
virtual void close ()
void commitTransaction ()
int currentReadChannel () const
int currentWriteChannel () const
QString errorString () const
bool getChar (char * c )
bool isOpen () const
bool isReadable () const
virtual bool isSequential () const
bool isTextModeEnabled () const
bool isTransactionStarted () const
bool isWritable () const
virtual bool open (QIODeviceBase::OpenMode mode )
QIODeviceBase::OpenMode openMode () const
qint64 peek (char * data , qint64 maxSize )
QByteArray peek (qint64 maxSize )
virtual qint64 pos () const
bool putChar (char c )
qint64 read (char * data , qint64 maxSize )
QByteArray read (qint64 maxSize )
QByteArray readAll ()
int readChannelCount () const
qint64 readLine (char * data , qint64 maxSize )
QByteArray readLine (qint64 maxSize = 0)
virtual bool reset ()
void rollbackTransaction ()
virtual bool seek (qint64 pos )
void setCurrentReadChannel (int channel )
void setCurrentWriteChannel (int channel )
void setTextModeEnabled (bool enabled )
virtual qint64 size () const
qint64 skip (qint64 maxSize )
void startTransaction ()
void ungetChar (char c )
virtual bool waitForBytesWritten (int msecs )
virtual bool waitForReadyRead (int msecs )
qint64 write (const char * data , qint64 maxSize )
qint64 write (const char * data )
qint64 write (const QByteArray & data )
int writeChannelCount () const

信号

void aboutToClose ()
void bytesWritten (qint64 bytes )
void channelBytesWritten (int channel , qint64 bytes )
void channelReadyRead (int channel )
void readChannelFinished ()
void readyRead ()

保护函数

virtual qint64 readData (char * data , qint64 maxSize ) = 0
virtual qint64 readLineData (char * data , qint64 maxSize )
void setErrorString (const QString & str )
void setOpenMode (QIODeviceBase::OpenMode openMode )
virtual qint64 skipData (qint64 maxSize )
virtual qint64 writeData (const char * data , qint64 maxSize ) = 0

详细描述

QIODevice 为支持数据块读写的设备提供公共实现和抽象接口，譬如 QFile , QBuffer and QTcpSocket 。QIODevice 是抽象的且无法被实例化，但通常使用它定义的接口以提供设备无关的 I/O 特征。例如：Qt 的 XML 类运转于 QIODevice 指针，允许它们与各种设备 (譬如：文件和缓冲) 一起使用。

在访问设备之前， open () 必须被调用以设置正确 OpenMode (譬如 ReadOnly 或 ReadWrite)。然后可以写入设备采用 write () 或 putChar ()，和读取通过调用 read (), readLine ()，或 readAll ()。调用 close ()，当设备用完时。

QIODevice 分 2 种类型的设备：随机访问设备和顺序设备。

  • 随机访问设备支持寻址到任意位置使用 seek ()。可以获得文件的当前位置通过调用 pos (). QFile and QBuffer 是随机访问设备范例。
  • 顺序设备不支持寻址到任意位置。数据必须被一次性读取。函数 pos () 和 size () 不工作对于顺序设备。 QTcpSocket and QProcess 是顺序设备范例。

可以使用 isSequential () 确定设备类型。

QIODevice 发射 readyRead () 当有新数据可供读取时；例如，若新数据到达网络，或额外数据被追加到正读取的文件中。可以调用 bytesAvailable () 以确定目前可供读取的字节数。常用 bytesAvailable () 连同 readyRead () 信号当采用异步设备编程时，譬如 QTcpSocket ，数据片段可以在任意时间点到达。QIODevice 发射 bytesWritten () 信号，每次将数据负载写入设备时。使用 bytesToWrite () 以确定当前等待写入的数据量。

QIODevice 的某些子类，如 QTcpSocket and QProcess , 是异步的。这意味着 I/O 函数，譬如 write () 或 read () 总是立即返回，而与设备本身的通信则可能发生，当控制返回给事件循环时。QIODevice 提供的函数允许强制立即履行这些操作，同时阻塞调用线程且不进入事件循环。这允许 QIODevice 子类在没有事件循环的情况下 (或在单独线程中) 使用：

  • waitForReadyRead () - 此函数挂起调用线程中的操作，直到有新数据可供读取。
  • waitForBytesWritten () - 此函数挂起调用线程中的操作，直到将某一数据负载写入设备为止。
  • waitFor....() - QIODevice 子类为特定设备操作实现阻塞功能。例如， QProcess 拥有函数称为 waitForStarted () 挂起调用线程中的操作，直到进程启动。

从主 GUI 线程调用这些函数可能导致用户界面被冻结。范例： 

QProcess gzip;
gzip.start("gzip", QStringList() << "-c");
if (!gzip.waitForStarted())
    return false;
gzip.write("uncompressed data");
QByteArray compressed;
while (gzip.waitForReadyRead())
    compressed += gzip.readAll();

通过子类化 QIODevice，可以为自己的 I/O 设备提供相同接口。QIODevice 的子类只要求实现保护 readData () 和 writeData () 函数。QIODevice 使用这些函数以实现其所有方便函数，譬如 getChar (), readLine () 和 write ()。QIODevice 还为您处理访问控制，所以可以安全地假定设备以写入模式打开，若 writeData () 被调用。

某些子类，譬如 QFile and QTcpSocket ，使用内存缓冲实现数据的中间体存储。这减少了要求设备的访问调用 (经常非常慢) 数。缓冲使函数像 getChar () 和 putChar () 很快，因为它们可以运转于内存缓冲，而不是直接运转于设备本身。不管怎样，某些 I/O 操作不能很好的操控缓冲。例如，若多个用户打开同一设备并逐字符读取，它们最终可能读取相同数据，当它们打算读取各单独组块时。出于此原因，QIODevice 允许绕过任何缓冲通过将 Unbuffered 标志传递给 open ()。当子类化 QIODevice 时，记得绕过可以使用的任何缓冲，当设备以 Unbuffered 模式打开时。

通常，来自异步设备的传入数据流是碎片化的，且数据组块可以在任意时间点到达。要处理数据结构的不完整读取，使用事务机制实现通过 QIODevice。见 startTransaction () 和相关函数了解更多细节。

某些顺序设备支持凭借多个通道的通信。这些通道表示拥有独立顺序交付特性的单独数据流。设备被打开后，就可以确定通道数通过调用 readChannelCount () 和 writeChannelCount () 函数。要在通道之间切换，调用 setCurrentReadChannel () 和 setCurrentWriteChannel ()，分别。QIODevice 还提供额外信号以处理基于每通道的异步通信。

另请参阅 QBuffer , QFile ，和 QTcpSocket .

成员函数文档编制

QIODevice:: QIODevice ()

构造 QIODevice 对象。

[explicit] QIODevice:: QIODevice ( QObject * parent )

构造 QIODevice 对象采用给定 parent .

[虚拟] QIODevice:: ~QIODevice ()

析构函数是虚拟的，且 QIODevice 是抽象基类。此析构函数不调用 close ()，但子类析构函数可能会。若有疑问，调用 close () 之后销毁 QIODevice .

[signal] void QIODevice:: aboutToClose ()

此信号被发射当设备即将关闭时。连接此信号，若需要履行操作在设备关闭之前 (如：若在需要写入设备的单独缓冲中有数据)。

[虚拟] bool QIODevice:: atEnd () const

返回 true 若当前读写位置在设备的末端 (即：设备中没有更多可供读取的数据)；否则返回 false .

对于某些设备，atEnd() 可以返回 true 即使有更多数据要读取。此特殊情况仅适用于设备生成数据以直接响应调用 read () (如， /dev or /proc 文件在 Unix 和 macOS，或控制台输入 / stdin 在所有平台)。

另请参阅 bytesAvailable (), read ()，和 isSequential ().

[虚拟] qint64 QIODevice:: bytesAvailable () const

返回可供读取的可用字节数。此函数通常用于顺序设备，以确定在读取之前缓冲中分配的字节数。

重实现此函数的子类必须调用基实现为包括缓冲大小对于 QIODevice 。范例： 

qint64 CustomDevice::bytesAvailable() const
{
    return buffer.size() + QIODevice::bytesAvailable();
}

另请参阅 bytesToWrite (), readyRead ()，和 isSequential ().

[虚拟] qint64 QIODevice:: bytesToWrite () const

对于缓冲设备，此函数返回等待写入的字节数。对于没有缓冲的设备，此函数返回 0。

重实现此函数的子类必须调用基实现为包括缓冲大小对于 QIODevice .

另请参阅 bytesAvailable (), bytesWritten ()，和 isSequential ().

[signal] void QIODevice:: bytesWritten ( qint64 bytes )

此信号被发射，每次将数据负载写入设备的当前写入通道时。 bytes 自变量是在此负载中写入的设置字节数。

bytesWritten() 不会递归发射；若重新进入事件循环或调用 waitForBytesWritten () 在连接到 bytesWritten() 信号的槽内，信号不会被重新发射 (尽管 waitForBytesWritten () 可能仍返回 true)。

另请参阅 readyRead ().

[虚拟] bool QIODevice:: canReadLine () const

返回 true 若可以从设备读取完整数据行；否则返回 false .

注意：没有办法确定是否可以读取的无缓冲设备始终返回 false。

此函数经常被调用结合 readyRead () 信号。

重实现此函数的子类必须调用基实现以便包括内容为 QIODevice 的缓冲。范例： 

bool CustomDevice::canReadLine() const
{
    return buffer.contains('\n') || QIODevice::canReadLine();
}

另请参阅 readyRead () 和 readLine ().

[signal] void QIODevice:: channelBytesWritten ( int channel , qint64 bytes )

此信号被发射，每次将数据负载写入设备时。 bytes 自变量设置此负载要写入的字节数，而 channel 是它们要写入的通道。不像 bytesWritten ()，它被发射不管 当前写入通道 .

channelBytesWritten() 可以被递归发射 - 即使是同一通道。

另请参阅 bytesWritten () 和 channelReadyRead ().

[signal] void QIODevice:: channelReadyRead ( int channel )

此信号被发射当有新数据可用于从设备读取时。 channel 自变量设置已到达数据的读取通道索引。不像 readyRead ()，它被发射不管 当前读取通道 .

channelReadyRead() 可以被递归发射 - 即使是同一通道。

另请参阅 readyRead () 和 channelBytesWritten ().

[虚拟] void QIODevice:: close ()

首先发射 aboutToClose ()，然后关闭设备并将其 OpenMode 设为 NotOpen。错误字符串也被重置。

另请参阅 setOpenMode () 和 QIODeviceBase::OpenMode .

void QIODevice:: commitTransaction ()

完成读取事务。

对于顺序设备，在事务期间记录在内部缓冲的所有数据将被丢弃。

另请参阅 startTransaction () 和 rollbackTransaction ().

int QIODevice:: currentReadChannel () const

返回当前读取通道的索引。

另请参阅 setCurrentReadChannel (), readChannelCount ()，和 QProcess .

int QIODevice:: currentWriteChannel () const

返回当前写入通道的索引。

另请参阅 setCurrentWriteChannel () 和 writeChannelCount ().

QString QIODevice:: errorString () const

返回人类可读的最后发生的设备错误描述。

另请参阅 setErrorString ().

bool QIODevice:: getChar ( char * c )

从设备读取 1 字符并把它存储在 c 。若 c is nullptr ，字符被丢弃。返回 true 当成功时；否则返回 false .

另请参阅 read (), putChar ()，和 ungetChar ().

bool QIODevice:: isOpen () const

返回 true 若设备是打开的；否则返回 false 。设备是打开的若可以读/写。默认情况下，此函数返回 false if openMode () 返回 NotOpen .

另请参阅 openMode () 和 QIODeviceBase::OpenMode .

bool QIODevice:: isReadable () const

返回 true 若可以从设备读取数据；否则返回 false。使用 bytesAvailable () 以确定可以读取多少字节。

这是方便函数，用于校验设备 OpenMode 是否包含 ReadOnly 标志。

另请参阅 openMode () 和 OpenMode .

[虚拟] bool QIODevice:: isSequential () const

返回 true 若此设备是顺序的；否则返回 false。

与随机访问设备相反，顺序设备没有开始、结束、大小或当前位置的概念，且它们不支持寻址。才可以从设备读取数据，仅当设备报告数据可用时。顺序设备的最常见范例是网络套接字。在 Unix，特殊文件 (譬如 /dev/zero 和 fifo 管道) 是顺序的。

另一方面，常规文件确实支持随机访问。它们拥有大小和当前位置，且它们还支持在数据流中向后和向前寻址。常规文件是非顺序的。

另请参阅 bytesAvailable ().

bool QIODevice:: isTextModeEnabled () const

返回 true 若 Text 标志被启用；否则返回 false .

另请参阅 setTextModeEnabled ().

bool QIODevice:: isTransactionStarted () const

返回 true 若事务在设备上正在进行中，否则 false .

另请参阅 startTransaction ().

bool QIODevice:: isWritable () const

返回 true 若可以把数据写入设备；否则返回 false。

这是方便函数，用于校验设备 OpenMode 是否包含 WriteOnly 标志。

另请参阅 openMode () 和 OpenMode .

[虚拟] bool QIODevice:: open ( QIODeviceBase::OpenMode mode )

打开设备并将其 OpenMode 设为 mode 。返回 true 若成功；否则返回 false 。应该从 open() 或打开设备的其它函数的任何重实现调用此函数。

另请参阅 openMode () 和 QIODeviceBase::OpenMode .

QIODeviceBase::OpenMode QIODevice:: openMode () const

返回设备被打开的模式；即：ReadOnly 或 WriteOnly。

另请参阅 setOpenMode () 和 OpenMode .

qint64 QIODevice:: peek ( char * data , qint64 maxSize )

读取最多 maxSize 字节从设备到 data ，无副作用 (即：若调用 read () 在 peek() 之后，将获得相同数据)。返回读取字节数。若发生错误 (譬如：当试图窥视以 WriteOnly 模式打开的设备时)，此函数返回 -1。

返回 0，当没有更多数据可供读取时。

范例： 

bool isExeFile(QFile *file)
{
    char buf[2];
    if (file->peek(buf, sizeof(buf)) == sizeof(buf))
        return (buf[0] == 'M' && buf[1] == 'Z');
    return false;
}

另请参阅 read ().

QByteArray QIODevice:: peek ( qint64 maxSize )

这是重载函数。

窥视最多 maxSize 字节从设备，返回窥视数据作为 QByteArray .

范例： 

bool isExeFile(QFile *file)
{
    return file->peek(2) == "MZ";
}

此函数没有办法报告错误；返回空 QByteArray 可能意味着当前没有数据可供窥视，或发生错误。

另请参阅 read ().

[虚拟] qint64 QIODevice:: pos () const

对于随机访问设备，此函数返回要写入或读取数据的位置。对于没有当前位置概念的顺序设备或闭合设备，返回 0。

设备的当前读/写位置的内部维护由 QIODevice ，因此重实现此函数不必要。当子类化 QIODevice ，使用 QIODevice::seek () 来通知 QIODevice 关于设备位置的变化。

另请参阅 isSequential () 和 seek ().

bool QIODevice:: putChar ( char c )

写入字符 c 到设备。返回 true 当成功时；否则返回 false .

另请参阅 write (), getChar ()，和 ungetChar ().

qint64 QIODevice:: read ( char * data , qint64 maxSize )

读取最多 maxSize 字节从设备到 data ，并返回读取字节数。若发生错误，譬如试图读取以 WriteOnly 模式打开的设备，此函数返回 -1。

返回 0 当没有更多可供读取的数据时。无论如何，认为读取流的末尾是错误的，所以，在此情况 (即：在关闭的套接字上读取，或在进程已死亡之后读取) 下，此函数返回 -1。

另请参阅 readData (), readLine ()，和 write ().

QByteArray QIODevice:: read ( qint64 maxSize )

这是重载函数。

读取最多 maxSize 字节从设备，并把读取数据返回作为 QByteArray .

此函数没有办法报告错误；返回空 QByteArray 可以意味着目前没有数据可供读取，或发生错误。

QByteArray QIODevice:: readAll ()

从设备读取所有剩余数据，并将其作为字节数组返回。

此函数没有办法报告错误；返回空 QByteArray 可能意味着目前没有可用于读取的数据 (或出现错误)。此函数也没有办法指示，可能有更多数据可用且无法读取。

int QIODevice:: readChannelCount () const

返回可用的读取通道数若设备是打开的；否则返回 0。

另请参阅 writeChannelCount () 和 QProcess .

[signal] void QIODevice:: readChannelFinished ()

此信号被发射当关闭此设备的输入 (读取) 流时。一检测到关闭就尽快发出它，这意味着可能仍有数据可供读取采用 read ().

另请参阅 atEnd () 和 read ().

[pure virtual protected] qint64 QIODevice:: readData ( char * data , qint64 maxSize )

读取到 maxSize 字节从设备到 data ，并返回读取字节数；返回 -1 若发生错误。

若没有字节要读取且从不会有更多字节可用 (范例包括：套接字被关闭、管道被关闭、子进程已完成)，此函数返回 -1。

此函数被调用通过 QIODevice 。重实现此函数，当创建子类为 QIODevice .

当重实现此函数时，此函数在返回之前读取所有要求数据是很重要的。这是必需的为 QDataStream 能够运转于类。 QDataStream 假定读取了所有请求信息，因此，不会试着读取 (若存在问题)。

可以在 maxSize 为 0 的情况下调用 此函数，用于履行读取后操作。

另请参阅 read (), readLine ()，和 writeData ().

qint64 QIODevice:: readLine ( char * data , qint64 maxSize )

此函数从设备读取一行 ASCII 字符，直到最多 maxSize - 1 字节，将字符存储在 data ，并返回读取字节数。若无法读取行但未发生错误，此函数返回 0。若发生错误，此函数返回可以读取的内容长度，或 -1 若什么都未读取。

终止 \0 字节始终被追加到 data ，所以 maxSize 必须大于 1。

读取数据直到满足以下任一条件：

  • 第一 \n 字符被读取。
  • maxSize - 1 字节被读取。
  • 检测到设备数据结束。

例如，以下代码从文件读取一行字符： 

QFile file("box.txt");
if (file.open(QFile::ReadOnly)) {
    char buf[1024];
    qint64 lineLength = file.readLine(buf, sizeof(buf));
    if (lineLength != -1) {
        // the line is available in buf
    }
}

换行符 \n 包括在缓冲中。若在读取 maxSize -1 字节之前未遭遇换行符，则不会将换行符插入缓冲。在 Windows，采用 \n 替换换行符。

注意：对于顺序设备，数据可能不会立即可用，这可能导致返回部分行。通过调用 canReadLine () 函数在读取之前，可以校验是否能读取完整行 (包括换行符)。

此函数调用 readLineData ()，这的实现是使用重复调用对 getChar ()。可以提供更高效实现通过重实现 readLineData () 在自己的子类中。

另请参阅 getChar (), read (), canReadLine ()，和 write ().

QByteArray QIODevice:: readLine ( qint64 maxSize = 0)

这是重载函数。

从设备读取行，但不超过 maxSize 字符，并以字节数组形式返回结果。

此函数没有办法报告错误；返回空 QByteArray 可以意味着目前没有数据可供读取，或发生错误。

[virtual protected] qint64 QIODevice:: readLineData ( char * data , qint64 maxSize )

读取到 maxSize 字符到 data 并返回读取的字符数。

此函数被调用通过 readLine ()，并提供其基实现，使用 getChar ()。缓冲设备可以改善性能对于 readLine () 通过重实现此函数。

readLine () 追加 \0 字节到 data ；readLineData() 不需要这样做。

若重实现此函数，小心返回正确值：它应返回在这一行中读取的字节数 (包括终止换行符)，或 0 若此时没有行要读取。若出现错误，应返回 -1，当且仅当没有字节要读取时。读取超过 EOF 认为出错。

[signal] void QIODevice:: readyRead ()

此信号被发射一次，每次有新数据可用于从设备当前读取通道读取时。它只会在新数据可用时再发射一次，譬如：当新网络数据负载到达网络套接字时，或当新数据块被追加到设备时。

readyRead() 不会递归发射；若重新进入事件循环或调用 waitForReadyRead () 在连接到 readyRead() 信号的槽内，信号不会被重新发射 (尽管 waitForReadyRead () 可能仍返回 true)。

注意，开发者实现的类派生自 QIODevice ：应始终发射 readyRead() 当有新数据到达时 (不要仅因为缓冲中仍有数据要读取而发射它)。在其它条件下不要发射 readyRead()。

另请参阅 bytesWritten ().

[虚拟] bool QIODevice:: reset ()

寻址随机访问设备输入起始。成功返回 true；否则返回 false (例如：若设备未被打开)。

注意，当使用 QTextStream 在 QFile ，调用 reset() 在 QFile 将不会有期望结果，因为 QTextStream 缓冲文件。使用 QTextStream::seek () 函数代替。

另请参阅 seek ().

void QIODevice:: rollbackTransaction ()

回滚读取事务。

将输入流还原到点对于 startTransaction () 调用。此函数常用于回滚事务，当在提交事务之前检测到读取未完成时。

另请参阅 startTransaction () 和 commitTransaction ().

[虚拟] bool QIODevice:: seek ( qint64 pos )

对于随机访问设备，此函数将当前位置设为 pos ，返回 true 当成功时，或 false 若发生错误。对于顺序设备，默认行为是产生警告并返回 false。

当子类化 QIODevice ，必须在函数开始时调用 QIODevice::seek() 以确保完整性采用 QIODevice 的内置缓冲。

另请参阅 pos () 和 isSequential ().

void QIODevice:: setCurrentReadChannel ( int channel )

设置当前读取通道为 QIODevice 到给定 channel 。当前输入通道用于函数 read (), readAll (), readLine ()，和 getChar ()。它还确定哪个通道触发 QIODevice 以发射 readyRead ().

另请参阅 currentReadChannel (), readChannelCount ()，和 QProcess .

void QIODevice:: setCurrentWriteChannel ( int channel )

设置当前写入通道为 QIODevice 到给定 channel 。当前输出通道用于函数 write (), putChar ()。它还确定哪个通道触发 QIODevice 以发射 bytesWritten ().

另请参阅 currentWriteChannel () 和 writeChannelCount ().

[protected] void QIODevice:: setErrorString (const QString & str )

将最后发生的设备错误的人类可读描述设为 str .

另请参阅 errorString ().

[protected] void QIODevice:: setOpenMode ( QIODeviceBase::OpenMode openMode )

将设备 OpenMode 设为 openMode 。调用此函数以设置打开模式，若设备打开后标志有变化。

另请参阅 openMode () 和 OpenMode .

void QIODevice:: setTextModeEnabled ( bool enabled )

若 enabled 为 true，此函数设置 Text 标志在设备；否则 Text 标志被移除。此特征很有用，对于提供自定义行尾处理的类而言在 QIODevice .

IO 设备应被打开，在调用此函数之前。

另请参阅 isTextModeEnabled (), open ()，和 setOpenMode ().

[虚拟] qint64 QIODevice:: size () const

对于打开的随机访问设备，此函数返回设备的大小。对于打开的顺序设备， bytesAvailable () 被返回。

若设备是关闭的，返回尺寸不会反映设备的实际大小。

另请参阅 isSequential () 和 pos ().

qint64 QIODevice:: skip ( qint64 maxSize )

跳过直到 maxSize 字节从设备。返回实际跳过字节数，或 -1 当出错时。

此函数不等待，且仅丢弃已可供读取的数据。

若以文本方式打开设备，把行尾终止符转换成 \n 符号并计为单个字节等同 read () 和 peek () 行为。

此函数适于所有设备，包括顺序设备无法 seek ()。它被优化以跳过不想要的数据之后 peek () 调用。

对于随机访问设备，skip() 可用于从当前位置向前寻址。负数 maxSize 值是不允许的。

另请参阅 skipData (), peek (), seek ()，和 read ().

[virtual protected, since 6.0] qint64 QIODevice:: skipData ( qint64 maxSize )

跳过直到 maxSize 字节从设备。返回实际跳过字节数，或 -1 当出错时。

此函数被调用通过 QIODevice 。考虑重实现它当创建子类化的 QIODevice .

基实现通过读入虚设缓冲以丢弃数据。这很慢，但工作于所有设备类型。子类可以重实现此函数以改进这。

该函数在 Qt 6.0 引入。

另请参阅 skip (), peek (), seek ()，和 read ().

void QIODevice:: startTransaction ()

在设备上启动新的读取事务。

在读取操作的序列中，定义可还原点。对于顺序设备，读取数据将在内部被复制，以在读取不完整的情况下允许还原。对于随机访问设备，此函数保存当前位置。调用 commitTransaction () 或 rollbackTransaction () 去完成事务。

注意： 嵌套事务不被支持。

另请参阅 commitTransaction () 和 rollbackTransaction ().

void QIODevice:: ungetChar ( char c )

放置字符 c 回到设备，并递减当前位置除非位置为 0。此函数通常被称为撤销 getChar () 操作，譬如：当编写回溯剖析器时。

若 c 先前未从设备读取，行为未定义。

注意： 此函数不可用，当事务正在进行时。

[虚拟] bool QIODevice:: waitForBytesWritten ( int msecs )

对于缓冲设备，此函数等待直到缓冲写入数据负载已写入设备且 bytesWritten () 信号已发射，或直到 msecs 毫秒已过去。若 msecs 为 -1，此函数不会超时。对于无缓冲设备，会立即返回。

返回 true 若数据负载已写入设备；否则返回 false （即：若操作超时或发生错误)。

可以在没有事件循环的情况下操作此函数。它很有用，当编写非 GUI 应用程序和在非 GUI 线程中履行 I/O 操作时。

若调用来自的槽有连接到 bytesWritten () 信号， bytesWritten () 不会重新发射。

重实现此函数能为自定义设备提供阻塞 API。默认实现什么都不做，并返回 false .

警告： 从主 GUI 线程调用此函数可能导致用户界面被冻结。

另请参阅 waitForReadyRead ().

[虚拟] bool QIODevice:: waitForReadyRead ( int msecs )

阻塞直到有新的数据可供读取且 readyRead () 信号已发射，或直到 msecs 毫秒已过去。若 msecs 为 -1，此函数不会超时。

返回 true 若新数据可用于读取；否则返回 false (若操作超时或发生错误)。

可以在没有事件循环的情况下操作此函数。它很有用，当编写非 GUI 应用程序和在非 GUI 线程中履行 I/O 操作时。

若调用来自的槽有连接到 readyRead () 信号， readyRead () 不会重新发射。

重实现此函数能为自定义设备提供阻塞 API。默认实现什么都不做，并返回 false .

警告： 从主 GUI 线程调用此函数可能导致用户界面被冻结。

另请参阅 waitForBytesWritten ().

qint64 QIODevice:: write (const char * data , qint64 maxSize )

写入最多 maxSize 字符的数据从 data 到设备。返回实际写入字节数；或 -1，若发生错误。

另请参阅 read () 和 writeData ().

qint64 QIODevice:: write (const char * data )

这是重载函数。

把数据从 8 位字符的零终止字符串写入设备。返回实际写入字节数；或 -1，若发生错误。这相当于 

...
QIODevice::write(data, qstrlen(data));
...

另请参阅 read () 和 writeData ().

qint64 QIODevice:: write (const QByteArray & data )

这是重载函数。

写入内容为 data 到设备。返回实际写入字节数；或 -1，若发生错误。

另请参阅 read () 和 writeData ().

int QIODevice:: writeChannelCount () const

返回可用写入通道数，若设备是打开的；否则返回 0。

另请参阅 readChannelCount ().

[pure virtual protected] qint64 QIODevice:: writeData (const char * data , qint64 maxSize )

写入直到 maxSize 字节来自 data 到设备。返回写入字节数，或 -1 若发生错误。

此函数被调用通过 QIODevice 。重实现此函数，当创建子类为 QIODevice .

当重实现此函数时，此函数在返回前写入所有可用数据很重要。这是必需的为使 QDataStream 能够运转于类。 QDataStream 假定写入了所有信息，因此，不会试着写入 (若存在问题)。

另请参阅 read () 和 write ().

内容