Класс QIODevice

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

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

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

Типы

Общедоступные функции

• 31 общедоступная функция унаследованная от 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.

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

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

[virtual] void QIODevice::close()

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

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

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::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 без побочных эффектов (т. е., если вы вызовете 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 может означать, что данные для чтения в данный момент отсутствуют или произошла ошибка.

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

[virtual] bool QIODevice::seek(qint64 pos)

Для устройств с произвольным доступом эта функция устанавливает текущую позицию в pos, возвращая true при успехе или false, если произошла ошибка. Для последовательных устройств стандартное поведение — выдать предупреждение и вернуть false.

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

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

[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::ungetChar(char c)

Возвращает символ c в устройство и уменьшает текущую позицию, если позиция не равна 0. Эта функция обычно используется для «отмены» операции getChar(), например, при записи рекурсивного парсера.

Если c ранее не был прочитан из устройства, поведение неопределено.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

qint64 QIODevice::write(const char *data)

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

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

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

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

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

qint64 QIODevice::write(const QByteArray &byteArray)

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

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

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

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

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

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

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

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