QIODevice Class

Dokumentation der Mitgliedsfunktionen

QIODevice::QIODevice()

Konstruiert ein QIODevice-Objekt.

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

Konstruiert ein QIODevice-Objekt mit der angegebenen parent.

[virtual noexcept] QIODevice::~QIODevice()

Der Destruktor ist virtuell, und QIODevice ist eine abstrakte Basisklasse. Dieser Destruktor ruft nicht close() auf, aber der Destruktor der Unterklasse könnte dies tun. Im Zweifelsfall rufen Sie close() auf, bevor Sie die QIODevice zerstören.

[signal] void QIODevice::aboutToClose()

Dieses Signal wird ausgegeben, wenn das Gerät kurz vor dem Schließen steht. Schließen Sie dieses Signal an, wenn Sie Operationen durchführen müssen, bevor das Gerät geschlossen wird (z. B. wenn Sie Daten in einem separaten Puffer haben, die in 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 weiteren Daten zum Lesen auf dem Gerät verfügbar); andernfalls wird false zurückgegeben.

Bei einigen Geräten kann atEnd() true zurückgeben, obwohl noch weitere Daten zu lesen sind. Dieser Sonderfall gilt nur für Geräte, die Daten als direkte Reaktion auf den Aufruf von read() erzeugen (z. B. /dev oder /proc Dateien unter Unix und macOS oder 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 üblicherweise bei sequenziellen Geräten verwendet, um die Anzahl der Bytes zu bestimmen, die vor dem Lesen in einem Puffer zugewiesen werden müssen.

Unterklassen, die diese Funktion neu implementieren, müssen die Basisimplementierung aufrufen, um die Größe des Puffers von QIODevice zu übernehmen. 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 darauf warten, geschrieben zu werden. 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 zu übernehmen.

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

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

Dieses Signal wird jedes Mal ausgegeben, wenn eine Nutzlast an Daten in den aktuellen Schreibkanal des Geräts geschrieben wurde. Das Argument bytes wird auf die Anzahl der Bytes gesetzt, die in diese Nutzlast geschrieben wurden.

bytesWritten() wird nicht rekursiv ausgegeben; wenn Sie innerhalb eines mit dem bytesWritten()-Signal verbundenen Slots erneut in die Ereignisschleife eintreten oder waitForBytesWritten() aufrufen, wird das Signal nicht erneut ausgegeben (obwohl waitForBytesWritten() weiterhin true zurückgeben kann).

Siehe auch readyRead().

[virtual] bool QIODevice::canReadLine() const

Gibt true zurück, wenn eine komplette Datenzeile aus dem Gerät gelesen werden kann; andernfalls wird false zurückgegeben.

Beachten Sie, dass ungepufferte Geräte, die keine Möglichkeit haben, zu bestimmen, was gelesen werden kann, immer false zurückgeben.

Diese Funktion wird oft 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 aufzunehmen. 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 ausgegeben, wenn eine Nutzlast an Daten in das Gerät geschrieben wurde. Das Argument bytes wird auf die Anzahl der Bytes gesetzt, die in diese Nutzlast geschrieben wurden, während channel der Kanal ist, in den sie geschrieben wurden. Im Gegensatz zu bytesWritten() wird es unabhängig von current write channel ausgegeben.

channelBytesWritten() kann rekursiv ausgegeben werden - sogar für denselben Kanal.

Siehe auch bytesWritten() und channelReadyRead().

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

Dieses Signal wird ausgegeben, wenn neue Daten zum Lesen aus dem Gerät verfügbar sind. Das Argument channel wird auf den Index des Lesekanals gesetzt, auf dem die Daten eingetroffen sind. Im Gegensatz zu readyRead() wird es unabhängig von current read channel ausgegeben.

channelReadyRead() kann rekursiv ausgeführt werden - sogar für denselben Kanal.

Siehe auch readyRead() und channelBytesWritten().

[virtual] void QIODevice::close()

Zuerst wird aboutToClose() ausgegeben, dann wird das Gerät geschlossen und sein OpenMode auf NotOpen gesetzt. Der Fehlerstring wird ebenfalls zurückgesetzt.

Siehe auch setOpenMode() und QIODeviceBase::OpenMode.

void QIODevice::commitTransaction()

Schließt eine Lesetransaktion ab.

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

Siehe auch startTransaction() und rollbackTransaction().

int QIODevice::currentReadChannel() const

Gibt den Index des aktuellen Lesekanals 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 von Menschen lesbare Beschreibung des letzten aufgetretenen Gerätefehlers zurück.

Siehe auch setErrorString().

bool QIODevice::getChar(char *c)

Liest ein Zeichen aus dem Gerät und speichert es in c. Wenn c gleich nullptr ist, 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 offen ist; andernfalls false. Ein Gerät ist offen, wenn von ihm gelesen und/oder auf es geschrieben 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 aus dem 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 Komfortfunktion, 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 dieses Gerät sequentiell ist; andernfalls wird false zurückgegeben.

Sequentielle Geräte haben im Gegensatz zu Geräten mit wahlfreiem Zugriff kein Konzept für einen Anfang, ein Ende, eine Größe oder eine aktuelle Position und unterstützen kein Suchen. Sie können nur aus dem Gerät lesen, wenn es meldet, dass Daten verfügbar sind. Das häufigste Beispiel für ein sequentielles Gerät ist ein Netzwerk-Socket. Unter Unix sind spezielle Dateien wie /dev/zero und Fifo-Pipes sequentiell.

Reguläre Dateien hingegen unterstützen den wahlfreien Zugriff. Sie haben sowohl eine Größe als auch eine aktuelle Position, und sie unterstützen auch die Suche vorwärts und rückwärts im Datenstrom. Reguläre Dateien sind nicht sequenziell.

Siehe auch bytesAvailable().

bool QIODevice::isTextModeEnabled() const

Gibt true zurück, wenn das Flag Text aktiviert ist; andernfalls gibt es false zurück.

Siehe auch setTextModeEnabled().

bool QIODevice::isTransactionStarted() const

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

Siehe auch startTransaction().

bool QIODevice::isWritable() const

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

Dies ist eine Komfortfunktion, 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 seinen OpenMode auf mode. Gibt bei Erfolg true zurück, andernfalls false. Diese Funktion sollte von jeder Neuimplementierung von open() oder anderen Funktionen, die das Gerät öffnen, aufgerufen werden.

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 aus dem Gerät in data, ohne Seiteneffekte (d.h., wenn Sie read() nach peek() aufrufen, erhalten Sie dieselben Daten). Gibt die Anzahl der gelesenen Bytes zurück. Tritt ein Fehler auf, z. B. beim Versuch, ein im WriteOnly-Modus geöffnetes Gerät zu durchsuchen, gibt diese Funktion -1 zurück.

0 wird zurückgegeben, wenn keine weiteren Daten 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)

Dies ist eine überladene Funktion.

Liest maximal maxSize Bytes aus dem Gerät aus und gibt die ausgelesenen Daten als QByteArray zurück.

Beispiel:

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

Diese Funktion hat keine Möglichkeit, Fehler zu melden; die Rückgabe eines leeren QByteArray kann entweder bedeuten, dass derzeit keine Daten zum Peeken verfügbar sind 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 die Daten geschrieben oder von der Daten gelesen werden. Bei sequentiellen Geräten oder geschlossenen Geräten, bei denen es kein Konzept für eine "aktuelle Position" gibt, wird 0 zurückgegeben.

Die aktuelle Lese-/Schreibposition des Geräts wird intern von QIODevice verwaltet, so dass eine Neuimplementierung dieser Funktion nicht erforderlich ist. Wenn Sie QIODevice unterklassifizieren, 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 false.

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

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

Liest maximal maxSize Bytes aus dem Gerät in data und gibt die Anzahl der gelesenen Bytes zurück. Tritt ein Fehler auf, z. B. beim Versuch, von einem Gerät zu lesen, das im Schreibmodus geöffnet ist, gibt diese Funktion -1 zurück.

0 wird zurückgegeben, wenn keine weiteren Daten zum Lesen verfügbar sind. Das Lesen über das Ende des Streams hinaus wird jedoch als Fehler betrachtet, so dass diese Funktion in solchen Fällen -1 zurückgibt (d. h. beim Lesen über einen geschlossenen Socket oder nachdem ein Prozess gestorben ist).

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

QByteArray QIODevice::read(qint64 maxSize)

Dies ist eine überladene Funktion.

Liest maximal maxSize Bytes aus dem Gerät und gibt die gelesenen Daten als QByteArray zurück.

Diese Funktion hat 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 aus dem Gerät und gibt sie als Byte-Array zurück.

Diese Funktion hat 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 hat auch keine Möglichkeit, anzuzeigen, dass mehr Daten verfügbar waren und nicht gelesen werden konnten.

int QIODevice::readChannelCount() const

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

Siehe auch writeChannelCount() und QProcess.

[signal] void QIODevice::readChannelFinished()

Dieses Signal wird ausgegeben, wenn der Eingangsstrom (Lesestrom) in diesem Gerät geschlossen wird. Es wird ausgegeben, sobald das Schließen erkannt wird, was bedeutet, dass noch Daten zum Lesen mit read() vorhanden sein können.

Siehe auch atEnd() und read().

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

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

Wenn es keine zu lesenden Bytes gibt und niemals mehr Bytes verfügbar sein können (Beispiele: Socket geschlossen, Pipe geschlossen, Subprozess beendet), gibt diese Funktion -1 zurück.

Diese Funktion wird von QIODevice aufgerufen. Reimplementieren Sie diese Funktion, wenn Sie eine Unterklasse von QIODevice erstellen.

Wenn Sie diese Funktion neu implementieren, ist es wichtig, dass diese Funktion alle erforderlichen Daten liest, bevor sie zurückkehrt. Dies ist erforderlich, damit QDataStream mit der Klasse arbeiten kann. QDataStream geht davon aus, dass alle angeforderten Informationen gelesen wurden und versucht daher nicht, das Lesen zu wiederholen, wenn es ein Problem gab.

Diese Funktion kann mit einer maxSize von 0 aufgerufen werden, was für die Durchführung von Nachleseoperationen verwendet werden kann.

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

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

Diese Funktion liest eine Zeile von ASCII-Zeichen aus dem Gerät, bis zu einem Maximum von maxSize - 1 Bytes, speichert die Zeichen in data und gibt die Anzahl der gelesenen Bytes zurück. Wenn eine Zeile nicht gelesen werden konnte, aber kein Fehler auftrat, gibt diese Funktion 0 zurück. Tritt ein Fehler auf, gibt diese Funktion die Länge dessen zurück, was gelesen werden konnte, oder -1, wenn nichts gelesen wurde.

Ein abschließendes '\0' Byte wird immer an data angehängt, so dass maxSize größer als 1 sein muss.

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

• Das erste '\n'-Zeichen wird gelesen.
• maxSize - Es werden 1 Byte gelesen.
• Das Ende der Gerätedaten wird erkannt.

Der folgende Code liest zum Beispiel eine Zeile von Zeichen 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 Newline-Zeichen ('\n') wird in den Puffer aufgenommen. Wenn ein Zeilenumbruch nicht erkannt wird, bevor maxSize - 1 Bytes gelesen werden, wird kein Zeilenumbruch in den Puffer eingefügt. Bei Fenstern werden Zeilenumbrüche durch '\n' ersetzt.

Beachten Sie, dass auf sequenziellen Geräten die Daten möglicherweise nicht sofort verfügbar sind, was dazu führen kann, dass eine Teilzeile zurückgegeben wird. Durch den Aufruf der Funktion canReadLine() vor dem Lesen können Sie prüfen, ob eine vollständige Zeile (einschließlich des Zeilenumbruchs) 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 reimplementieren.

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

QByteArray QIODevice::readLine(qint64 maxSize = 0)

Dies ist eine überladene Funktion.

Liest eine Zeile aus dem Gerät, 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 eine beliebige Länge haben, so dass unbegrenzt gelesen werden kann.

Die resultierende Zeile kann abschließende Zeilenende-Zeichen ("\n" oder "\r\n") enthalten, so dass der Aufruf von QByteArray::trimmed() notwendig sein kann.

Diese Funktion hat keine Möglichkeit, Fehler zu melden; die Rückgabe einer 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 und gibt die Anzahl der gelesenen Zeichen zurück.

Diese Funktion wird von readLine() aufgerufen und bietet ihre Basisimplementierung mit getChar(). Gepufferte Geräte können die Leistung von readLine() durch Neuimplementierung dieser Funktion verbessern.

readLine() fügt ein '\0'-Byte an data an; readLineData() braucht dies nicht zu tun.

Wenn Sie diese Funktion neu implementieren, achten Sie darauf, dass sie den richtigen Wert zurückgibt: Sie sollte die Anzahl der in dieser Zeile gelesenen Bytes zurückgeben, einschließlich des abschließenden Zeilenumbruchs, oder 0, wenn es an dieser Stelle keine zu lesende Zeile gibt. Wenn ein Fehler auftritt, sollte -1 zurückgegeben werden, wenn keine Bytes gelesen wurden. Das Lesen nach EOF wird als Fehler betrachtet.

[signal] void QIODevice::readyRead()

Dieses Signal wird jedes Mal ausgegeben, wenn neue Daten zum Lesen vom aktuellen Lesekanal des Geräts verfügbar sind. Es wird nur dann erneut ausgegeben, wenn neue Daten verfügbar sind, z.B. wenn eine neue Nutzlast von Netzwerkdaten an Ihrem Netzwerksocket angekommen ist oder wenn ein neuer Datenblock an Ihr Gerät angehängt wurde.

readyRead() wird nicht rekursiv ausgegeben; wenn Sie die Ereignisschleife erneut betreten oder waitForReadyRead() innerhalb eines Slots aufrufen, der mit dem readyRead()-Signal verbunden ist, wird das Signal nicht erneut ausgegeben (obwohl waitForReadyRead() weiterhin true zurückgeben kann).

Hinweis für Entwickler, die von QIODevice abgeleitete Klassen implementieren: Sie sollten readyRead() immer dann ausgeben, wenn neue Daten eingetroffen sind (geben Sie es nicht aus, nur weil noch Daten in Ihren Puffern zu lesen sind). Geben Sie readyRead() nicht unter anderen Bedingungen aus.

Siehe auch bytesWritten().

[virtual] bool QIODevice::reset()

Sucht bei Geräten mit wahlfreiem Zugriff nach dem Beginn der Eingabe. Bei Erfolg wird true zurückgegeben; andernfalls wird false zurückgegeben (z. B. wenn das Gerät nicht geöffnet ist).

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

Siehe auch seek().

void QIODevice::rollbackTransaction()

Rollt eine Lesetransaktion zurück.

Stellt den Eingabestrom an dem Punkt wieder her, an dem der Aufruf startTransaction() erfolgte. Diese Funktion wird üblicherweise verwendet, um die Transaktion zurückzusetzen, wenn ein unvollständiger Lesevorgang vor dem Commit der Transaktion entdeckt 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 oder false, wenn ein Fehler aufgetreten ist. Bei sequentiellen Geräten wird standardmäßig eine Warnung ausgegeben und false zurückgegeben.

Wenn Sie QIODevice subclassing, müssen Sie QIODevice::seek() am Anfang Ihrer Funktion aufrufen, um die Integrität mit dem eingebauten Puffer von QIODevice sicherzustellen.

Siehe auch pos() und isSequential().

void QIODevice::setCurrentReadChannel(int channel)

Setzt den aktuellen Lesekanal von QIODevice auf den angegebenen channel. Der aktuelle Eingangskanal wird von den Funktionen read(), readAll(), readLine() und getChar() verwendet. Er bestimmt auch, welcher Kanal QIODevice zur Ausgabe von readyRead() veranlasst.

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

void QIODevice::setCurrentWriteChannel(int channel)

Setzt den aktuellen Schreibkanal von QIODevice auf den angegebenen channel. Der aktuelle Ausgabekanal wird von den Funktionen write(), putChar() verwendet. Er bestimmt auch, welcher Kanal QIODevice zur Ausgabe von bytesWritten() veranlasst.

Siehe auch currentWriteChannel() und writeChannelCount().

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

Setzt die menschenlesbare Beschreibung des letzten 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 zu setzen, wenn 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 Text Flag auf dem Gerät; andernfalls wird das Text Flag entfernt. Diese Funktion ist nützlich für Klassen, die eine benutzerdefinierte Behandlung von Zeilenenden auf einem QIODevice anbieten.

Das IO-Gerät sollte vor dem Aufruf dieser Funktion geöffnet werden.

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

[virtual] qint64 QIODevice::size() const

Bei offenen Direktzugriffsgeräten gibt diese Funktion die Größe des Geräts zurück. Für offene sequentielle Geräte wird bytesAvailable() zurückgegeben.

Wenn das Gerät geschlossen ist, 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 aus dem Gerät. Gibt die Anzahl der tatsächlich übersprungenen Bytes zurück, oder -1 bei einem Fehler.

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

Wenn das Gerät im Textmodus geöffnet ist, werden Zeilenendezeichen in '\n'-Symbole umgewandelt und als ein einzelnes Byte gezählt, genau wie bei read() und peek().

Diese Funktion funktioniert für alle Geräte, auch für sequenzielle Geräte, die nicht seek() können. Sie ist so optimiert, dass unerwünschte Daten nach einem peek()-Aufruf übersprungen werden.

Bei Geräten mit wahlfreiem Zugriff kann skip() verwendet werden, um von der aktuellen Position aus weiterzusuchen. Negative maxSize Werte sind nicht erlaubt.

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

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

Überspringt bis zu maxSize Bytes aus dem Gerät. Gibt die Anzahl der tatsächlich übersprungenen Bytes zurück, oder -1 bei einem Fehler.

Diese Funktion wird von QIODevice aufgerufen. Erwägen Sie, sie neu zu implementieren, wenn Sie eine Unterklasse von QIODevice erstellen.

Die Basisimplementierung verwirft die Daten, indem sie in einen Dummy-Puffer liest. Dies ist langsam, funktioniert aber für alle Gerätetypen. Unterklassen können diese Funktion reimplementieren, um sie 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 wiederherstellbaren Punkt innerhalb der Sequenz von Lesevorgängen. Bei sequentiellen Geräten werden die gelesenen Daten intern dupliziert, um eine Wiederherstellung im Falle unvollständiger Lesevorgänge zu ermöglichen. Bei Geräten mit wahlfreiem Zugriff speichert diese Funktion die aktuelle Position. Rufen Sie commitTransaction() oder rollbackTransaction() auf, um die Transaktion zu beenden.

Siehe auch commitTransaction() und rollbackTransaction().

void QIODevice::ungetChar(char c)

Legt das Zeichen c zurück in das Gerät und dekrementiert die aktuelle Position, es sei denn, die Position ist 0. Diese Funktion wird normalerweise aufgerufen, um eine getChar()-Operation "rückgängig" zu machen, z. B. beim Schreiben eines Backtracking-Parsers.

Wenn c nicht zuvor vom Gerät gelesen wurde, ist das Verhalten undefiniert.

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

Bei gepufferten Geräten wartet diese Funktion, bis eine Nutzlast gepufferter geschriebener Daten in das Gerät geschrieben wurde und das Signal bytesWritten() ausgegeben wurde oder bis msecs Millisekunden vergangen sind. Wenn msecs -1 ist, wird diese Funktion nicht beendet. Bei ungepufferten Geräten kehrt sie sofort zurück.

Gibt true zurück, wenn eine Nutzlast von Daten in das Gerät geschrieben wurde; andernfalls gibt sie false zurück (d. h. wenn die Zeit für den Vorgang abgelaufen oder ein Fehler aufgetreten ist).

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

Wenn sie von einem Slot aus aufgerufen wird, der mit dem Signal bytesWritten() verbunden ist, wird bytesWritten() nicht erneut gesendet.

Reimplementieren Sie diese Funktion, um eine blockierende API für ein benutzerdefiniertes Gerät bereitzustellen. Die Standardimplementierung tut nichts und gibt false zurück.

Siehe auch waitForReadyRead().

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

Blockiert, bis neue Daten zum Lesen verfügbar sind und das Signal readyRead() ausgegeben wurde, oder bis msecs Millisekunden vergangen sind. Wenn msecs -1 ist, wird diese Funktion nicht abgebrochen.

Gibt true zurück, wenn neue Daten zum Lesen verfügbar sind; andernfalls wird false zurückgegeben (wenn der Vorgang eine Zeitüberschreitung hatte oder ein Fehler auftrat).

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

Wenn sie von einem Slot aus aufgerufen wird, der mit dem Signal readyRead() verbunden ist, wird readyRead() nicht erneut gesendet.

Reimplementieren Sie diese Funktion, um eine blockierende API für ein benutzerdefiniertes Gerät bereitzustellen. Die Standardimplementierung tut nichts und gibt false zurück.

Siehe auch waitForBytesWritten().

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

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

Siehe auch read() und writeData().

qint64 QIODevice::write(const QByteArray &data)

Dies ist eine überladene Funktion.

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

Siehe auch read() und writeData().

qint64 QIODevice::write(const char *data)

Dies ist eine überladene Funktion.

Schreibt Daten aus einer null-terminierten Zeichenkette von 8-Bit-Zeichen in das Gerät. Gibt die Anzahl der tatsächlich geschriebenen Bytes zurück, oder -1, wenn ein Fehler aufgetreten ist. Dies ist äquivalent zu

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

Siehe auch read() und writeData().

int QIODevice::writeChannelCount() const

Gibt die Anzahl der verfügbaren Schreibkanäle zurück, wenn 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, wenn ein Fehler aufgetreten ist.

Diese Funktion wird von QIODevice aufgerufen. Reimplementieren Sie diese Funktion, wenn Sie eine Unterklasse von QIODevice erstellen.

Wenn Sie diese Funktion neu implementieren, ist es wichtig, dass diese 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, wenn es ein Problem gab.

Siehe auch read() und write().