QIODevice Class

Dokumentation der Mitgliedsfunktionen

QIODevice::QIODevice()

Erstellt ein QIODevice-Objekt.

[explicit] QIODevice::QIODevice(QObject *parent)

Erstellt ein QIODevice-Objekt mit dem angegebenen „ parent “.

[virtual noexcept] QIODevice::~QIODevice()

Der Destruktor ist virtuell, und ` QIODevice ` ist eine abstrakte Basisklasse. Dieser Destruktor ruft ` close()` nicht auf, der Destruktor der Unterklasse könnte dies jedoch tun. Im Zweifelsfall sollten Sie ` close()` aufrufen, bevor Sie ` QIODevice` löschen.

[signal] void QIODevice::aboutToClose()

Dieses Signal wird ausgegeben, wenn sich das Gerät kurz vor dem Schließen befindet. Schließen Sie dieses Signal an, wenn vor dem Schließen des Geräts noch Vorgänge ausgeführt werden müssen (z. B. wenn sich Daten in einem separaten Puffer befinden, die auf das Gerät geschrieben werden müssen).

[virtual] bool QIODevice::atEnd() const

Gibt „ true “ zurück, wenn sich die aktuelle Lese- und Schreibposition am Ende des Geräts befindet (d. h., es sind keine Daten mehr auf dem Gerät zum Lesen verfügbar); andernfalls wird „ false “ zurückgegeben.

Bei einigen Geräten kann `atEnd()` den Wert `true` zurückgeben, obwohl noch weitere Daten zum Lesen vorhanden sind. Dieser Sonderfall gilt nur für Geräte, die Daten als direkte Reaktion auf den Aufruf von ` read()` generieren (z. B. ` /dev `- oder ` /proc `-Dateien unter Unix und macOS oder die Konsoleneingabe/` stdin ` auf allen Plattformen).

Siehe auch bytesAvailable(), read() und isSequential().

[virtual] qint64 QIODevice::bytesAvailable() const

Gibt die Anzahl der Bytes zurück, die zum Lesen verfügbar sind. Diese Funktion wird häufig bei sequenziellen Geräten verwendet, um vor dem Lesen die Anzahl der Bytes zu ermitteln, die in einem Puffer zugewiesen werden sollen.

Unterklassen, die diese Funktion neu implementieren, müssen die Basisimplementierung aufrufen, um die Größe des Puffers von ` QIODevice` einzubeziehen. Beispiel:

qint64 CustomDevice::bytesAvailable() const
{
    return buffer.size() + QIODevice::bytesAvailable();
}

Siehe auch ` bytesToWrite()`, ` readyRead()` und ` isSequential()`.

[virtual] qint64 QIODevice::bytesToWrite() const

Bei gepufferten Geräten gibt diese Funktion die Anzahl der Bytes zurück, die auf das Schreiben warten. Bei Geräten ohne Puffer gibt diese Funktion 0 zurück.

Unterklassen, die diese Funktion neu implementieren, müssen die Basisimplementierung aufrufen, um die Größe des Puffers von ` QIODevice` einzubeziehen.

Siehe auch ` bytesAvailable()`, ` bytesWritten()` und ` isSequential()`.

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

Dieses Signal wird jedes Mal ausgelöst, wenn eine Datenlast in den aktuellen Schreibkanal des Geräts geschrieben wurde. Das Argument „ bytes “ wird auf die Anzahl der Bytes gesetzt, die in dieser Datenlast geschrieben wurden.

bytesWritten() wird nicht rekursiv ausgelöst; wenn Sie die Ereignisschleife erneut betreten oder waitForBytesWritten() innerhalb eines Slots aufrufen, der mit dem Signal bytesWritten() verbunden ist, wird das Signal nicht erneut ausgelöst (auch wenn waitForBytesWritten() möglicherweise weiterhin „true“ zurückgibt).

Siehe auch ` readyRead()`.

[virtual] bool QIODevice::canReadLine() const

Gibt „ true “ zurück, wenn eine vollständige Datenzeile vom Gerät gelesen werden kann; andernfalls wird „ false “ zurückgegeben.

Beachten Sie, dass ungepufferte Geräte, bei denen nicht festgestellt werden kann, was gelesen werden kann, immer „false“ zurückgeben.

Diese Funktion wird häufig in Verbindung mit dem Signal „ readyRead()“ aufgerufen.

Unterklassen, die diese Funktion neu implementieren, müssen die Basisimplementierung aufrufen, um den Inhalt des Puffers von ` QIODevice` einzubeziehen. Beispiel:

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

Siehe auch „ readyRead()“ und „ readLine()“.

[signal] void QIODevice::channelBytesWritten(int channel, qint64 bytes)

Dieses Signal wird jedes Mal ausgelöst, wenn eine Datenlast in das Gerät geschrieben wurde. Das Argument ` bytes ` wird auf die Anzahl der Bytes gesetzt, die in dieser Datenlast geschrieben wurden, während ` channel ` den Kanal angibt, in den sie geschrieben wurden. Im Gegensatz zu ` bytesWritten()` wird es unabhängig von ` current write channel` ausgelöst.

`channelBytesWritten()` kann rekursiv ausgelöst werden – sogar für denselben Kanal.

Siehe auch „ bytesWritten()“ und „ channelReadyRead()“.

[signal] void QIODevice::channelReadyRead(int channel)

Dieses Signal wird ausgelöst, wenn neue Daten vom Gerät zum Lesen bereitstehen. Das Argument „ channel “ wird auf den Index des Lesekanals gesetzt, auf dem die Daten eingegangen sind. Im Gegensatz zu „ readyRead()“ wird es unabhängig von „ current read channel “ ausgelöst.

`channelReadyRead()` kann rekursiv ausgelöst werden – sogar für denselben Kanal.

Siehe auch ` readyRead()` und ` channelBytesWritten()`.

[virtual] void QIODevice::close()

Zunächst wird aboutToClose() ausgegeben, anschließend wird das Gerät geschlossen und sein OpenMode auf „NotOpen“ gesetzt. Die Fehlerzeichenfolge wird ebenfalls zurückgesetzt.

Siehe auch „ setOpenMode()“ und „ QIODeviceBase::OpenMode “.

void QIODevice::commitTransaction()

Schließt eine Lesetransaktion ab.

Bei sequenziellen Geräten werden alle Daten, die während der Transaktion im internen Puffer aufgezeichnet wurden, verworfen.

Siehe auch „ startTransaction “ () und „ rollbackTransaction “ ().

int QIODevice::currentReadChannel() const

Gibt den Index des aktuell gelesenen Kanals zurück.

Siehe auch setCurrentReadChannel(), readChannelCount() und QProcess.

int QIODevice::currentWriteChannel() const

Gibt den Index des aktuellen Schreibkanals zurück.

Siehe auch setCurrentWriteChannel() und writeChannelCount().

QString QIODevice::errorString() const

Gibt eine für Menschen lesbare Beschreibung des zuletzt aufgetretenen Gerätefehlers zurück.

Siehe auch „ setErrorString()“.

bool QIODevice::getChar(char *c)

Liest ein Zeichen vom Gerät und speichert es in ` c`. Ist ` c ` gleich ` nullptr`, wird das Zeichen verworfen. Gibt bei Erfolg ` true ` zurück; andernfalls ` false`.

Siehe auch read(), putChar() und ungetChar().

bool QIODevice::isOpen() const

Gibt „ true “ zurück, wenn das Gerät geöffnet ist; andernfalls gibt sie „ false “ zurück. Ein Gerät ist geöffnet, wenn es gelesen und/oder beschrieben werden kann. Standardmäßig gibt diese Funktion „ false “ zurück, wenn „ openMode()“ „ NotOpen “ zurückgibt.

Siehe auch „ openMode()“ und „ QIODeviceBase::OpenMode “.

bool QIODevice::isReadable() const

Gibt „ true “ zurück, wenn Daten vom Gerät gelesen werden können; andernfalls wird „false“ zurückgegeben. Verwenden Sie „ bytesAvailable()“, um festzustellen, wie viele Bytes gelesen werden können.

Dies ist eine Hilfsfunktion, die prüft, ob der OpenMode des Geräts das ReadOnly-Flag enthält.

Siehe auch ` openMode()` und ` OpenMode`.

[virtual] bool QIODevice::isSequential() const

Gibt „ true “ zurück, wenn es sich um ein sequentielles Gerät handelt; andernfalls wird „false“ zurückgegeben.

Sequentielle Geräte kennen – im Gegensatz zu Geräten mit wahlfreiem Zugriff – keine Begriffe wie Anfang, Ende, Größe oder aktuelle Position und unterstützen keine Positionssprünge. Sie können nur dann Daten von dem Gerät lesen, wenn es meldet, dass Daten verfügbar sind. Das bekannteste Beispiel für ein sequentielles Gerät ist ein Netzwerk-Socket. Unter Unix sind spezielle Dateien wie /dev/zero und FIFO-Pipes sequentiell.

Normale Dateien hingegen unterstützen den wahlfreien Zugriff. Sie verfügen sowohl über eine Größe als auch über eine aktuelle Position und ermöglichen zudem das Vor- und Zurückspringen im Datenstrom. Normale Dateien sind nicht-sequenziell.

Siehe auch „ bytesAvailable()“.

bool QIODevice::isTextModeEnabled() const

Gibt „ true “ zurück, wenn das Flag „ Text “ aktiviert ist; andernfalls wird „ false “ zurückgegeben.

Siehe auch setTextModeEnabled().

bool QIODevice::isTransactionStarted() const

Gibt „ true “ zurück, wenn auf dem Gerät eine Transaktion läuft, andernfalls „ false “.

Siehe auch startTransaction().

bool QIODevice::isWritable() const

Gibt „ true “ zurück, wenn Daten auf das Gerät geschrieben werden können; andernfalls wird „false“ zurückgegeben.

Dies ist eine Hilfsfunktion, die prüft, ob der OpenMode des Geräts das WriteOnly-Flag enthält.

Siehe auch „ openMode()“ und „ OpenMode “.

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

Öffnet das Gerät und setzt dessen OpenMode auf „ mode “. Gibt bei Erfolg „ true “ zurück; andernfalls wird „ false “ zurückgegeben. Diese Funktion sollte aus allen Neuimplementierungen von open() oder anderen Funktionen aufgerufen werden, die das Gerät öffnen.

Siehe auch ` openMode()` und ` QIODeviceBase::OpenMode`.

QIODeviceBase::OpenMode QIODevice::openMode() const

Gibt den Modus zurück, in dem das Gerät geöffnet wurde, d. h. „ReadOnly“ oder „WriteOnly“.

Siehe auch „ setOpenMode()“ und „ OpenMode “.

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

Liest höchstens maxSize Bytes vom Gerät in data, ohne Nebenwirkungen (d. h., wenn Sie nach dem Aufruf von `peek()` die Funktion ` read()` aufrufen, erhalten Sie dieselben Daten). Gibt die Anzahl der gelesenen Bytes zurück. Tritt ein Fehler auf, beispielsweise beim Versuch, Daten von einem im WriteOnly-Modus geöffneten Gerät mit `peek()` auszulesen, gibt diese Funktion -1 zurück.

0 wird zurückgegeben, wenn keine Daten mehr zum Lesen verfügbar sind.

Beispiel:

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

Siehe auch „ read()“.

QByteArray QIODevice::peek(qint64 maxSize)

Liest maximal maxSize Bytes vom Gerät ein und gibt die eingelesenen Daten als ` QByteArray` zurück.

Beispiel:

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

Diese Funktion verfügt über keine Möglichkeit, Fehler zu melden; die Rückgabe eines leeren ` QByteArray ` kann entweder bedeuten, dass derzeit keine Daten zum Einlesen verfügbar waren, oder dass ein Fehler aufgetreten ist.

Siehe auch ` read()`.

[virtual] qint64 QIODevice::pos() const

Bei Geräten mit wahlfreiem Zugriff gibt diese Funktion die Position zurück, an der Daten geschrieben oder gelesen werden. Bei sequenziellen oder geschlossenen Geräten, bei denen es kein Konzept einer „aktuellen Position“ gibt, wird 0 zurückgegeben.

Die aktuelle Lese-/Schreibposition des Geräts wird intern von ` QIODevice` verwaltet, sodass eine Neuimplementierung dieser Funktion nicht erforderlich ist. Wenn Sie eine Unterklasse von ` QIODevice` erstellen, verwenden Sie ` QIODevice::seek()`, um ` QIODevice ` über Änderungen der Geräteposition zu informieren.

Siehe auch ` isSequential()` und ` seek()`.

bool QIODevice::putChar(char c)

Schreibt das Zeichen „ c “ auf das Gerät. Gibt bei Erfolg „ true “ zurück; andernfalls wird „ false “ zurückgegeben.

Siehe auch write(), getChar() und ungetChar().

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

Liest höchstens maxSize Bytes vom Gerät in data und gibt die Anzahl der gelesenen Bytes zurück. Tritt ein Fehler auf, beispielsweise beim Versuch, von einem im WriteOnly-Modus geöffneten Gerät zu lesen, gibt diese Funktion -1 zurück.

0 wird zurückgegeben, wenn keine Daten mehr zum Lesen verfügbar sind. Das Lesen über das Ende des Datenstroms hinaus gilt jedoch als Fehler, sodass diese Funktion in solchen Fällen -1 zurückgibt (d. h. beim Lesen von einem geschlossenen Socket oder nach dem Beenden eines Prozesses).

Siehe auch readData(), readLine() und write().

QByteArray QIODevice::read(qint64 maxSize)

Liest höchstens maxSize Bytes vom Gerät und gibt die gelesenen Daten als QByteArray zurück.

Diese Funktion verfügt über keine Möglichkeit, Fehler zu melden; die Rückgabe eines leeren ` QByteArray ` kann entweder bedeuten, dass derzeit keine Daten zum Lesen verfügbar waren, oder dass ein Fehler aufgetreten ist.

QByteArray QIODevice::readAll()

Liest alle verbleibenden Daten vom Gerät und gibt sie als Byte-Array zurück.

Diese Funktion verfügt über keine Möglichkeit, Fehler zu melden; die Rückgabe eines leeren „ QByteArray “ kann entweder bedeuten, dass derzeit keine Daten zum Lesen verfügbar waren, oder dass ein Fehler aufgetreten ist. Diese Funktion verfügt zudem über keine Möglichkeit, anzuzeigen, dass möglicherweise weitere Daten verfügbar waren, die jedoch nicht gelesen werden konnten.

int QIODevice::readChannelCount() const

Gibt die Anzahl der verfügbaren Lese-Kanäle zurück, sofern das Gerät geöffnet ist; andernfalls wird 0 zurückgegeben.

Siehe auch ` writeChannelCount()` und ` QProcess`.

[signal] void QIODevice::readChannelFinished()

Dieses Signal wird ausgelöst, wenn der Eingabe- (Lese-)Strom in diesem Gerät geschlossen wird. Es wird ausgelöst, sobald das Schließen erkannt wird, was bedeutet, dass möglicherweise noch Daten zum Lesen mit read() verfügbar sind.

Siehe auch atEnd() und read().

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

Liest bis zu maxSize Bytes vom Gerät in data und gibt die Anzahl der gelesenen Bytes zurück oder -1, falls ein Fehler aufgetreten ist.

Wenn keine Bytes zu lesen sind und niemals weitere Bytes verfügbar sein können (Beispiele hierfür sind ein geschlossener Socket, eine geschlossene Pipe oder ein beendeter Unterprozess), gibt diese Funktion -1 zurück.

Diese Funktion wird von ` QIODevice` aufgerufen. Implementieren Sie diese Funktion neu, wenn Sie eine Unterklasse von ` QIODevice` erstellen.

Bei der Neuimplementierung dieser Funktion ist es wichtig, dass die Funktion alle erforderlichen Daten liest, bevor sie zurückkehrt. Dies ist erforderlich, damit „ QDataStream “ die Klasse verarbeiten kann. „ QDataStream “ geht davon aus, dass alle angeforderten Informationen gelesen wurden, und versucht daher nicht erneut zu lesen, falls ein Problem aufgetreten ist.

Diese Funktion kann mit einem `maxSize`-Wert von 0 aufgerufen werden, was zur Durchführung von Operationen nach dem Einlesen genutzt werden kann.

Siehe auch read(), readLine() und writeData().

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

Diese Funktion liest eine Zeile mit ASCII-Zeichen vom Gerät – maximal maxSize - 1 Bytes –, speichert die Zeichen in data und gibt die Anzahl der gelesenen Bytes zurück. Wenn keine Zeile gelesen werden konnte, aber kein Fehler aufgetreten ist, gibt diese Funktion 0 zurück. Tritt ein Fehler auf, gibt diese Funktion die Länge des gelesenen Teils zurück oder -1, wenn nichts gelesen wurde.

An „ data “ wird immer ein abschließendes Byte „\0 “ angehängt, daher muss „ maxSize “ größer als 1 sein.

Daten werden so lange gelesen, bis eine der folgenden Bedingungen erfüllt ist:

• Das erste „\n “-Zeichen wird gelesen.
• maxSize - 1 Byte wurde gelesen.
• Das Ende der Gerätedaten wird erkannt.

Der folgende Code liest beispielsweise eine Zeichenzeile aus einer Datei:

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
    }
}

Das Zeilenumbruchzeichen („\n “) wird in den Puffer aufgenommen. Wird vor dem Lesen von „maxSize – 1“ Bytes kein Zeilenumbruch gefunden, wird kein Zeilenumbruch in den Puffer eingefügt.

Beachten Sie, dass bei sequenziellen Geräten die Daten möglicherweise nicht sofort verfügbar sind, was dazu führen kann, dass nur eine unvollständige Zeile zurückgegeben wird. Durch den Aufruf der Funktion ` canReadLine()` vor dem Lesen können Sie überprüfen, ob eine vollständige Zeile (einschließlich des Zeilenumbruchzeichens) gelesen werden kann.

Diese Funktion ruft ` readLineData()` auf, die durch wiederholte Aufrufe von ` getChar()` implementiert ist. Sie können eine effizientere Implementierung bereitstellen, indem Sie ` readLineData()` in Ihrer eigenen Unterklasse neu implementieren.

Siehe auch ` getChar()`, ` read()`, ` canReadLine()` und ` write()`.

QByteArray QIODevice::readLine(qint64 maxSize = 0)

Liest eine Zeile vom Gerät ein, jedoch nicht mehr als maxSize Zeichen, und gibt das Ergebnis als Byte-Array zurück.

Ist maxSize gleich 0 oder nicht angegeben, kann die Zeile beliebig lang sein, wodurch ein unbegrenztes Einlesen ermöglicht wird.

Die resultierende Zeile kann abschließende Zeilenendezeichen enthalten („\n “ oder „\r\n “), sodass der Aufruf von QByteArray::trimmed() erforderlich sein kann.

Diese Funktion verfügt über keine Möglichkeit, Fehler zu melden; die Rückgabe eines leeren ` QByteArray ` kann entweder bedeuten, dass derzeit keine Daten zum Lesen verfügbar waren, oder dass ein Fehler aufgetreten ist.

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

Liest bis zu maxSize Zeichen in data ein und gibt die Anzahl der gelesenen Zeichen zurück.

Diese Funktion wird von ` readLine()` aufgerufen und stellt deren Basisimplementierung bereit, wobei ` getChar()` verwendet wird. Gepufferte Geräte können die Leistung von ` readLine()` verbessern, indem sie diese Funktion neu implementieren.

readLine() fügt an „ data “ ein „\0 “-Byte an; readLineData() muss dies nicht tun.

Wenn Sie diese Funktion neu implementieren, achten Sie darauf, den korrekten Wert zurückzugeben: Sie sollte die Anzahl der in dieser Zeile gelesenen Bytes einschließlich des abschließenden Zeilenumbruchs zurückgeben oder 0, wenn an dieser Stelle keine Zeile zu lesen ist. Tritt ein Fehler auf, sollte sie genau dann -1 zurückgeben, wenn keine Bytes gelesen wurden. Das Lesen über das EOF hinaus gilt als Fehler.

Liest eine Zeile von diesem Gerät in „ buffer “ ein und gibt die Teilmenge von „ buffer “ zurück, die die eingelesenen Daten enthält.

Ist die Größe von ` buffer` kleiner als die Länge der Zeile, werden nur die Zeichen gelesen und zurückgegeben, die in ` buffer ` Platz finden. In diesem Fall wird durch einen erneuten Aufruf von ` readLineInto()` der Rest der Zeile abgerufen. Um festzustellen, ob die gesamte Zeile gelesen wurde, prüfen Sie zunächst, ob das Gerät ` atEnd()` ist, für den Fall, dass die letzte Zeile nicht mit einem Zeilenumbruch endete. Ist dies nicht der Fall (` atEnd()`), überprüfen Sie, ob die zurückgegebene Ansicht mit `'\n'` endet. Andernfalls ist ein weiterer Aufruf von ` readLineInto()` erforderlich.

Die resultierende Zeile kann abschließende Zeilenendezeichen enthalten („\n “ oder „\r\n “), sodass ein Aufruf von QByteArrayView::trimmed() erforderlich sein kann.

Falls ein Fehler aufgetreten ist, gibt diese Funktion einen Null- QByteArrayView zurück. Andernfalls handelt es sich um einen Teilbereich von buffer. Wenn derzeit keine Daten zum Lesen verfügbar waren oder das Gerät atEnd() ist, gibt diese Funktion einen leeren QByteArrayView zurück.

Beachten Sie, dass der Rückgabewert nicht null-terminiert ist. Wenn Sie eine Null-Terminierung wünschen, können Sie ` buffer.chopped(1) ` übergeben und anschließend `'\0'` an ` buffer[result.size()]` einfügen.

Diese Funktionen wurden in Qt 6.9 eingeführt.

Siehe auch ` readLine()`.

[since 6.9] bool QIODevice::readLineInto(QByteArray *line, qint64 maxSize = 0)

Liest eine Zeile vom Gerät ein, jedoch nicht mehr als maxSize Zeichen, und speichert sie als Byte-Array in line.

Ist maxSize gleich 0 oder nicht angegeben, kann die Zeile beliebig lang sein, wodurch unbegrenztes Einlesen ermöglicht wird.

Die resultierende Zeile kann abschließende Zeilenendezeichen enthalten („\n “ oder „\r\n “), sodass der Aufruf von ` QByteArray::trimmed()` erforderlich sein kann.

Wenn derzeit keine Daten zum Lesen verfügbar waren oder ein Fehler aufgetreten ist, gibt diese Funktion „ false “ zurück und setzt „ line “ auf „ empty “. Andernfalls gibt sie „ true “ zurück.

Beachten Sie, dass der Inhalt von ` line ` vor dem Aufruf in jedem Fall verworfen wird, dessen ` capacity()` jedoch niemals verringert wird.

Diese Funktion wurde in Qt 6.9 eingeführt.

Siehe auch readAll(), readLine() und QTextStream::readLineInto().

[signal] void QIODevice::readyRead()

Dieses Signal wird jedes Mal einmal ausgegeben, wenn neue Daten zum Auslesen aus dem aktuellen Lesekanal des Geräts verfügbar sind. Es wird erst wieder ausgegeben, sobald neue Daten verfügbar sind, beispielsweise wenn eine neue Nutzlast mit Netzwerkdaten an Ihrem Netzwerk-Socket eingetroffen ist oder wenn ein neuer Datenblock an Ihr Gerät angehängt wurde.

`readyRead()` wird nicht rekursiv ausgelöst; wenn Sie die Ereignisschleife erneut betreten oder ` waitForReadyRead()` innerhalb eines Slots aufrufen, der mit dem Signal `readyRead()` verbunden ist, wird das Signal nicht erneut ausgelöst (obwohl ` waitForReadyRead()` möglicherweise weiterhin `true` zurückgibt).

Hinweis für Entwickler, die von ` QIODevice` abgeleitete Klassen implementieren: Sie sollten `readyRead()` immer auslösen, wenn neue Daten eingetroffen sind (lösen Sie es nicht nur aus, weil sich noch Daten in Ihren Puffern befinden, die gelesen werden müssen). Lösen Sie `readyRead()` unter keinen anderen Umständen aus.

Siehe auch ` bytesWritten()`.

[virtual] bool QIODevice::reset()

Sucht den Anfang der Eingabe für Geräte mit wahlfreiem Zugriff. Gibt bei Erfolg „true“ zurück; andernfalls wird „ false “ zurückgegeben (beispielsweise, wenn das Gerät nicht geöffnet ist).

Beachten Sie, dass bei Verwendung eines „ QTextStream “ auf einem „ QFile “ der Aufruf von `reset()` auf dem „ QFile “ nicht das erwartete Ergebnis liefert, da „ QTextStream “ die Datei puffert. Verwenden Sie stattdessen die Funktion ` QTextStream::seek()`.

Siehe auch seek().

void QIODevice::rollbackTransaction()

Macht eine Lese-Transaktion rückgängig.

Stellt den Eingabestrom auf den Zeitpunkt des Aufrufs von ` startTransaction()` zurück. Diese Funktion wird üblicherweise verwendet, um die Transaktion zurückzusetzen, wenn vor dem Commit der Transaktion ein unvollständiger Lesevorgang festgestellt wurde.

Siehe auch ` startTransaction()` und ` commitTransaction()`.

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

Bei Geräten mit wahlfreiem Zugriff setzt diese Funktion die aktuelle Position auf ` pos` und gibt bei Erfolg „true“ zurück, andernfalls „false“, falls ein Fehler aufgetreten ist. Bei sequenziellen Geräten wird standardmäßig eine Warnung ausgegeben und „false“ zurückgegeben.

Wenn Sie eine Unterklasse von ` QIODevice` erstellen, müssen Sie zu Beginn Ihrer Funktion `QIODevice::seek()` aufrufen, um die Konsistenz mit dem integrierten Puffer von ` QIODevice` sicherzustellen.

Siehe auch ` pos()` und ` isSequential()`.

void QIODevice::setCurrentReadChannel(int channel)

Setzt den aktuellen Lesekanal des „ QIODevice “ auf den angegebenen „ channel “. Der aktuelle Eingangskanal wird von den Funktionen „ read()“, „ readAll()“, „ readLine()“ und „ getChar()“ verwendet. Er bestimmt außerdem, welcher Kanal „ QIODevice “ dazu veranlasst, „ readyRead()“ auszulösen.

Siehe auch currentReadChannel(), readChannelCount() und QProcess.

void QIODevice::setCurrentWriteChannel(int channel)

Setzt den aktuellen Schreibkanal des „ QIODevice “ auf den angegebenen „ channel “. Der aktuelle Ausgangskanal wird von den Funktionen „ write()“ und „ putChar()“ verwendet. Er bestimmt außerdem, welcher Kanal „ QIODevice “ dazu veranlasst, „ bytesWritten()“ auszugeben.

Siehe auch currentWriteChannel() und writeChannelCount().

[protected] void QIODevice::setErrorString(const QString &str)

Setzt die für Menschen lesbare Beschreibung des zuletzt aufgetretenen Gerätefehlers auf „ str “.

Siehe auch errorString().

[protected] void QIODevice::setOpenMode(QIODeviceBase::OpenMode openMode)

Setzt den OpenMode des Geräts auf „ openMode “. Rufen Sie diese Funktion auf, um den Öffnungsmodus festzulegen, falls sich die Flags ändern, nachdem das Gerät geöffnet wurde.

Siehe auch „ openMode()“ und „ OpenMode “.

void QIODevice::setTextModeEnabled(bool enabled)

Wenn „ enabled “ wahr ist, setzt diese Funktion das Flag „ Text “ auf dem Gerät; andernfalls wird das Flag „ Text “ entfernt. Diese Funktion ist nützlich für Klassen, die eine benutzerdefinierte Zeilenende-Verarbeitung auf einem „ QIODevice “ bereitstellen.

Das E/A-Gerät sollte vor dem Aufruf dieser Funktion geöffnet sein.

Siehe auch „ isTextModeEnabled()“, „ open()“ und „ setOpenMode()“.

[virtual] qint64 QIODevice::size() const

Bei geöffneten Geräten mit wahlfreiem Zugriff gibt diese Funktion die Größe des Geräts zurück. Bei geöffneten sequenziellen Geräten wird „ bytesAvailable()“ zurückgegeben.

Ist das Gerät geschlossen, entspricht die zurückgegebene Größe nicht der tatsächlichen Größe des Geräts.

Siehe auch ` isSequential()` und ` pos()`.

qint64 QIODevice::skip(qint64 maxSize)

Überspringt bis zu maxSize Bytes vom Gerät. Gibt die Anzahl der tatsächlich übersprungenen Bytes zurück oder -1 im Fehlerfall.

Diese Funktion wartet nicht und verwirft lediglich die Daten, die bereits zum Lesen verfügbar sind.

Wenn das Gerät im Textmodus geöffnet ist, werden Zeilenendezeichen in die Symbole „\n “ umgewandelt und zählen als ein einzelnes Byte – genau wie bei den Funktionen „ read()“ und „ peek()“.

Diese Funktion funktioniert für alle Geräte, einschließlich sequenzieller Geräte, die seek() nicht unterstützen. Sie ist darauf optimiert, unerwünschte Daten nach einem Aufruf von peek() zu überspringen.

Bei Geräten mit wahlfreiem Zugriff kann `skip()` verwendet werden, um von der aktuellen Position aus vorwärts zu springen. Negative Werte für ` maxSize ` sind nicht zulässig.

Siehe auch skipData(), peek(), seek() und read().

[virtual protected, since 6.0] qint64 QIODevice::skipData(qint64 maxSize)

Überspringt bis zu maxSize Bytes vom Gerät. Gibt die Anzahl der tatsächlich übersprungenen Bytes zurück oder -1 im Fehlerfall.

Diese Funktion wird von ` QIODevice` aufgerufen. Erwägen Sie eine Neuimplementierung, wenn Sie eine Unterklasse von ` QIODevice` erstellen.

Die Basisimplementierung verwirft die Daten, indem sie in einen Dummy-Puffer eingelesen werden. Dies ist langsam, funktioniert aber für alle Gerätetypen. Unterklassen können diese Funktion neu implementieren, um die Leistung zu verbessern.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch ` skip()`, ` peek()`, ` seek()` und ` read()`.

void QIODevice::startTransaction()

Startet eine neue Lesetransaktion auf dem Gerät.

Definiert einen Wiederherstellungspunkt innerhalb der Abfolge von Lesevorgängen. Bei sequenziellen Geräten werden die Lesedaten intern dupliziert, um im Falle unvollständiger Lesevorgänge eine Wiederherstellung zu ermöglichen. Bei Geräten mit wahlfreiem Zugriff speichert diese Funktion die aktuelle Position. Rufen Sie „ commitTransaction()“ oder „ rollbackTransaction()“ auf, um die Transaktion abzuschließen.

Siehe auch ` commitTransaction()` und ` rollbackTransaction()`.

void QIODevice::ungetChar(char c)

Schreibt das Zeichen „ c “ zurück in das Gerät und verringert die aktuelle Position um eins, sofern diese nicht bereits 0 ist. Diese Funktion wird in der Regel aufgerufen, um eine Operation mit „ getChar()“ rückgängig zu machen, beispielsweise beim Schreiben eines Backtracking-Parsers.

Wenn „ c “ zuvor nicht aus dem Gerät gelesen wurde, ist das Verhalten undefiniert.

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

Bei gepufferten Geräten wartet diese Funktion so lange, bis eine Nutzlast aus gepufferten Schreibdaten auf das Gerät geschrieben und das Signal „ bytesWritten()“ ausgelöst wurde oder bis msecs Millisekunden verstrichen sind. Ist „msecs“ gleich -1, gibt es bei dieser Funktion kein Timeout. Bei ungepufferten Geräten kehrt die Funktion sofort zurück.

Gibt ` true ` zurück, wenn eine Nutzlast an Daten auf das Gerät geschrieben wurde; andernfalls gibt sie ` false ` zurück (d. h. wenn das Zeitlimit abgelaufen ist oder ein Fehler aufgetreten ist).

Diese Funktion kann ohne Ereignisschleife ausgeführt werden. Sie ist nützlich beim Schreiben von Nicht-GUI-Anwendungen und bei der Durchführung von E/A-Operationen in einem Nicht-GUI-Thread.

Wird die Funktion aus einem Slot heraus aufgerufen, der mit dem Signal „ bytesWritten()“ verbunden ist, wird „ bytesWritten()“ nicht erneut ausgesendet.

Implementieren Sie diese Funktion neu, um eine blockierende API für ein benutzerdefiniertes Gerät bereitzustellen. Die Standardimplementierung führt keine Aktion aus und gibt „ false “ zurück.

Siehe auch waitForReadyRead().

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

Die Funktion wartet, bis neue Daten zum Lesen verfügbar sind und das Signal „ readyRead()“ ausgelöst wurde, oder bis msecs Millisekunden verstrichen sind. Ist „msecs“ gleich -1, gibt es bei dieser Funktion kein Zeitlimit.

Gibt „ true “ zurück, wenn neue Daten zum Lesen verfügbar sind; andernfalls wird „false“ zurückgegeben (wenn die Operation abgelaufen ist oder ein Fehler aufgetreten ist).

Diese Funktion kann ohne Ereignisschleife ausgeführt werden. Sie ist nützlich beim Schreiben von Nicht-GUI-Anwendungen und bei der Durchführung von E/A-Operationen in einem Nicht-GUI-Thread.

Wird die Funktion aus einem Slot heraus aufgerufen, der mit dem Signal „ readyRead()“ verbunden ist, wird „ readyRead()“ nicht erneut gesendet.

Implementieren Sie diese Funktion neu, um eine blockierende API für ein benutzerdefiniertes Gerät bereitzustellen. Die Standardimplementierung führt keine Aktion aus und gibt ` false` zurück.

Siehe auch waitForBytesWritten().

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

Schreibt höchstens maxSize Bytes an Daten von data auf das Gerät. Gibt die Anzahl der tatsächlich geschriebenen Bytes zurück oder -1, falls ein Fehler aufgetreten ist.

Siehe auch read() und writeData().

qint64 QIODevice::write(const QByteArray &data)

Schreibt den Inhalt von ` data ` auf das Gerät. Gibt die Anzahl der tatsächlich geschriebenen Bytes zurück oder -1, falls ein Fehler aufgetreten ist.

Siehe auch „ read()“ und „ writeData()“.

qint64 QIODevice::write(const char *data)

Schreibt Daten aus einer nullterminierten Zeichenkette aus 8-Bit-Zeichen auf das Gerät. Gibt die Anzahl der tatsächlich geschriebenen Bytes zurück oder -1, falls ein Fehler aufgetreten ist. Dies entspricht

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

Siehe auch read() und writeData().

int QIODevice::writeChannelCount() const

Gibt die Anzahl der verfügbaren Schreibkanäle zurück, sofern das Gerät geöffnet ist; andernfalls wird 0 zurückgegeben.

Siehe auch ` readChannelCount()`.

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

Schreibt bis zu maxSize Bytes von data auf das Gerät. Gibt die Anzahl der geschriebenen Bytes zurück oder -1, falls ein Fehler aufgetreten ist.

Diese Funktion wird von ` QIODevice` aufgerufen. Implementieren Sie diese Funktion neu, wenn Sie eine Unterklasse von ` QIODevice` erstellen.

Bei der Neuimplementierung dieser Funktion ist es wichtig, dass die Funktion alle verfügbaren Daten schreibt, bevor sie zurückkehrt. Dies ist erforderlich, damit QDataStream mit der Klasse arbeiten kann. QDataStream geht davon aus, dass alle Informationen geschrieben wurden, und versucht daher nicht erneut zu schreiben, falls ein Problem aufgetreten ist.

Siehe auch read() und write().