Класс 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::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() и 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() и 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)

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

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

QIODeviceBase::OpenMode QIODevice::openMode() const

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

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

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

Считывает не более maxSize байтов из устройства в data без побочных эффектов (т.е., если после peek() вызовёте read(), получите те же данные). Возвращает количество считанных байтов. В случае ошибки, например, при попытке peek из устройства, открытого в режиме WriteOnly, функция возвращает -1.

Возвращает 0, когда больше данных для чтения недоступно.

Пример:

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

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

QByteArray QIODevice::peek(qint64 maxSize)

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

Просматривает не более maxSize байтов из устройства, возвращая просмотренные данные как QByteArray.

Пример:

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

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

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

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

Функция может быть вызвана с размером 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().

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