Класс QIODevice

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

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

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

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

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

• 32 открытых функции унаследованные от QObject

Сигналы

• 2 сигнала унаследованные от QObject

Статические открытые члены

• 10 статических публичных членов, унаследованных от QObject

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

• 9 защищенных функций, унаследованных от QObject

Дополнительные унаследованные члены

• 1 свойство, унаследованное от QObject
• 1 публичный слот, унаследованный от QObject

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

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

Вызов этих функций из основной, 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::OpenModeFlag QIODevice::OpenMode

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

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

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

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

QIODevice::QIODevice()

Создаёт объект QIODevice.

QIODevice::QIODevice(QObject *parent)

Создаёт объект QIODevice с заданным parent.

[virtual] QIODevice::~QIODevice()

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

[signal] void QIODevice::aboutToClose()

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

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

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

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

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

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

[virtual] bool QIODevice::canReadLine() const

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

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

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

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

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

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

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

[virtual] void QIODevice::close()

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

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

void QIODevice::commitTransaction()

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

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

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

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

int QIODevice::currentReadChannel() const

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

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

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

int QIODevice::currentWriteChannel() const

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

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

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

QString QIODevice::errorString() const

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

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

bool QIODevice::getChar(char *c)

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

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

bool QIODevice::isOpen() const

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

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

bool QIODevice::isReadable() const

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

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

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

[virtual] bool QIODevice::isSequential() const

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

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

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

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

bool QIODevice::isTextModeEnabled() const

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

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

bool QIODevice::isTransactionStarted() const

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

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

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

bool QIODevice::isWritable() const

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

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

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

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

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

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

QIODevice::OpenMode QIODevice::openMode() const

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

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

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

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

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

Пример:

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

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

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

QByteArray QIODevice::peek(qint64 maxSize)

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

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

Пример:

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

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

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

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

[virtual] qint64 QIODevice::pos() const

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

Текущая позиция чтения/записи устройства поддерживается внутри QIODevice, поэтому переопределение этой функции не требуется. При наследовании от QIODevice используйте QIODevice::seek(), чтобы уведомить QIODevice об изменениях позиции устройства.

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

bool QIODevice::putChar(char c)

Записывает символ c в устройство. Возвращает true при успехе; в противном случае возвращает false.

См. также write(), getChar() и ungetChar().

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

Читает не более maxSize байтов из устройства в data и возвращает количество прочитанных байтов. Если произошла ошибка, например, при попытке чтения из устройства, открытого в режиме WriteOnly, эта функция возвращает -1.

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

См. также readData(), readLine() и write().

QByteArray QIODevice::read(qint64 maxSize)

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

Читает не более maxSize байтов из устройства и возвращает прочитанные данные в виде QByteArray.

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

QByteArray QIODevice::readAll()

Читает все оставшиеся данные из устройства и возвращает их в виде массива байтов.

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

int QIODevice::readChannelCount() const

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

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

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

[signal] void QIODevice::readChannelFinished()

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

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

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

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

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

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

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

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

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

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

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

Эта функция читает строку ASCII-символов из устройства, до максимального количества maxSize - 1 байт, сохраняет символы в data и возвращает количество прочитанных байтов. Если строка не могла быть прочитана, но ошибка не произошла, эта функция возвращает 0. Если произошла ошибка, эта функция возвращает длину того, что можно было прочитать, или -1, если ничего не было прочитано.

Завершающий байт '\0' всегда добавляется к data, поэтому maxSize должно быть больше 1.

Данные читаются до тех пор, пока не будет выполнено одно из следующих условий:

• Считан первый символ '\n'.
• Считано maxSize - 1 байт.
• Обнаружен конец данных устройства.

Например, следующий код читает строку символов из файла:

QFile file("box.txt");
if (file.open(QFile::ReadOnly)) {
    char buf[1024];
    qint64 lineLength = file.readLine(buf, sizeof(buf));
    if (lineLength != -1) {
        // the line is available in buf
    }
}

Символ новой строки ('\n') включён в буфер. Если символ новой строки не встретился до того, как было прочитано maxSize - 1 байт, символ новой строки не будет вставлен в буфер. В Windows символы новой строки заменяются на '\n'.

Эта функция вызывает readLineData(), которая реализована с помощью многократных вызовов getChar(). Вы можете предоставить более эффективную реализацию, переопределив readLineData() в вашем собственном подклассе.

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

QByteArray QIODevice::readLine(qint64 maxSize = 0)

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

Читает строку из устройства, но не более maxSize символов, и возвращает результат в виде массива байтов.

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

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

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

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

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

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

[signal] void QIODevice::readyRead()

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

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

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

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

[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 (т.е. если операция закончилась по истечении времени или произошла ошибка).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

qint64 QIODevice::write(const char *data)

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

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

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

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

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

qint64 QIODevice::write(const QByteArray &byteArray)

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

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

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

int QIODevice::writeChannelCount() const

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

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

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

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

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

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

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

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