Класс QIODevice

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

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

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

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

Сигналы

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

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

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

Перед доступом к устройству необходимо вызвать open() для установки правильного режима открытия (например, 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(), которая приостанавливает выполнение в вызывающей нити до тех пор, пока процесс не будет запущен.

Вызов этих функций из основной нити 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, вы можете предоставить тот же интерфейс для собственных устройств ввода-вывода. Подклассам 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::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, since 5.7] void QIODevice::channelBytesWritten(int channel, qint64 bytes)

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

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

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

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

[signal, since 5.7] void QIODevice::channelReadyRead(int channel)

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

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

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

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

[signal] void QIODevice::readChannelFinished()

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

См. также 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() и QIODeviceBase::OpenMode.

[since 5.7] void QIODevice::commitTransaction()

Завершает транзакцию чтения.

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

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

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

[since 5.7] int QIODevice::currentReadChannel() const

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

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

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

[since 5.7] 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() и QIODeviceBase::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().

[since 5.7] bool QIODevice::isTransactionStarted() const

Возвращает true если транзакция выполняется на устройстве, в противном случае false.

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

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

bool QIODevice::isWritable() const

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

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

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

[virtual] 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(), вы получите те же данные). Возвращает количество прочитанных байтов. Если произошла ошибка, например, при попытке 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().

[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 может означать либо то, что данные для чтения в данный момент недоступны, либо то, что произошла ошибка.

[since 5.7] 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'.

Обратите внимание, что в последовательных устройствах данные могут быть недоступны немедленно, что может привести к возврату части строки. Вызывая функцию 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 считается ошибкой.

[virtual] bool QIODevice::reset()

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

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

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

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

[since 5.7] void QIODevice::setCurrentReadChannel(int channel)

Устанавливает текущий канал чтения QIODevice на заданный channel. Текущий входной канал используется функциями read(), readAll(), readLine() и getChar(). Он также определяет, какой канал вызывает QIODevice для излучения сигнала readyRead().

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

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

[since 5.7] 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(QIODeviceBase::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().

[since 5.10] qint64 QIODevice::skip(qint64 maxSize)

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

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

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

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

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

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

См. также 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().

[since 5.7] void QIODevice::startTransaction()

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

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

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

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

void QIODevice::ungetChar(char c)

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

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

[virtual] bool QIODevice::waitForBytesWritten(int msecs)

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

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

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

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

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

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

[virtual] 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 в случае ошибки. Это эквивалентно

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

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

qint64 QIODevice::write(const QByteArray &data)

Это перегруженный метод.

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

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

[since 5.7] int QIODevice::writeChannelCount() const

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

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

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

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

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

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

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

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