Класс 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.

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

перечисление QIODevice::OpenModeFlag 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 равен 0, символ отбрасывается. Возвращает true при успехе; в противном случае возвращает false.

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

bool QIODevice::isOpen() const

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

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

bool QIODevice::isReadable() const

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

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

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

[virtual] bool QIODevice::isSequential() const

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

Последовательные устройства, в отличие от устройств с произвольным доступом, не имеют понятия о начале, конце, размере или текущей позиции, и не поддерживают поиск. Вы можете читать данные из устройства только тогда, когда оно сообщает, что данные доступны. Наиболее распространённым примером последовательного устройства является сетевой сокет. В Unix специальные файлы, такие как /dev/zero и fifo-каналы, являются последовательными.

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

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

bool QIODevice::isTextModeEnabled() const

Возвращает true если флаг Text включен; в противном случае возвращает false.

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

bool QIODevice::isTransactionStarted() const

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

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

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

bool QIODevice::isWritable() const

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

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

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

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

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

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

QIODevice::OpenMode QIODevice::openMode() const

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

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

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

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

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

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

[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));
...

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

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

qint64 QIODevice::write(const QByteArray &byteArray)

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

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

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

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