Класс 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(OpenMode mode)

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

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

OpenMode QIODevice::openMode() const

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

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

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

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

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.

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

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