Kurs: Effektive Software-Entwicklung mit C++ (http://tutego.de/g/CPP2)
Autor: Boris Schäling

Kapitel 7: Der C++ Standard
...
7.2 Strings. Zeichenketten speichern und verarbeiten
Eine der am häufigsten verwendeten im C++ Standard definierten Klasse...
immer gleiche Ergebnisse liefern, stehen keine Methoden zur Umwandlung von Buchstaben
zur Verfügung.

Neben std::string is...
Zwei Streams kennen Sie bereits aus vielen Beispielen: std::cin ist die Standardeingabe und
std::cout die Standardausgabe....
std::ostream. In diesen beiden Klassen sind auch die verschiedenen Methoden definiert,
die für die formatierte und nicht-f...
Ein wichtiger Bestandteil des C++ Standards sind verschiedene Container, die es einfach
machen, große Datenmengen zu verwa...
int main()
{
  std::list<char> l;
  l.push_back('a');
  l.push_back('b');
  l.push_back('c');

    std::cout << l.front() ...
Alter von Personen zugeordnet werden sollen, kann std::map mit std::string und int
instantiiert werden. In diesem Fall ist...
Die Schleifenkonstruktion, die Sie im obigen Programm sehen, ist typisch: Mit begin() wird
ein Iterator auf das erste Elem...
anwenden möchten, können Sie als Parameter die Iteratoren übergeben, die von begin()
und end() zurückgegeben werden.

#inc...
Mit Hilfe des Algorithmus std::count() kann die Anzahl der Elemente zwischen zwei
Iteratoren gefunden werden, die mit dem ...
Nächste SlideShare
Wird geladen in …5
×

Der C++ Standard

818 Aufrufe

Veröffentlicht am

Veröffentlicht in: Bildung
0 Kommentare
0 Gefällt mir
Statistik
Notizen
  • Als Erste(r) kommentieren

  • Gehören Sie zu den Ersten, denen das gefällt!

Keine Downloads
Aufrufe
Aufrufe insgesamt
818
Auf SlideShare
0
Aus Einbettungen
0
Anzahl an Einbettungen
3
Aktionen
Geteilt
0
Downloads
0
Kommentare
0
Gefällt mir
0
Einbettungen 0
Keine Einbettungen

Keine Notizen für die Folie

Der C++ Standard

  1. 1. Kurs: Effektive Software-Entwicklung mit C++ (http://tutego.de/g/CPP2) Autor: Boris Schäling Kapitel 7: Der C++ Standard Inhaltsverzeichnis • 7.1 Allgemeines • 7.2 Strings • 7.3 Streams • 7.4 Container • 7.5 Iteratoren • 7.6 Algorithmen 7.1 Allgemeines. Standardisierte Werkzeuge auf allen Plattformen In den 90er Jahren wurde die Programmiersprache C++ standardisiert. Ein internationales Gremium arbeitete an einem langen Dokument, in dem festgehalten wurde, wie standardisierter C++-Code auszusehen hat. Die Standardisierung sollte es ermöglichen, C++- Code problemlos mit Compilern verschiedener Hersteller zu übersetzen, und das idealerweise auch auf unterschiedlichen Plattformen. 1998 wurde die erste Version des C++ Standards schließlich verabschiedet und veröffentlicht. Im C++ Standard wurde nicht nur festgelegt, aus welchen Schlüsselwörtern C++ besteht und welche Bedeutung sie haben. Es wurden darüber hinaus Klassen und Funktionen definiert, die von jedem Compilerhersteller, der den C++ Standard unterstützen möchte, zur Verfügung gestellt werden müssen. Das erst macht es möglich, auf Klassen wie std::string zugreifen zu können, ohne sich jeweils Gedanken machen zu müssen, wo diese Klasse genau herkommt und wie sie im Detail aussieht. Der C++ Standard verlangt, dass die Klasse std::string in einer Headerdatei string zur Verfügung gestellt wird und sich so verhält, wie es im C++ Standard definiert ist. Der C++ Standard hat sich soweit durchgesetzt, dass ihn heute kein Compilerhersteller ignorieren kann. Das bedeutet, dass standardisierter C++-Code mit jedem modernen C++- Compiler auf jeder beliebigen Plattform kompiliert werden kann. Dabei kann problemlos auf sämtliche Klassen und Funktionen zugegriffen werden, die im Namensraum std definiert sind. Alle in diesem Namensraum vorhandenen Klassen und Funktionen müssen sich so verhalten, wie es der C++ Standard vorschreibt - egal, mit welchem Compiler und egal, auf welcher Plattform Sie arbeiten. In diesem Kapitel erhalten Sie einen Überblick über verschiedene Bestandteile des C++ Standards. Neben der Klasse std::string und den Streams std::cin und std::cout, die Sie bereits in vielen Beispielen kennengelernt und eingesetzt haben, werden Ihnen Container, Iteratoren und Algorithmen vorgestellt.
  2. 2. 7.2 Strings. Zeichenketten speichern und verarbeiten Eine der am häufigsten verwendeten im C++ Standard definierten Klassen ist std::string. Diese Klasse ist in der Headerdatei string definiert und bietet rund 100 Methoden, um Zeichenketten zu verarbeiten. #include <string> #include <cstdio> int main() { std::string s = "Hello"; s += ", world!"; std::printf("%sn", s.c_str()); std::string::size_type idx = s.find("world"); if (idx != std::string::npos) { s.replace(idx, 5, "moon"); std::printf("%sn", s.c_str()); } } Im obigen Programm werden ein paar Methoden der Klasse std::string beispielhaft verwendet. So wird zuerst die Variable s mit Hilfe eines überladenen Konstruktors mit "Hello" initialisiert und anschließend der überladene Operator += verwendet, um ", world!" an s anzuhängen. Die Methode c_str() gibt einen Zeiger auf einen Puffer zurück, in dem der String mit einem Nullzeichen abgeschlossen ist. Da Strings in C üblicherweise mit einem Nullzeichen abgeschlossen werden, wird diese Methode immer dann verwendet, wenn ein String an eine C-Funktion übergeben werden muss. std::printf() ist eine derartige C-Funktion, der deswegen die Variable s nicht direkt übergeben wird, sondern mit Hilfe von c_str() ein Zeiger auf einen mit einem Nullzeichen abgeschlossenen String. Auf diese Weise kann der String "Hello, world!" mit std::printf() ausgegeben werden. Die Klasse std::string bietet verschiedene Methoden an, um einen String zu durchsuchen. So gibt find() die Position einer gefundenen Zeichenkette im String zurück. Der Datentyp dieser Positionsnummer ist std::string::size_type. Sollte die gesuchte Zeichenkette nicht gefunden werden, gibt find() std::string::npos zurück. Es stehen darüber hinaus Methoden zum Ersetzen und Löschen von Zeichen zur Verfügung. So wird im obigen Beispiel mit replace() das Wort "world" durch "moon" ersetzt. Beachten Sie, dass std::string keine Methoden anbietet, deren Funktionsweise vom sogenannten Kulturkreis abhängt. So gibt es beispielsweise keine Methode, um einen String in Groß- oder Kleinbuchstaben umzuwandeln. Denn welches Zeichen jeweils wie umgewandelt werden müsste, hängt vom Kulturkreis ab. So sind im Deutschen Umlaute wie ä, ö und ü Buchstaben wie alle anderen. Im Englischen aber zählen ä, ö und ü nicht zu den Buchstaben. Das Ergebnis einer Umwandlung in Groß- oder Kleinbuchstaben hängt demnach vom Kulturkreis ab. Da std::string nur Methoden anbietet, die unabhängig vom Kulturkreis
  3. 3. immer gleiche Ergebnisse liefern, stehen keine Methoden zur Umwandlung von Buchstaben zur Verfügung. Neben std::string ist in der Headerdatei string auch eine Klasse std::wstring definiert. Diese Klasse basiert nicht auf dem Datentyp char, sondern auf wchar_t. Der C++ Standard legt die Größe dieses Datentyps nicht fest. Sie können lediglich davon ausgehen, dass ein wchar_t auf 2 oder mehr Bytes basiert und damit größer als ein char ist. Das ermöglicht eine andere Kodierung von Strings. So wird in der Praxis std::wstring üblicherweise eingesetzt, um Unicode-Strings zu speichern. #include <string> #include <cstdio> int main() { std::wstring s = L"Hello"; s += L", world!"; std::printf("%lsn", s.c_str()); std::string::size_type idx = s.find(L"world"); if (idx != std::string::npos) { s.replace(idx, 5, L"moon"); std::printf("%lsn", s.c_str()); } } Obiges Programm verwendet Strings vom Typ std::wstring. Da die Zeichen aller Strings nicht mehr auf einem char, sondern auf einem wchar_t basieren, muss vor Literalen ein L angegeben werden. So muss bei der Initialisierung von s L"Hello" angegeben werden, um dem Compiler zu verstehen zu geben, dass die fünf Zeichen jeweils auf einem wchar_t basieren. Abgesehen von der Kennzeichnung der Literale mit einem L und dem neuen Formatierungssymbol %ls, das zur Ausgabe von auf wchar_t basierenden Strings mit std::printf() verwendet werden muss, gibt es keine Änderungen im Vergleich zum vorherigen Beispiel. Der einzige Unterschied zwischen std::string und std::wstring ist die Kodierung der Strings. 7.3 Streams. Auf dem Flusskonzept basierende Schnittstellen Unter Streams können Sie sich vereinfacht Rohre vorstellen, über die Daten von einer Quelle gelesen oder in ein Ziel geschrieben werden. Die Schnittstelle ist dabei so abstrakt, dass sich die unterschiedlichsten Objekte wie Streams verhalten können. Die Bedingungen, die Streams an eine Quelle oder ein Ziel stellen, sind minimal. Streams erwarten lediglich, dass ein paar Methoden zur Verfügung stehen, mit denen Daten gelesen oder geschrieben werden können.
  4. 4. Zwei Streams kennen Sie bereits aus vielen Beispielen: std::cin ist die Standardeingabe und std::cout die Standardausgabe. Es handelt sich dabei um Objekte, die in jedem C++ Programm automatisch vorhanden sind, wenn iostream eingebunden wird. #include <string> #include <iostream> int main() { std::string s; int i; std::cin >> s >> i; std::cout << i << s; } Über den Operator >> können Daten von std::cin gelesen werden. Um Daten auf std::cout auszugeben, wird auf den Operator << zugegriffen. Man bezeichnet diese Lese- und Schreiboperationen als formatierte Ein- und Ausgabe, da Daten automatisch umgewandelt werden. So wird im obigen Programm bei einer Eingabe automatisch die erste Zeichenkette in s gespeichert und die zweite Zeichenkette in einen Wert vom Typ int umgewandelt, um ihn dann in i zu speichern. Bei der Ausgabe über std::cout geschieht ähnliches. Neben der formatierten Ein- und Ausgabe unterstützen Streams auch nicht-formatierte Lese- und Schreiboperationen. #include <iostream> #include <cstring> int main() { char buffer[32]; std::cin.getline(buffer, sizeof(buffer)); std::cout.write(buffer, std::strlen(buffer)); } Über die Methode getline() kann eine Zeile komplett in einen Puffer geladen werden. Die Methode erkennt das Zeilenende am Enter, das der Anwender eingeben muss, damit der Aufruf von getline() zurückkehrt. Es findet dabei im Gegensatz zur formatierten Dateneingabe keine Interpretation der eingegebenen Zeichen statt - die gesamte Zeile wird in den Puffer kopiert. getline() setzt automatisch ans Ende der gelesenen Zeichen ein Nullzeichen, so dass der String im Puffer zum Beispiel an eine C-Funktion übergeben werden kann. So wie Daten über getline() unformatiert von der Standardeingabe gelesen werden können, können sie mit write() unformatiert auf die Standardausgabe ausgegeben werden. Objekte wie std::cin und std::cout sind prominente, aber nicht die einzigen Streams, die in C+ +-Programmen verwendet werden können. Während diese beiden Objekte automatisch existieren, stellt der C++ Standard zahlreiche Stream-Klassen zur Verfügung, die von Ihnen instantiiert werden können. Dabei wird grundsätzlich zwischen Ein- und Ausgabestreams unterschieden. Eingabestreams sind von std::istream abgeleitet, Ausgabestreams von
  5. 5. std::ostream. In diesen beiden Klassen sind auch die verschiedenen Methoden definiert, die für die formatierte und nicht-formatierte Ein- und Ausgabe von Daten verwendet werden können. Weil alle Streams von mindestens einer der beiden Klassen abgeleitet sind, besitzen sie alle die gleiche Schnittstelle. Der C++ Standard bietet zum Beispiel zwei Klassen std::istringstream und std::ostringstream an, die in der Headerdatei sstream definiert sind. Diese Klassen verwenden als Quelle bzw. Ziel einen String vom Typ std::string. Mit Hilfe dieser beiden Klassen können Daten von einem String so gelesen und in einen String so geschrieben werden wie Sie es von std::cin und std::cout gewohnt sind. #include <string> #include <sstream> #include <iostream> int main() { std::string input = "abc 10"; std::istringstream is(input); std::ostringstream os; std::string s; int i; is >> s >> i; os << i << s; std::cout << os.str() << std::endl; } Im obigen Programm wird ein Eingabestream is vom Typ std::istringstream mit dem String input initialisiert. Der Stream is verwendet demnach den String input als Quelle. Es werden dann mit Hilfe des Operators >> Daten formatiert gelesen - zuerst ein String, dann eine Zahl. Diese Daten werden in den Variablen s und i entgegen genommen. Im nächsten Schritt werden die Daten in s und i in umgekehrter Reihenfolge in den Stream os geschrieben. Dieser Stream ist ein Ausgabestream vom Typ std::ostringstream. Alle Daten, die in einen derartigen Stream geschrieben werden, werden intern in einer Variablen vom Typ std::string gespeichert. Die Methode str() gibt diesen internen String zurück. Im obigen Programm wird str() verwendet, um den String zur Kontrolle auf die Standardausgabe auszugeben. Der C++ Standard stellt weitere Stream-Klassen zur Verfügung wie beispielsweise std::ifstream und std::ofstream, die in der Headerdatei fstream definiert sind. Diese Klassen können verwendet werden, um Daten aus Dateien zu lesen bzw. in Dateien zu schreiben. Es existiert außerdem eine Klasse std::fstream, die sowohl von std::istream als auch von std::ostream abgeleitet ist und somit Lese- und Schreiboperationen unterstützt. 7.4 Container. Gruppieren von Daten
  6. 6. Ein wichtiger Bestandteil des C++ Standards sind verschiedene Container, die es einfach machen, große Datenmengen zu verwalten. Für größtmögliche Flexibilität sind alle Containerklassen als Templates definiert, so dass sie Daten beliebigen Typs speichern können. So existiert beispielsweise eine Klasse std::vector, die sich grundsätzlich wie ein Array verhält. Der Vorteil dieser Klasse ist jedoch, dass die Größe von Vektoren im Gegensatz zu Arrays dynamisch ist und Elemente beliebig hinzugefügt und entfernt werden können. #include <vector> #include <iostream> int main() { std::vector<char> v; v.push_back('a'); v.push_back('b'); v.push_back('c'); std::cout << v[0] << std::endl; std::cout << v.at(2) << std::endl; std::cout.write(&v[0], v.size()) << std::endl; } Im obigen Programm wird ein Vektor v verwendet, der Elemente vom Typ char speichern kann. Um den Vektor mit drei Buchstaben zu füllen, wird auf die Methode push_back() zugegriffen. Um auf ein Element an einer bestimmten Position im Vektor zuzugreifen, kann entweder der überladene Operator [] oder die Methode at() verwendet werden. Der Unterschied ist: at() überprüft, ob der übergebene Index gültig ist und wirft im Fehlerfall eine Ausnahme vom Typ std::out_of_range. Der Operator [] hingegen überprüft wie bei herkömlichen Arrays nicht, ob der Index innerhalb der gültigen Bandbreite liegt. Vektoren garantieren, dass Elemente direkt hintereinander im Speicher liegen - so wie Sie es von herkömlichen Arrays kennen. Deswegen können wie im obigen Programm geschehen mit Hilfe der Methode write() die Elemente im Vektor als Zeichenkette "abc" auf die Standardausgabe ausgegeben werden. Die Anzahl der Elemente im Vektor wird über die Methode size() ermittelt. Da Vektoren garantieren, dass Elemente direkt hintereinander im Speicher liegen, kann das Hinzufügen eines neuen Elements mit push_back() dazu führen, dass ein Vektor einen neuen Speicherbereich reservieren muss, der für die aktuell gespeicherten Daten und das neu hinzugefügte Elemente groß genug ist. Das bedeutet, dass momentan im Vektor gespeicherte Daten in einen neuen Speicherbereich kopiert werden müssen. Wenn es für Ihr Programm wichtig ist, dass Daten schnell hinzugefügt werden können, ohne das bereits gespeicherte Daten intern an eine andere Position kopiert werden müssen, bietet sich die Liste an. Die entsprechende Klasse heißt std::list und ist in der Headerdatei list definiert. #include <list> #include <iostream>
  7. 7. int main() { std::list<char> l; l.push_back('a'); l.push_back('b'); l.push_back('c'); std::cout << l.front() << std::endl; std::cout << l.back() << std::endl; std::cout << l.size() << std::endl; } Der entscheidende Unterschied zwischen einer Liste und einem Vektor ist, dass in einer Liste ein Element mit Hilfe eines Zeigers auf das nächste Element zeigt, während bei einem Vektor alle Elemente direkt hintereinander in einem Speicherbereich liegen. Weil in einer Liste Elemente über Zeiger gekoppelt sind, kann das Hinzufügen eines neuen Elements nicht dazu führen, dass die Liste bereits gespeicherte Daten verschieben muss. Da Entwickler in unterschiedlichen Situationen unterschiedliche Container benötigen, bietet der C++ Standard entsprechend verschiedene Klassen an, aus denen gewählt werden kann. Während der Zugriff auf ein beliebiges Element in einem Array und in einem Vektor über Zeigerarithmetik sehr schnell vonstatten geht, muss sich eine Liste anhand der Zeiger über die Elemente entlang hangeln. Deswegen bietet std::list keinen überladenen Operator [] und keine Methode at() an. Sie müssen sich also selbst anhand der Zeiger vorhangeln, um zu einem Element an einer bestimmten Position in der Liste zu kommen. Mit front() und back() stehen aber zwei Methoden zur Verfügung, um direkt auf das erste und letzte Element in einer Liste zugreifen zu können. Neben std::vector und std::list bietet der C++ Standard weitere Container wie std::deque, std::queue und std::set an. Alle Container sind auf bestimmte Datenstrukturen und Algorithmen zur Verwaltung von Daten spezialisiert, so dass Entwickler den für ihre Situation jeweils besten Container wählen können. Neben den bisher kennengelernten Containern, die einfach nur Gruppen von Daten speichern, gibt es einen Container, in dem jeweils zwei Daten eineinander zugeordnet sind. #include <string> #include <map> #include <utility> #include <iostream> int main() { std::map<std::string, int> m; m.insert(std::make_pair("Anton", 35)); m.insert(std::make_pair("Boris", 31)); m.insert(std::make_pair("Caesar", 40)); std::cout << m["Boris"] << std::endl; } Die Klasse std::map ist ein Template, das zwei Parameter erwartet - nämlich die Typen der Daten, die eineinander zugeordnet werden sollen. Wenn wie im obigen Beispiel Name und
  8. 8. Alter von Personen zugeordnet werden sollen, kann std::map mit std::string und int instantiiert werden. In diesem Fall ist der String der Schlüssel und die Zahl der dem Schlüssel zugeordnete Wert. Container vom Typ std::map sortieren Daten anhand der Schlüssel. Dank dieser automatischen Sortierung ist es möglich, Werte über Schlüssel sehr schnell zu finden. So wird im obigen Programm mit Hilfe des überladenen Operators [] nach dem Schlüssel "Boris" gesucht und der dem Schlüssel zugeordnete Wert 31 auf die Standardausgabe ausgegeben. std::map bietet zwar einen Operator [] an. Das heißt aber nicht, dass Daten intern ähnlich wie bei Arrays oder Vektoren gemeinsam in einem Speicherbereich liegen. Im Gegensatz zu Arrays und Vektoren garantieren Container vom Typ std::map noch nicht einmal, dass Daten intern genau in der Reihenfolge gespeichert werden, in der sie dem Container mit insert() hinzugefügt wurden. Damit Container vom Typ std::map Schlüssel schnell finden können, müssen sie Daten sortieren. Sie sollten demnach std::map nicht verwenden, wenn Ihnen die Reihenfolge der Daten, die Sie im Container speichern, wichtig ist und die Reihenfolge unverändert bleiben muss. 7.5 Iteratoren. Zeiger auf Elemente in Containern Alle Container bieten zwei Methoden begin() und end() an, die sogenannte Iteratoren zurückgeben. Es handelt sich dabei um Objekte, mit denen über Elemente in einem Container iteriert werden kann. Der von begin() zurückgegebene Iterator zeigt dabei auf das erste Element, der von end() zurückgegebene Iterator auf die Position hinter dem letzten gültigen Element in einem Container. Iteratoren sind daher etwas ähnliches wie Zeiger. Sie bieten tatsächlich einen überladenen Operator * an, so dass wie bei Zeigern über das Sternchen auf ein Element zugegriffen werden kann, auf das ein Iterator verweist. #include <list> #include <iostream> int main() { std::list<char> l; l.push_back('a'); l.push_back('b'); l.push_back('c'); for (std::list<char>::iterator it = l.begin(); it != l.end(); ++it) std::cout << *it << std::endl; } Im obigen Beispiel wird auf die Liste zugegriffen, die bereits in einem Beispiel im vorherigen Abschnitt verwendet wurde. Mit Hilfe der Iteratoren wird nun über die einzelnen Elemente in der Liste iteriert, um dann über das Sternchen auf das jeweilige Element zuzugreifen und es auf die Standardausgabe auszugeben.
  9. 9. Die Schleifenkonstruktion, die Sie im obigen Programm sehen, ist typisch: Mit begin() wird ein Iterator auf das erste Element des Containers erhalten. Bevor über diesen Iterator versucht werden darf, auf ein Element im Container zuzugreifen, wird überprüft, ob er ungleich dem Iterator ist, der von end() zurückgegeben wird. Nach jedem Schleifendurchgang wird der Iterator mit ++ inkrementiert, um ein Element im Container vorzurücken. Der Datentyp des Iterators hängt mit dem Datentyp des Containers zusammen, über dessen Elemente der Iterator laufen soll. Alle Container definieren dazu einen Typ iterator, so dass es nicht notwendig ist, sich neue Klassennamen zu merken. Mit Hilfe der Iteratoren ist es nun möglich, auf jedes beliebige Element in einem Container zuzugreifen. Wenn Sie beispielsweise das zweite Element der Liste ausgeben möchten, können Sie das wie folgt machen. #include <list> #include <utility> #include <iostream> int main() { std::list<char> l; l.push_back('a'); l.push_back('b'); l.push_back('c'); std::list<char>::iterator it = l.begin(); std::advance(it, 1); std::cout << *it << std::endl; } In der Headerdatei utility ist eine Funktion std::advance() definiert, mit der ein Iterator um eine bestimmte Anzahl an Stellen vor- oder zurückgesetzt werden kann. Im obigen Beispiel wird der Iterator, der auf das erste Element im Container zeigt, um eine Stelle vorgerückt und zeigt somit auf das zweite Element im Container. Genausogut hätte in diesem Fall der Iterator natürlich auch mit ++ inkrementiert werden können. Für größere Sprünge ist std::advance() jedoch hilfreich. Der eigentliche Grund, warum es Iteratoren gibt, liegt in ihrer Eigenschaft als Bindeglied zwischen Containern und Algorithmen. So stehen im C++ Standard zahlreiche Algorithmen zur Verfügung, mit denen Daten in Containern verarbeitet werden können. Diese Algorithmen erwarten jedoch als Parameter keine Container, sondern Iteratoren. Auf diese Weise können Algorithmen auf bestimmte Elemente in Containern angewandt werden und müssen nicht sämtliche Elemente in einem Container verarbeiten. 7.6 Algorithmen. Mit Elementen in Containern arbeiten Der C++ Standard definiert gut 60 Algorithmen in der Headerdatei algorithm. Es handelt sich dabei um freistehende Funktionen, die mindestens zwei Iteratoren als Parameter erwarten: Ein Iterator, der auf den Anfang einer Sequenz von Elementen zeigt, und einer, der dahinter zeigt. Wenn Sie einen Algorithmus auf alle Elemente in einem Container
  10. 10. anwenden möchten, können Sie als Parameter die Iteratoren übergeben, die von begin() und end() zurückgegeben werden. #include <list> #include <algorithm> #include <iostream> int main() { std::list<char> l; l.push_back('a'); l.push_back('b'); l.push_back('c'); std::reverse(l.begin(), l.end()); for (std::list<char>::iterator it = l.begin(); it != l.end(); ++it) std::cout << *it << std::endl; } Im obigen Beispiel wird der Algorithmus std::reverse() verwendet, der die Reihenfolge der Elemente zwischen den beiden Iteratoren, die als Parameter übergeben werden, umdreht. #include <list> #include <algorithm> #include <iostream> int main() { std::list<char> l; l.push_back('a'); l.push_back('b'); l.push_back('c'); std::list<char>::iterator it = l.begin(); std::advance(it, 1); std::rotate(l.begin(), it, l.end()); for (std::list<char>::iterator it = l.begin(); it != l.end(); ++it) std::cout << *it << std::endl; } Der Algorithmus std::rotate() ist eine Funktion, die als Parameter drei Iteratoren erwartet. std::rotate() rotiert die Elemente, auf die die Iteratoren zeigen, im Kreis. Der mittlere Iterator bestimmt dabei das Element, das nach der Rotation das erste Element sein soll. #include <list> #include <algorithm> #include <iostream> int main() { std::list<char> l; l.push_back('a'); l.push_back('b'); l.push_back('c'); std::cout << std::count(l.begin(), l.end(), 'c') << std::endl; }
  11. 11. Mit Hilfe des Algorithmus std::count() kann die Anzahl der Elemente zwischen zwei Iteratoren gefunden werden, die mit dem Wert, der als dritter Parameter übergeben wird, identisch sind. Beachten Sie, dass die Iteratoren, die Sie als Parameter an Algorithmen übergeben, immer auf Elemente im gleichen Container verweisen müssen. Es hat unvorhersehbare Folgen und kann zu einem Absturz führen, wenn Sie Iteratoren übergeben, die auf Elemente in unterschiedlichen Containern verweisen.

×