Класс QIODevice

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

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

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

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

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

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

Сигналы

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

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

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

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

• 1 свойство, унаследованное от QObject
• 1 публичный слот, унаследованный от QObject
• 11 статических публичных членов, унаследованных от 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() для определения количества байтов, которые в данный момент доступны для чтения. При программировании с асинхронными устройствами, такими как QTcpSocket, часто удобно использовать bytesAvailable() совместно с сигналом readyRead(), так как фрагменты данных могут поступать в произвольные моменты времени. 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(), вы получите те же данные). Возвращает количество прочитанных байтов. Если произошла ошибка, например, при попытке просмотреть устройство, открытое в режиме 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 ранее не был прочитан с устройства, поведение не определено.

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

bool QIODevice::waitForBytesWritten(int msecs)

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

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

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

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

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

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

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

bool QIODevice::waitForReadyRead(int msecs)

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

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

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

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

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

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

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

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

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

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

qint64 QIODevice::write(const char *data)

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

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

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

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

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

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

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

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