HOWTO · C++
Verwendung von den STL-Warteschlangencontainer in C++
In diesem Artikel wird veranschaulicht, wie Sie den STL-Warteschlangencontainer in C++ verwenden.
Auf dieser Seite
Dieser Leitfaden zeigt, wie Sie mit std::queue Werte in FIFO-Reihenfolge hinzufügen, ansehen und entfernen, die Anzahl der wartenden Werte ermitteln und den Inhalt zweier Warteschlangen austauschen.
Mit std::queue eine FIFO-Warteschlange in C++ deklarieren und verwenden
std::queue ist ein Container-Adapter: Er stellt für einen Sequenzcontainer eine Warteschlangenschnittstelle bereit. FIFO bedeutet „zuerst hinein, zuerst hinaus“: push fügt ein Element hinten an, während front auf das als Nächstes zu verarbeitende Element verweist. Eine Warteschlange stellt absichtlich keine Iteratoren bereit. Daher können Sie weder mit einer Bereichsschleife über sie iterieren noch per Index auf ein Element zugreifen. Als zugrunde liegender Container dient üblicherweise std::deque; std::list ist eine weitere Standardoption. Ein eigener zugrunde liegender Container muss die Anforderungen von SequenceContainer erfüllen und front, back, push_back sowie pop_front bereitstellen.
Führen Sie dieses Beispiel aus:
Der Code und die angezeigten Bezeichnungen oder Ausgaben in diesem Abschnitt bleiben auf Englisch.
#include <deque>
#include <iostream>
#include <queue>
#include <string>
void printQueue(std::queue<std::string> q) {
bool first = true;
while (q.size() > 0) {
if (!first) std::cout << ", ";
std::cout << q.front();
q.pop();
first = false;
}
std::cout << '\n';
}
int main() {
std::queue<std::string> fromPush;
fromPush.push("one");
fromPush.push("two");
fromPush.push("three");
std::deque<std::string> values{"red", "green", "blue"};
std::queue<std::string> fromDeque(values);
std::cout << "from push: ";
printQueue(fromPush);
std::cout << "from deque: ";
printQueue(fromDeque);
}
from push: one, two, three
from deque: red, green, blue
Der Standardkonstruktor erstellt eine leere Warteschlange. Mit push fügen Sie Werte in der Reihenfolge ihres Eintreffens hinzu. Um eine Warteschlange aus einem vorhandenen deque zu erstellen, übergeben Sie diesen deque an den Warteschlangenkonstruktor, wie es fromDeque oben tut. Der Konstruktor kopiert die deque-Elemente in ihrer Reihenfolge in die Warteschlange. Daher stellt jede der beiden Warteschlangen ihr zuerst eingefügtes Element über front() bereit.
Um eine Warteschlange abzuarbeiten, prüfen Sie zuerst, ob sie ein Element enthält. Lesen Sie dann front() aus und rufen Sie pop() auf. Das Beispiel verwendet size() > 0 als Prüfbedingung. front() ohne vorhandenes Element aufzurufen, ist keine sichere Methode, um festzustellen, ob die Verarbeitung fortgesetzt werden kann. Beachten Sie außerdem: pop() entfernt das vorderste Element, gibt es aber nicht zurück. Lesen Sie den Wert daher vor dem Entfernen aus. printQueue übernimmt sein Argument als Wert. Die Funktion verarbeitet also ihre lokale Kopie und lässt die Warteschlange des Aufrufers unverändert. Dafür wird die Warteschlange kopiert, was unnötig sein kann, wenn die Warteschlange des Aufrufers verbraucht werden darf.
Die Größe einer Warteschlange mit size() ermitteln
Rufen Sie size() auf, um die aktuelle Anzahl der Elemente zu erhalten. Das ist nützlich, um ausstehende Arbeit anzugeben oder festzustellen, wie viele Elemente noch verbleiben. Auf die Elemente selbst können Sie damit jedoch nicht zugreifen. Die Anzahl ändert sich nach jedem erfolgreichen Aufruf von push oder pop. Das folgende vollständige Beispiel gibt die Anzahl aus, nachdem drei Werte hinzugefügt wurden:
Der Code und die angezeigten Bezeichnungen oder Ausgaben in diesem Abschnitt bleiben auf Englisch.
#include <iostream>
#include <queue>
int main() {
std::queue<int> tasks;
tasks.push(12);
tasks.push(24);
tasks.push(36);
std::cout << "size = " << tasks.size() << '\n';
}
size = 3
size() gibt eine Anzahl zurück, keine Position oder einen Index. Da die Warteschlange keine Iteratoren bereitstellt, rufen Sie wiederholt front() und pop() auf, wenn Sie die Werte der Reihe nach durchgehen müssen. Prüfen Sie zuerst, ob ein Element verfügbar ist, bevor Sie auf front() zugreifen, falls die Warteschlange leer sein könnte.
Den Inhalt zweier Warteschlangen mit swap() austauschen
Rufen Sie first.swap(second) auf, um die Elemente zweier Warteschlangen auszutauschen. Danach enthält first die Sequenz, die zuvor zu second gehörte, und second die Sequenz, die zuvor zu first gehörte. Beide Warteschlangen müssen denselben Elementtyp und denselben Typ des zugrunde liegenden Containers haben; auch etwaige Allokatorbeschränkungen dieses Containers gelten. Bei diesem Vorgang werden beide Warteschlangen verändert; ihre Sequenzen werden nicht zusammengeführt.
Das Beispiel gibt jede Warteschlange vor und nach dem Austausch aus. Die Hilfsfunktion erhält eine Kopie, damit sie alle Werte anzeigen kann, ohne eine der beiden Warteschlangen zu verändern:
Der Code und die angezeigten Bezeichnungen oder Ausgaben in diesem Abschnitt bleiben auf Englisch.
#include <iostream>
#include <queue>
void printQueue(std::queue<int> q) {
bool first = true;
while (q.size() > 0) {
if (!first) std::cout << ' ';
std::cout << q.front();
q.pop();
first = false;
}
std::cout << '\n';
}
int main() {
std::queue<int> first;
first.push(1);
first.push(2);
std::queue<int> second;
second.push(8);
std::cout << "before first: ";
printQueue(first);
std::cout << "before second: ";
printQueue(second);
first.swap(second);
std::cout << "after first: ";
printQueue(first);
std::cout << "after second: ";
printQueue(second);
}
before first: 1 2
before second: 8
after first: 8
after second: 1 2
Verwenden Sie swap, wenn zwei Warteschlangen ihre ausstehenden Sequenzen tauschen sollen. Wenn Sie eine Warteschlange erhalten möchten, erstellen Sie vor dem Austausch ausdrücklich eine Kopie. Beziehen Sie sich andernfalls nach dem Austausch auf den neuen Inhalt der jeweiligen Warteschlange, statt anzunehmen, dass ihre Namen weiterhin dieselbe Arbeit bezeichnen.