Класс 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(), чтобы определить количество байтов, которые в настоящее время доступны для чтения. Часто bytesAvailable() используется вместе со сигналом readyRead() при программировании с асинхронными устройствами, такими как QTcpSocket, где фрагменты данных могут прибывать в произвольные моменты времени. 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.

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

enum QIODevice::OpenModeFlagflags QIODevice::OpenMode

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

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

Тип OpenMode является псевдонимом для 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 равно nullptr, символ отбрасывается. Возвращает 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, если ничего не было прочитано.

Завершающий байт '\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 символов, и возвращает результат как массив байтов.

Этот метод не может сообщать об ошибках; возврат пустого 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.

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.

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

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

bool QIODevice::waitForReadyRead(int msecs)

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

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

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

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

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

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

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

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

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

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

qint64 QIODevice::write(const char *data)

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

Записывает данные из нуль-терминированной строки символов 8-битного представления в устройство. Возвращает количество байтов, которые были фактически записаны, или -1, если произошла ошибка. Это эквивалентно

Эта функция была введена в 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().