Класс QIODevice

Класс QIODevice является базовым интерфейсным классом всех устройств ввода-вывода в Qt. Подробнее...

• Список всех членов, включая унаследованные

Примечание: Все функции в этом классе являются перевходовыми.

Открытые типы

Открытые функции

Сигналы

Защищённые функции

Подробное описание

QIODevice предоставляет как общее реализацию, так и абстрактный интерфейс для устройств, поддерживающих чтение и запись блоков данных, таких как QFile, QBuffer и QTcpSocket. QIODevice является абстрактным и не может быть инстанцирован, но часто используется интерфейс, который он определяет, для предоставления функций ввода-вывода, независимых от устройства. Например, XML-классы Qt работают с указателем QIODevice, что позволяет использовать их с различными устройствами (например, файлами и буферами).

Перед доступом к устройству необходимо вызвать open(), чтобы установить соответствующий режим OpenMode (например, ReadOnly или ReadWrite). Затем вы можете записывать в устройство с помощью write() или putChar(), и читать, вызывая read(), readLine() или readAll(). После завершения работы с устройством вызовите close().

QIODevice различает два типа устройств: устройства с произвольным доступом и последовательные устройства.

• Устройства с произвольным доступом поддерживают перемещение к произвольным позициям с помощью seek(). Текущая позиция в файле доступна с помощью вызова pos(). QFile и QBuffer являются примерами устройств с произвольным доступом.
• Последовательные устройства не поддерживают перемещение к произвольным позициям. Данные должны читаться в одном проходе. Функции pos() и size() не работают для последовательных устройств. QTcpSocket и QProcess являются примерами последовательных устройств.

Вы можете использовать isSequential(), чтобы определить тип устройства.

QIODevice излучает readyRead(), когда новые данные доступны для чтения; например, если новые данные прибыли по сети или если к файлу, из которого вы читаете, добавлены дополнительные данные. Вы можете вызвать bytesAvailable(), чтобы определить количество байтов, которые в настоящее время доступны для чтения. При программировании с асинхронными устройствами, такими как QTcpSocket, где фрагменты данных могут прибывать в произвольные моменты времени, часто используется bytesAvailable() вместе с сигналом readyRead(). QIODevice излучает сигнал bytesWritten() каждый раз, когда пакет данных был записан в устройство. Используйте bytesToWrite(), чтобы определить текущее количество данных, ожидающих записи.

Некоторые подклассы QIODevice, такие как QTcpSocket и QProcess, являются асинхронными. Это означает, что функции ввода-вывода, такие как write() или read(), всегда возвращают значение немедленно, в то время как общение с самим устройством может происходить, когда управление возвращается к циклу событий. QIODevice предоставляет функции, которые позволяют вам выполнить эти операции немедленно, блокируя вызывающую нить и не входя в цикл событий. Это позволяет подклассам QIODevice использоваться без цикла событий или в отдельной нити:

• waitForReadyRead() - эта функция приостанавливает работу в вызывающей нити, пока новые данные не станут доступными для чтения.
• waitForBytesWritten() - эта функция приостанавливает работу в вызывающей нити, пока один пакет данных не будет записан в устройство.
• waitFor....() - подклассы QIODevice реализуют блокирующие функции для операций, специфичных для устройства. Например, QProcess имеет функцию waitForStarted(), которая приостанавливает выполнение в вызывающей нити, пока процесс не начнётся.

Вызов этих функций из главной, графической нити, может привести к зависанию вашего пользовательского интерфейса. Пример:

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, вы можете предоставить тот же интерфейс для собственных устройств ввода-вывода. Подклассы QIODevice должны реализовать только защищённые функции readData() и writeData(). QIODevice использует эти функции для реализации всех удобных функций, таких как getChar(), readLine() и write(). QIODevice также обрабатывает контроль доступа, поэтому вы можете безопасно предполагать, что устройство открыто в режиме записи, если вызывается writeData().

Некоторые подклассы, такие как QFile и QTcpSocket, реализованы с использованием буфера памяти для промежуточного хранения данных. Это уменьшает количество необходимых вызовов доступа к устройству, которые часто очень медленные. Буферизация ускоряет функции, такие как getChar() и putChar(), так как они могут работать с буфером памяти, а не непосредственно с устройством. Однако некоторые операции ввода-вывода работают неэффективно с буфером. Например, если несколько пользователей открывают одно и то же устройство и читают его символ за символом, они могут прочитать одни и те же данные, когда предполагали прочитать разные фрагменты каждый. По этой причине QIODevice позволяет обойти буферизацию, передав флаг Unbuffered в open(). При подклассировании QIODevice, помните об обходе любого буфера, который вы используете, когда устройство открыто в режиме Unbuffered.

Обычно входящий поток данных из асинхронного устройства фрагментирован, и фрагменты данных могут прибывать в произвольные моменты времени. Для обработки неполных чтений структур данных используйте механизм транзакций, реализованный в QIODevice. Дополнительную информацию см. в startTransaction() и связанных функциях.

Некоторые последовательные устройства поддерживают общение через несколько каналов. Эти каналы представляют собой отдельные потоки данных, которые обладают свойством независимой последовательной доставки. После открытия устройства вы можете определить количество каналов, вызвав функции readChannelCount() и writeChannelCount(). Для переключения между каналами вызовите setCurrentReadChannel() и setCurrentWriteChannel() соответственно. QIODevice также предоставляет дополнительные сигналы для обработки асинхронного общения на уровне каждого канала.

См. также QBuffer, QFile и QTcpSocket.

Документация по типам членов

Перечисление QIODevice::OpenModeFlag флаги QIODevice::OpenMode

Это перечисление используется с open() для описания режима открытия устройства. Оно также возвращается функцией openMode().

Некоторые флаги, такие как Unbuffered и Truncate, бессмысленны при использовании с некоторыми подклассами. Некоторые из этих ограничений подразумеваются типом устройства, представленного подклассом. В других случаях ограничение может быть обусловлено реализацией или быть наложено базовой платформой; например, QTcpSocket не поддерживает режим Unbuffered, а ограничения в базовом API не позволяют QFile поддерживать Unbuffered в Windows.

Тип OpenMode является typedef для QFlags<OpenModeFlag>. Он хранит логическое ИЛИ сочетание значений OpenModeFlag.

Документация функций-членов

QIODevice::QIODevice(QObject *parent)

Конструирует объект QIODevice с заданным parent.

QIODevice::QIODevice()

Конструирует объект QIODevice.

[signal] void QIODevice::aboutToClose()

Этот сигнал подаётся, когда устройство собирается закрыться. Подключите этот сигнал, если у вас есть операции, которые необходимо выполнить перед закрытием устройства (например, если у вас есть данные в отдельном буфере, которые нужно записать в устройство).

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

Этот сигнал подаётся каждый раз, когда пакет данных записывается в текущий канал записи устройства. Аргумент bytes устанавливается в количество байтов, записанных в этом пакете.

bytesWritten() не подаётся рекурсивно; если вы повторно входите в цикл обработки событий или вызываете waitForBytesWritten() внутри слота, подключенного к сигналу bytesWritten(), сигнал не будет повторно подан (хотя waitForBytesWritten() может всё ещё вернуть true).

См. также readyRead().

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

Этот сигнал подаётся каждый раз, когда пакет данных записывается в устройство. Аргумент bytes устанавливается в количество байтов, записанных в этом пакете, а channel — в индекс канала, в который они были записаны. В отличие от bytesWritten(), он подаётся независимо от текущего канала записи.

channelBytesWritten() может подаваться рекурсивно — даже для одного и того же канала.

Эта функция была добавлена в Qt 5.7.

См. также bytesWritten() и channelReadyRead().

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

Этот сигнал подаётся, когда новые данные доступны для чтения из устройства. Аргумент channel устанавливается в индекс канала чтения, на котором появились данные. В отличие от readyRead(), он подаётся независимо от текущего канала чтения.

channelReadyRead() может подаваться рекурсивно — даже для одного и того же канала.

Эта функция была добавлена в Qt 5.7.

См. также readyRead() и channelBytesWritten().

[signal] void QIODevice::readChannelFinished()

Этот сигнал подаётся, когда входной (чтение) поток закрыт в этом устройстве. Он подаётся как только закрытие обнаружено, что означает, что данные для чтения с помощью read() могут ещё быть доступны.

Эта функция была добавлена в Qt 4.4.

См. также atEnd() и read().

[signal] void QIODevice::readyRead()

Этот сигнал подаётся каждый раз, когда новые данные доступны для чтения из текущего канала чтения устройства. Он будет подан снова только после появления новых данных, например, после получения нового пакета сетевых данных в вашем сокете или добавления нового блока данных в ваше устройство.

readyRead() не подаётся рекурсивно; если вы повторно входите в цикл обработки событий или вызываете waitForReadyRead() внутри слота, подключенного к сигналу readyRead(), сигнал не будет повторно подан (хотя waitForReadyRead() может всё ещё вернуть true).

Примечание для разработчиков, реализующих классы, производные от QIODevice: вы всегда должны подавать readyRead() при поступлении новых данных (не подавайте его только потому, что в ваших буферах ещё есть данные для чтения). Не подавайте readyRead() в других условиях.

См. также bytesWritten().

[virtual] QIODevice::~QIODevice()

Деструктор является виртуальным, и QIODevice — абстрактный базовый класс. Этот деструктор не вызывает close(), но деструктор подкласса может. Если вы сомневаетесь, вызовите close() перед удалением QIODevice.

[virtual] bool QIODevice::atEnd() const

Возвращает true, если текущая позиция чтения и записи находится в конце устройства (т.е. больше нет данных, доступных для чтения на устройстве); в противном случае возвращает false.

Для некоторых устройств atEnd() может возвращать true, даже если есть больше данных для чтения. Этот особый случай относится только к устройствам, которые генерируют данные в прямой ответ на вызов read() (например, файлы /dev или /proc на Unix и macOS, или консольный ввод/stdin на всех платформах).

См. также bytesAvailable(), read() и isSequential().

[virtual] qint64 QIODevice::bytesAvailable() const

Возвращает количество байтов, доступных для чтения. Эта функция обычно используется с последовательными устройствами для определения количества байтов, которые необходимо выделить в буфере перед чтением.

Подклассы, переопределяющие эту функцию, должны вызывать базовую реализацию, чтобы включить размер буфера QIODevice. Пример:

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

См. также bytesToWrite(), readyRead() и isSequential().

[virtual] qint64 QIODevice::bytesToWrite() const

Для буферизованных устройств эта функция возвращает количество байтов, ожидающих записи. Для устройств без буфера эта функция возвращает 0.

Подклассы, переопределяющие эту функцию, должны вызывать базовую реализацию, чтобы включить размер буфера QIODevice.

См. также bytesAvailable(), bytesWritten() и isSequential().

[virtual] bool QIODevice::canReadLine() const

Возвращает true, если из устройства можно прочитать целую строку данных; в противном случае возвращает false.

Обратите внимание, что для устройств без буферизации, которые не могут определить, что можно прочитать, всегда возвращается false.

Эта функция часто вызывается совместно со сигналом readyRead().

Подклассы, которые переопределяют эту функцию, должны вызвать базовую реализацию, чтобы включить содержимое буфера QIODevice. Пример:

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

См. также readyRead() и readLine().

[virtual] void QIODevice::close()

Сначала испускает aboutToClose(), затем закрывает устройство и устанавливает его OpenMode в NotOpen. Строка ошибки также сбрасывается.

См. также setOpenMode() и OpenMode.

void QIODevice::commitTransaction()

Завершает операцию чтения.

Для последовательных устройств все данные, записанные во внутренний буфер во время транзакции, будут удалены.

Эта функция была добавлена в Qt 5.7.

См. также startTransaction() и rollbackTransaction().

int QIODevice::currentReadChannel() const

Возвращает индекс текущего канала чтения.

Эта функция была добавлена в Qt 5.7.

См. также setCurrentReadChannel(), readChannelCount() и QProcess.

int QIODevice::currentWriteChannel() const

Возвращает индекс текущего канала записи.

Эта функция была добавлена в Qt 5.7.

См. также setCurrentWriteChannel() и writeChannelCount().

QString QIODevice::errorString() const

Возвращает удобочитаемое описание последней ошибки устройства.

См. также setErrorString().

bool QIODevice::getChar(char *c)

Читает один символ из устройства и сохраняет его в c. Если c равен 0, символ отбрасывается. Возвращает true при успехе; в противном случае возвращает false.

См. также read(), putChar() и ungetChar().

bool QIODevice::isOpen() const

Возвращает true, если устройство открыто; в противном случае возвращает false. Устройство открыто, если к нему можно читать и/или писать. По умолчанию эта функция возвращает false, если openMode() возвращает NotOpen.

См. также openMode() и OpenMode.

bool QIODevice::isReadable() const

Возвращает true, если из устройства можно читать данные; в противном случае возвращает false. Используйте bytesAvailable(), чтобы определить, сколько байтов можно прочитать.

Это функция-удобство, которая проверяет, содержит ли OpenMode устройства флаг ReadOnly.

См. также openMode() и OpenMode.

[virtual] 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.

Эта функция была добавлена в Qt 5.7.

См. также startTransaction().

bool QIODevice::isWritable() const

Возвращает true, если данные можно записать в устройство; в противном случае возвращает false.

Это функция-удобство, которая проверяет, содержит ли OpenMode устройства флаг WriteOnly.

См. также openMode() и OpenMode.

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

Открывает устройство и устанавливает его OpenMode в mode. Возвращает true при успехе; в противном случае возвращает false. Эта функция должна вызываться из любых переопределений open() или других функций, которые открывают устройство.

См. также openMode() и OpenMode.

QIODevice::OpenMode QIODevice::openMode() const

Возвращает режим, в котором было открыто устройство; т.е. ReadOnly или WriteOnly.

См. также setOpenMode() и OpenMode.

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

Читает не более maxSize байтов из устройства в data без побочных эффектов (т.е., если вы вызовите read() после peek(), вы получите те же данные). Возвращает количество прочитанных байтов. Если возникает ошибка, например, при попытке 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";
}

Эта функция не может сообщить об ошибках; возврат пустого QByteArray может означать либо то, что данные для предварительного просмотра в данный момент недоступны, либо то, что произошла ошибка.

Эта функция была добавлена в Qt 4.1.

См. также read().

[virtual] 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.

Этот метод был добавлен в Qt 5.7.

См. также writeChannelCount() и QProcess.

[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, если ничего не было прочитано.

В data всегда добавляется завершающий байт '\0', поэтому 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 символов, и возвращает результат в виде массива байтов.

Этот метод не имеет способов сообщить об ошибках; возврат пустого QByteArray может означать либо отсутствие доступных данных для чтения, либо возникновение ошибки.

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

Считывает до maxSize символов в data и возвращает количество прочитанных символов.

Этот метод вызывается методом readLine() и предоставляет его базовую реализацию, используя getChar(). Буферизованные устройства могут повысить производительность readLine() путём переопределения этого метода.

readLine() добавляет байт '\0' к data; readLineData() этого не делает.

Если вы переопределяете этот метод, следите за корректностью возвращаемого значения: оно должно возвращать количество прочитанных байтов в этой строке, включая завершающий символ новой строки, или 0, если в данный момент нет строки для чтения. В случае ошибки оно должно возвращать -1, только если не было прочитано ни одного байта. Чтение после EOF считается ошибкой.

[virtual] bool QIODevice::reset()

Перемещает указатель на начало входных данных для устройств с произвольным доступом. Возвращает true при успехе; в противном случае возвращает false (например, если устройство не открыто).

Обратите внимание, что при использовании QTextStream на QFile, вызов reset() для QFile не даст ожидаемого результата, поскольку QTextStream буферизует файл. Используйте функцию QTextStream::seek() вместо этого.

См. также seek().

void QIODevice::rollbackTransaction()

Отменяет транзакцию чтения.

Возвращает поток ввода к состоянию на момент вызова startTransaction(). Этот метод обычно используется для отмены транзакции, если было обнаружено неполное чтение до подтверждения транзакции.

Этот метод был добавлен в Qt 5.7.

См. также startTransaction() и commitTransaction().

[virtual] 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().

Этот метод был добавлен в Qt 5.7.

См. также currentReadChannel(), readChannelCount() и QProcess.

void QIODevice::setCurrentWriteChannel(int channel)

Устанавливает текущий канал записи QIODevice на заданный channel. Текущий выходной канал используется функциями write() и putChar(). Также он определяет, какой канал вызывает у QIODevice излучение сигнала bytesWritten().

Этот метод был добавлен в Qt 5.7.

См. также currentWriteChannel() и writeChannelCount().

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

Устанавливает удобочитаемое описание последней ошибки устройства на str.

См. также errorString().

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

Устанавливает OpenMode устройства на openMode. Вызовите этот метод для установки режима открытия, если флаги изменятся после открытия устройства.

См. также openMode() и OpenMode.

void QIODevice::setTextModeEnabled(bool enabled)

Если enabled равно true, эта функция устанавливает флаг Text на устройстве; в противном случае флаг Text удаляется. Эта функция полезна для классов, предоставляющих пользовательскую обработку конца строки на QIODevice.

Устройство ввода-вывода должно быть открыто перед вызовом этого метода.

См. также isTextModeEnabled(), open() и setOpenMode().

[virtual] qint64 QIODevice::size() const

Для открытых устройств с произвольным доступом эта функция возвращает размер устройства. Для открытых последовательных устройств возвращается bytesAvailable().

Если устройство закрыто, возвращаемый размер не отражает фактический размер устройства.

См. также isSequential() и pos().

qint64 QIODevice::skip(qint64 maxSize)

Пропускает до maxSize байт из устройства. Возвращает количество фактически пропущенных байт или -1 при ошибке.

Эта функция не ожидает и только отбрасывает данные, уже доступные для чтения.

Если устройство открыто в текстовом режиме, разделители конца строки переводятся в символы '\n' и считаются как один байт, аналогично поведению read() и peek().

Эта функция работает для всех устройств, включая последовательные, для которых нельзя выполнить seek(). Она оптимизирована для пропуска нежелательных данных после вызова peek().

Для устройств с произвольным доступом skip() можно использовать для перемещения вперед от текущей позиции. Отрицательные значения maxSize недопустимы.

Эта функция была добавлена в Qt 5.10.

См. также peek(), seek() и read().

void QIODevice::startTransaction()

Начинает новую транзакцию чтения на устройстве.

Определяет точку восстановления в последовательности операций чтения. Для последовательных устройств данные чтения будут дублированы внутри, чтобы позволить восстановление в случае неполных чтений. Для устройств с произвольным доступом эта функция сохраняет текущую позицию. Вызовите commitTransaction() или rollbackTransaction(), чтобы завершить транзакцию.

Примечание: Вложенность транзакций не поддерживается.

Эта функция была добавлена в Qt 5.7.

См. также commitTransaction() и rollbackTransaction().

void QIODevice::ungetChar(char c)

Возвращает символ c обратно на устройство и уменьшает текущую позицию, если позиция не равна 0. Эта функция обычно используется для «отмены» операции getChar(), например, при написании парсера с возвратом.

Если c ранее не считывался с устройства, поведение неопределено.

Примечание: Эта функция недоступна во время выполнения транзакции.

bool QIODevice::waitForBytesWritten(int msecs)

Для буферизованных устройств эта функция ожидает, пока буфер записанных данных будет отправлен на устройство и будет выпущен сигнал bytesWritten() или пока не пройдет msecs миллисекунд. Если msecs равно -1, эта функция не будет ограничена по времени. Для небуферизованных устройств она возвращает значение немедленно.

Возвращает true, если пакет данных был записан на устройство; в противном случае возвращает false (например, если операция истекла по времени или произошла ошибка).

Эта функция может работать без цикла событий. Она полезна при написании приложений без графического интерфейса пользователя и при выполнении операций ввода-вывода в потоке без графического интерфейса пользователя.

Если она вызывается из слота, подключенного к сигналу bytesWritten(), сигнал bytesWritten() не будет повторно выпущен.

Переопределите эту функцию, чтобы предоставить блокирующую API для пользовательского устройства. По умолчанию реализация ничего не делает и возвращает false.

Предупреждение: Вызов этой функции из основного (GUI) потока может привести к зависанию графического интерфейса пользователя.

См. также waitForReadyRead().

bool QIODevice::waitForReadyRead(int msecs)

Блокирует выполнение, пока новые данные не станут доступными для чтения и не будет выпущен сигнал readyRead(), или пока не пройдет msecs миллисекунд. Если msecs равно -1, эта функция не будет ограничена по времени.

Возвращает true, если новые данные доступны для чтения; в противном случае возвращает false (если операция истекла по времени или произошла ошибка).

Эта функция может работать без цикла событий. Она полезна при написании приложений без графического интерфейса пользователя и при выполнении операций ввода-вывода в потоке без графического интерфейса пользователя.

Если она вызывается из слота, подключенного к сигналу 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));
...

Эта функция была добавлена в Qt 4.5.

См. также read() и writeData().

qint64 QIODevice::write(const QByteArray &byteArray)

Это перегруженная функция.

Записывает содержимое byteArray на устройство. Возвращает количество фактически записанных байт или -1, если произошла ошибка.

См. также read() и writeData().

int QIODevice::writeChannelCount() const

Возвращает количество доступных каналов записи, если устройство открыто; в противном случае возвращает 0.

Эта функция была добавлена в Qt 5.7.

См. также readChannelCount().

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

Записывает до maxSize байт из data на устройство. Возвращает количество записанных байт или -1, если произошла ошибка.

Эта функция вызывается из QIODevice. Переопределите эту функцию при создании подкласса QIODevice.

При переопределении этой функции важно, чтобы функция записала все доступные данные, прежде чем вернуть значение. Это необходимо для работы QDataStream с классом. QDataStream предполагает, что вся информация была записана, и поэтому не будет пытаться повторно записать данные, если произошла проблема.

См. также read() и write().