QContiguousCache Class

Dokumentation zu den Member-Funktionen

[explicit] QContiguousCache::QContiguousCache(qsizetype capacity = 0)

Erstellt einen Cache mit dem angegebenen „ capacity “.

Siehe auch ` setCapacity()`.

QContiguousCache::QContiguousCache(const QContiguousCache<T> &other)

Erstellt eine Kopie von ` other`.

Dieser Vorgang dauert eine konstante Zeit, da `QContiguousCache` implizit gemeinsam genutzt wird. Dadurch ist die Rückgabe eines `QContiguousCache` aus einer Funktion sehr schnell. Wird eine gemeinsam genutzte Instanz geändert, wird sie kopiert (Copy-on-Write), was lineare Zeit in Anspruch nimmt.

Siehe auch ` operator=()`.

QContiguousCache::~QContiguousCache()

Löscht den Cache.

void QContiguousCache::append(const T &value)

Fügt „ value “ am Ende des Caches ein. Ist der Cache bereits voll, wird der Eintrag am Anfang des Caches entfernt.

Siehe auch prepend(), insert() und isFull().

bool QContiguousCache::areIndexesValid() const

Gibt zurück, ob die Indizes für die im Cache gespeicherten Elemente gültig sind. Indizes können ungültig werden, wenn Elemente hinter der Indexposition INT_MAX angehängt oder vor der Indexposition 0 vorangestellt werden. Dies ist nur bei einer sehr langlebigen Nutzung des zusammenhängenden Caches im Stil eines Ringpuffers zu erwarten. Indizes können durch den Aufruf von ` normalizeIndexes()` wieder gültig gemacht werden.

Siehe auch ` normalizeIndexes()`, ` append()` und ` prepend()`.

const T &QContiguousCache::at(qsizetype i) const

Gibt das Element an der Indexposition „ i “ im Cache zurück. „ i “ muss eine gültige Indexposition im Cache sein (d. h., firstIndex() <= i <= lastIndex()).

Die Indizes im Cache beziehen sich auf die Anzahl der Positionen, um die das Element vom ersten in den Cache eingefügten Element entfernt ist. Das heißt, ein Cache mit einer Kapazität von 100, dem 150 Elemente hinzugefügt wurden, hat einen gültigen Indexbereich von 50 bis 149. Dies ermöglicht das Einfügen und Abrufen von Elementen in den Cache auf der Grundlage einer theoretisch unendlichen Liste

Siehe auch firstIndex(), lastIndex(), insert() und operator[]().

qsizetype QContiguousCache::available() const

Gibt die Anzahl der Elemente zurück, die dem Cache hinzugefügt werden können, bevor dieser voll ist.

Siehe auch size(), capacity() und isFull().

qsizetype QContiguousCache::capacity() const

Gibt die Anzahl der Elemente zurück, die der Cache speichern kann, bevor er voll ist. Wenn ein Cache eine Anzahl von Elementen enthält, die seiner Kapazität entspricht, führt das Hinzufügen neuer Elemente dazu, dass die Elemente, die am weitesten vom hinzugefügten Element entfernt sind, entfernt werden.

Siehe auch setCapacity() und size().

void QContiguousCache::clear()

Entfernt alle Elemente aus dem Cache. Die Kapazität bleibt unverändert.

bool QContiguousCache::containsIndex(qsizetype i) const

Gibt „ true “ zurück, wenn der Indexbereich des Caches den angegebenen Index „ i “ enthält.

Siehe auch firstIndex() und lastIndex().

qsizetype QContiguousCache::count() const

Entspricht ` size()`.

T &QContiguousCache::first()

Gibt eine Referenz auf das erste Element im Cache zurück. Diese Funktion setzt voraus, dass der Cache nicht leer ist.

Siehe auch last() und isEmpty().

const T &QContiguousCache::first() const

qsizetype QContiguousCache::firstIndex() const

Gibt den ersten gültigen Index im Cache zurück. Der Index ist ungültig, wenn der Cache leer ist.

Siehe auch capacity(), size() und lastIndex().

void QContiguousCache::insert(qsizetype i, const T &value)

Fügt den Wert „ value “ an der Indexposition „ i “ ein. Enthält der Cache bereits einen Eintrag unter „ i “, wird dieser Wert überschrieben. Liegt „ i “ entweder um eins über „ lastIndex “ () oder um eins unter „ firstIndex “ (), entspricht dies einem „ append “ () oder einem „ prepend “ ().

Wenn der angegebene Index i weder innerhalb des aktuellen Bereichs des Caches liegt noch an die Grenzen des Indexbereichs des Caches angrenzt, wird der Cache vor dem Einfügen des Elements zunächst geleert. Zu diesem Zeitpunkt hat der Cache eine Größe von 1. Es lohnt sich, Elemente in einer Reihenfolge einzufügen, die angrenzend an den aktuellen Indexbereich des Caches beginnt.

Der Bereich gültiger Indizes für die Klasse „ QContiguousCache “ reicht von 0 bis INT_MAX. Das Einfügen außerhalb dieses Bereichs führt zu undefiniertem Verhalten.

Siehe auch prepend(), append(), isFull(), firstIndex() und lastIndex().

bool QContiguousCache::isEmpty() const

Gibt „ true “ zurück, wenn keine Elemente im Cache gespeichert sind.

Siehe auch „ size()“ und „ capacity()“.

bool QContiguousCache::isFull() const

Gibt „ true “ zurück, wenn die Anzahl der im Cache gespeicherten Elemente der Kapazität des Caches entspricht.

Siehe auch „ size()“ und „ capacity()“.

T &QContiguousCache::last()

Gibt eine Referenz auf das letzte Element im Cache zurück. Diese Funktion setzt voraus, dass der Cache nicht leer ist.

Siehe auch first() und isEmpty().

const T &QContiguousCache::last() const

qsizetype QContiguousCache::lastIndex() const

Gibt den letzten gültigen Index im Cache zurück. Der Index ist ungültig, wenn der Cache leer ist.

Siehe auch capacity(), size() und firstIndex().

void QContiguousCache::normalizeIndexes()

Verschiebt den ersten und den letzten Index des Caches so, dass sie auf gültige Indizes verweisen. Die Funktion verändert weder den Inhalt des Caches noch die Reihenfolge der Elemente innerhalb des Caches.

Sie wird bereitgestellt, damit Indexüberläufe korrigiert werden können, wenn der Cache als Ringpuffer verwendet wird.

QContiguousCache<int> cache(10);
cache.insert(INT_MAX, 1); // cache contains one value and has valid indexes, INT_MAX to INT_MAX
cache.append(2); // cache contains two values but does not have valid indexes.
cache.normalizeIndexes(); // cache has two values, 1 and 2.  New first index will be in the range of 0 to capacity().

Siehe auch areIndexesValid(), append() und prepend().

void QContiguousCache::prepend(const T &value)

Fügt „ value “ am Anfang des Caches ein. Ist der Cache bereits voll, wird das Element am Ende des Caches entfernt.

Siehe auch append(), insert() und isFull().

void QContiguousCache::removeFirst()

Entfernt das erste Element aus dem Cache. Diese Funktion setzt voraus, dass der Cache nicht leer ist.

Siehe auch ` removeLast()`.

void QContiguousCache::removeLast()

Entfernt den letzten Eintrag aus dem Cache. Diese Funktion setzt voraus, dass der Cache nicht leer ist.

Siehe auch ` removeFirst()`.

void QContiguousCache::setCapacity(qsizetype size)

Stellt die Kapazität des Caches auf den angegebenen Wert „ size “ ein. Ein Cache kann eine Anzahl von Elementen aufnehmen, die seiner Kapazität entspricht. Beim Einfügen, Anhängen oder Voranstellen von Elementen in den Cache wird – sofern der Cache bereits voll ist – das Element entfernt, das am weitesten vom hinzugefügten Element entfernt ist.

Ist der angegebene Wert ` size ` kleiner als die aktuelle Anzahl der Elemente im Cache, bleiben nur die letzten ` size ` Elemente im Cache erhalten.

Siehe auch „ capacity()“ und „ isFull()“.

qsizetype QContiguousCache::size() const

Gibt die Anzahl der im Cache enthaltenen Elemente zurück.

Siehe auch ` capacity()`.

[noexcept] void QContiguousCache::swap(QContiguousCache<T> &other)

Tauscht diesen Cache gegen other aus. Dieser Vorgang ist sehr schnell und schlägt niemals fehl.

T QContiguousCache::takeFirst()

Entfernt das erste Element aus dem Cache und gibt es zurück. Diese Funktion setzt voraus, dass der Cache nicht leer ist.

Wenn Sie den Rückgabewert nicht verwenden, ist ` removeFirst()` effizienter.

Siehe auch ` takeLast()` und ` removeFirst()`.

T QContiguousCache::takeLast()

Entfernt das letzte Element aus dem Cache und gibt es zurück. Diese Funktion setzt voraus, dass der Cache nicht leer ist.

Wenn Sie den Rückgabewert nicht verwenden, ist ` removeLast()` effizienter.

Siehe auch ` takeFirst()` und ` removeLast()`.

bool QContiguousCache::operator!=(const QContiguousCache<T> &other) const

Gibt „ true “ zurück, wenn „ other “ nicht mit diesem Cache übereinstimmt; andernfalls wird „ false “ zurückgegeben.

Zwei Caches gelten als gleich, wenn sie an denselben Indizes dieselben Werte enthalten. Diese Funktion setzt voraus, dass der Werttyp die Schnittstelle ` operator==()` implementiert.

Siehe auch ` operator==()`.

[noexcept] QContiguousCache<T> &QContiguousCache::operator=(QContiguousCache<T> &&other)

Weist „ other “ dieser „ QContiguousCache “-Instanz zu.

QContiguousCache<T> &QContiguousCache::operator=(const QContiguousCache<T> &other)

Weist diesem Cache „ other “ zu und gibt eine Referenz auf diesen Cache zurück.

bool QContiguousCache::operator==(const QContiguousCache<T> &other) const

Gibt „ true “ zurück, wenn „ other “ mit diesem Cache übereinstimmt; andernfalls wird „ false “ zurückgegeben.

Zwei Caches gelten als gleich, wenn sie an denselben Indizes dieselben Werte enthalten. Diese Funktion setzt voraus, dass der Werttyp die Schnittstelle ` operator==()` implementiert.

Siehe auch ` operator!=()`.

T &QContiguousCache::operator[](qsizetype i)

Gibt das Element an der Indexposition i als veränderbare Referenz zurück. Wenn der Cache kein Element an der angegebenen Indexposition i enthält, wird zunächst ein leeres Element an dieser Position eingefügt.

In den meisten Fällen ist es besser, entweder ` at()` oder ` insert()` zu verwenden.

Siehe auch „ insert()“ und „ at()“.

const T &QContiguousCache::operator[](qsizetype i) const

Genau wie unter (i).