内容

公共类型
公共函数
信号
保护函数
详细描述

QIODevice 类

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

头：	#include <QIODevice>
继承：	QObject
继承者：	Q3Socket , Q3SocketDevice , QAbstractSocket , QBuffer , QFile , QLocalSocket , QNetworkReply ，和 QProcess

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

公共类型

flags	OpenMode
enum	OpenModeFlag { NotOpen, ReadOnly, WriteOnly, ReadWrite, ..., Unbuffered }

公共函数

	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 ()
QString	errorString () const
bool	getChar (char * c )
bool	isOpen () const
bool	isReadable () const
virtual bool	isSequential () const
bool	isTextModeEnabled () const
bool	isWritable () const
virtual bool	open (OpenMode mode )
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 ()
qint64	readLine (char * data , qint64 maxSize )
QByteArray	readLine (qint64 maxSize = 0)
virtual bool	reset ()
virtual bool	seek (qint64 pos )
void	setTextModeEnabled (bool enabled )
virtual qint64	size () const
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 & byteArray )

29 公共函数继承自 QObject

信号

void	aboutToClose ()
void	bytesWritten (qint64 bytes )
void	readChannelFinished ()
void	readyRead ()

1 信号继承自 QObject

保护函数

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

8 保护函数继承自 QObject

额外继承成员

1 特性继承自 QObject
1 公共槽继承自 QObject
7 静态公共成员继承自 QObject

详细描述

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

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

在访问设备之前， open () 必须被调用以设置正确 OpenMode (譬如 ReadOnly or 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 has a function called waitForStarted() which suspends operation in the calling thread until the process has started.

从主 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 模式打开时。

另请参阅 QBuffer , QFile ，和 QTcpSocket .

成员类型文档编制

enum QIODevice:: OpenModeFlag
flags QIODevice:: OpenMode

此枚举用于 open () 以描述设备被打开的模式。它也被返回由 openMode ().

常量	值	描述
`QIODevice::NotOpen`	`0x0000`	设备未打开。
`QIODevice::ReadOnly`	`0x0001`	打开设备以供读取。
`QIODevice::WriteOnly`	`0x0002`	The device is open for writing.
`QIODevice::ReadWrite`	`ReadOnly \| WriteOnly`	打开设备以供读写。
`QIODevice::Append`	`0x0004`	The device is opened in append mode, so that all data is written to the end of the file.
`QIODevice::Truncate`	`0x0008`	若可能，会截取设备在它被打开之前。设备的所有早期内容将丢失。
`QIODevice::Text`	`0x0010`	当读取时，把行尾终止符转换成 \n。当写入时，把行尾终止符转换成本地编码 (例如：用于 Win32 的 \r\n)。
`QIODevice::Unbuffered`	`0x0020`	绕过任何设备缓冲。

某些标志，譬如 Unbuffered and Truncate 没有意义，当用于某些子类时。其中某些限定由子类表示的设备类型所隐含。在其它情况下，限定可能是由于实现，或可能是通过底层平台施加；例如， QTcpSocket 不支持 Unbuffered 模式，且局限在本机 API 以阻止 QFile 从支持 Unbuffered 在 Windows。

OpenMode 类型是 typedef 对于 QFlags <OpenModeFlag>。它存储 OpenModeFlag 值的 OR 组合。

成员函数文档编制

QIODevice:: QIODevice ()

构造 QIODevice 对象。

QIODevice:: QIODevice ( QObject * parent )

构造 QIODevice 对象采用给定 parent .

`[虚拟]` QIODevice:: ~QIODevice ()

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

`[signal]` void QIODevice:: aboutToClose ()

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

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

Returns true if the current read and write position is at the end of the device (i.e. there is no more data available for reading on the device); otherwise returns false.

对于某些设备，atEnd() 可以返回 true 即使有更多数据要读取。此特殊情况仅适用于设备生成数据以直接响应调用 read () (如， /dev or /proc files on Unix and Mac OS X, or console input / stdin 在所有平台)。

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

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

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

Subclasses that reimplement this function must call the base implementation in order to include the size of QIODevices' buffer. Example:

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

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

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

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

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

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

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

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

另请参阅 readyRead ().

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

Returns true if a complete line of data can be read from the device; otherwise returns false.

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

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

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

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

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

`[虚拟]` void QIODevice:: close ()

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

另请参阅 setOpenMode () 和 OpenMode .

QString QIODevice:: errorString () const

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

另请参阅 setErrorString ().

bool QIODevice:: getChar ( char * c )

从设备读取 1 字符并把它存储在 c 。若 c is 0, the character is discarded. Returns true on success; otherwise returns false.

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

bool QIODevice:: isOpen () const

Returns true if the device is open; otherwise returns false. A device is open if it can be read from and/or written to. By default, this function returns false if openMode () 返回 NotOpen .

另请参阅 openMode () 和 OpenMode .

bool QIODevice:: isReadable () const

Returns true if data can be read from the device; otherwise returns false. Use bytesAvailable () 以确定可以读取多少字节。

这是方便校验函数若 OpenMode 的设备包含 ReadOnly 标志。

另请参阅 openMode () 和 OpenMode .

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

Returns true if this device is sequential; otherwise returns false.

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

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

The QIODevice 实现返回 false。

另请参阅 bytesAvailable ().

bool QIODevice:: isTextModeEnabled () const

返回 true 若 Text flag is enabled; otherwise returns false.

另请参阅 setTextModeEnabled ().

bool QIODevice:: isWritable () const

Returns true if data can be written to the device; otherwise returns false.

这是方便校验函数若 OpenMode 的设备包含 WriteOnly 标志。

另请参阅 openMode () 和 OpenMode .

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

打开设备并设置其 OpenMode to mode . Returns true if successful; otherwise returns false. This function should be called from any reimplementations of open() or other functions that open the device.

另请参阅 openMode () 和 OpenMode .

OpenMode QIODevice:: openMode () const

返回设备被打开的模式；即： ReadOnly or 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;
}

该函数在 Qt 4.1 引入。

另请参阅 read ().

QByteArray QIODevice:: peek ( qint64 maxSize )

这是重载函数。

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

范例：

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

This function has no way of reporting errors; returning an empty QByteArray() can mean either that no data was currently available for peeking, or that an error occurred.

该函数在 Qt 4.1 引入。

另请参阅 read ().

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

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

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

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

bool QIODevice:: putChar ( char c )

写入字符 c to the device. Returns true on success; otherwise returns 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 .

This function has no way of reporting errors; returning an empty QByteArray() can mean either that no data was currently available for reading, or that an error occurred.

QByteArray QIODevice:: readAll ()

这是重载函数。

Reads all available data from the device, and returns it as a QByteArray .

This function has no way of reporting errors; returning an empty QByteArray() can mean either that no data was currently available for reading, or that an error occurred.

`[signal]` void QIODevice:: readChannelFinished ()

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

该函数在 Qt 4.4 引入。

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

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

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

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

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

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

另请参阅 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 替换换行符。

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

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

QByteArray QIODevice:: readLine ( qint64 maxSize = 0)

这是重载函数。

从设备读取行，但不超过 maxSize characters, and returns the result as a QByteArray .

This function has no way of reporting errors; returning an empty QByteArray() can mean either that no data was currently available for reading, or that an error occurred.

`[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 ()

This signal is emitted once every time new data is available for reading from the device. It will only be emitted again once new data is available, such as when a new payload of network data has arrived on your network socket, or when a new block of data has been appended to your device.

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

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

另请参阅 bytesWritten ().

`[虚拟]` bool QIODevice:: reset ()

Seeks to the start of input for random-access devices. Returns true on success; otherwise returns false (for example, if the device is not open).

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

另请参阅 seek ().

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

对于随机访问设备，此函数将当前位置设为 pos ，返回 true 当成功时，或 false 若出现错误。对于顺序设备，默认行为是什么都不做并返回 false。

当子类化 QIODevice ，必须在函数开始时调用 QIODevice::seek() 以确保完整性采用 QIODevice 's built-in buffer. The base implementation always returns true.

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

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

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

另请参阅 errorString ().

`[protected]` void QIODevice:: setOpenMode ( 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 ().

void QIODevice:: ungetChar ( char c )

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

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

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

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

Returns true if a payload of data was written to the device; otherwise returns false (i.e. if the operation timed out, or if an error occurred).

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

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

Reimplement this function to provide a blocking API for a custom device. The default implementation does nothing, and returns false.

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

另请参阅 waitForReadyRead ().

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

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

Returns true if new data is available for reading; otherwise returns false (if the operation timed out or if an error occurred).

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

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

Reimplement this function to provide a blocking API for a custom device. The default implementation does nothing, and returns 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));
...

该函数在 Qt 4.5 引入。

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

qint64 QIODevice:: write (const QByteArray & byteArray )

这是重载函数。

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

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

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

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

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

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

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

内容

QIODevice 类

公共类型

公共函数

信号

保护函数

额外继承成员

详细描述

成员类型文档编制

enum QIODevice:: OpenModeFlag flags QIODevice:: OpenMode

成员函数文档编制

QIODevice:: QIODevice ()

QIODevice:: QIODevice ( QObject * parent )

[虚拟] QIODevice:: ~QIODevice ()

[signal] void QIODevice:: aboutToClose ()

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

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

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

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

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

[虚拟] void QIODevice:: close ()

QString QIODevice:: errorString () const

bool QIODevice:: getChar ( char * c )

bool QIODevice:: isOpen () const

bool QIODevice:: isReadable () const

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

bool QIODevice:: isTextModeEnabled () const

bool QIODevice:: isWritable () const

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

OpenMode QIODevice:: openMode () const

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

QByteArray QIODevice:: peek ( qint64 maxSize )

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

bool QIODevice:: putChar ( char c )

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

QByteArray QIODevice:: read ( qint64 maxSize )

QByteArray QIODevice:: readAll ()

[signal] void QIODevice:: readChannelFinished ()

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

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

QByteArray QIODevice:: readLine ( qint64 maxSize = 0)

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

[signal] void QIODevice:: readyRead ()

[虚拟] bool QIODevice:: reset ()

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

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

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

void QIODevice:: setTextModeEnabled ( bool enabled )

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

void QIODevice:: ungetChar ( char c )

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

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

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

qint64 QIODevice:: write (const char * data )

qint64 QIODevice:: write (const QByteArray & byteArray )

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

enum QIODevice:: OpenModeFlag
flags QIODevice:: OpenMode

`[虚拟]` QIODevice:: ~QIODevice ()

`[signal]` void QIODevice:: aboutToClose ()

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

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

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

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

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

`[虚拟]` void QIODevice:: close ()

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

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

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

`[signal]` void QIODevice:: readChannelFinished ()

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

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

`[signal]` void QIODevice:: readyRead ()

`[虚拟]` bool QIODevice:: reset ()

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

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

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

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

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

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

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