Programmieren - Standard Template Library (STL)

Transkript

1 Programmieren - Standard Template Library (STL) Reiner Nitsch r.nitsch@fbi.h-da.de

2 Literatur zu STL Ulrich Breymann Designing Components with the C++ STL (2000) ISBN Free download of the revised and improved edition as a PDFfile for non-commercial purposes: David R. Musser, Gillmer J. Derge, Atul Saini. STL Tutorial and Reference Guide: C++ Programming with the Standard Template Library, 2nd Edition (2001) ISBN: Price: ~50$ C++ Standard Template Library (STL) 2

3 Begriffsdefinitionen Behälterklassen (Container) Container sind Objekte, die andere Objekte speichern und verwalten (Einfügen, Lesen, Löschen, Kopieren, Suchen, Sortieren, ) Die Container enthalten i.a. Objekte desselben Typs, wobei die Objekte auch Zeiger sein können. Die STL bietet 2 Container-Kategorien an: Sequenzcontainer Assoziative Container: Die Daten in diesen Containern werden nicht mittels Index adressiert sondern über einen Schlüsselwert beliebigentyps. Beispiel: Deutsch-Englisches Wörterbuch. Die deutschen Wörter bilden den Schlüsselwert zum Auffinden der gespeicherten Daten (=englische Wörter): cout << dict_ge_en["sprache"] << endl; Ausgabe: language Andere Bezeichner für Assoziative Container sind Dictionary (Smalltalk, Python, Objective- C, PostScript, C#), einer Map (C++, Java), Hash (Perl, Ruby) oder einer Hashtable/Hashmap (Java, Windows PowerShell) Gemeinsamkeiten dieser Container Konstruktoren, Destruktor, Methoden für Elementzugriff, Einfüge- und Lösch-Operationen eigene Speicherverwaltung (wachsen, wenn der reservierte Speicher nicht mehr ausreicht) C++ Standard Template Library (STL) 3

4 Grundsätzliches zu Containern Sequentielles Aufsuchen der Elemente eines Containers Sequentiell impliziert, dass eine Reihenfolge definiert und dem Anwender bekannt sein muss. Um die interne Datenstruktur zu verbergen, werden i.a. Iteratoren als Mittel zur Kontrollabstraktion eingesetzt. STL-Iteratoren Sind Objekte, die wie Pointer anzuwenden sind bieten lesenden und schreibenden Zugriff auf den Containerinhalt Können von einem zu einem anderen Containerelement bewegt werden, wobei die Details der Bewegung verborgen bleiben (Kontrollabstraktion) Erlauben die Formulierung von Algorithmen, die Containerinhalte verarbeiten, unabhängig von der jeweiligen Datenrepräsentation (generische Algorithmen) C++ Standard Template Library (STL) 4

5 Grundsätzliches zu Containern Was soll ein Container enthalten? Bei der Wertsemantik legt der Container von allen zum Einfügen übergebenen Nutzdaten jeweils eine Kopie an, und speichert die Kopie. Eine danach erfolgte Änderung der Orginale durch den Aufrufer wirkt sich nicht auf die Kopien im Container aus. Bei der Referenzsemantik werden effektiv nur Referenzen auf die einzufügenden Objekte gespeichert. Eine Änderung der Orginale durch den Aufrufer wirkt sich auch nach dem Einfügen noch auf den Inhalt des Containers aus. Alle STL-Container arbeiten mit Wert-Semantik. Aber auch Referenzsemantik lässt sich darstellen, indem den Containern lediglich Pointer mit den Adressen der Daten übergeben werden C++ Standard Template Library (STL) 5

6 Grundsätzliches zu Containern Wachstum von Behältern Jedes Wachsen bedeutet Anfordern (Allokieren) eines größeren Speicherbereichs, Umkopieren und Löschen des bisherigen Speicherbereichs (Zeitaufwändig) Zugriff auf Container-Elemente Soll ein Container beim Lesen seiner Elemente vom Typ T Referenzen (T&) zurückgeben? Kein Kopieraufwand. Missbrauch möglich: Ändern des Werts eines Elements in einem sortierten Container über die Referenz. Bei dynamisch wachsenden Containern können Referenzen und Iteratoren ungültig werden, wenn die Elemente automatisch in einen größeren zusammenhängenden Speicherbereich umkopiert werden. Container, die Referenzen/Zeiger zurück geben, sollten ihre Elemente im Hauptspeicher möglichst nicht verschieben müssen, also auch nicht wachsen müssen C++ Standard Template Library (STL) 6

7 Standard Template Library (STL) Components Overview Die C++ STL enthält mehrere typparametrisierte Container Klassen vector<t>, Header <vector> deque<t>, Header <deque> list<t>, Header <list> set<t>, Header <set> map<key,t>, Header <map> Diese Container verwenden die Wert-Semantik, d.h. sie kopieren intern die einzufügenden Elemente anstatt nur eine Referenz darauf abzuspeichern. Die C++ STL enthält mehrere typparametrisierte Algorithmen (ca. 70 verschiedene ) im Header <algorithm>, die hinsichtlich Laufzeiteffizienz optimiert sind. Die STL definiert mehrere Funktionsobjekte im Header <functional>, um verschiedene Algorithmen an unterschiedliche Aufgabenstellungen anzupassen. Container (vector) InputIterator Algorithm OutputIterator Container (map) Container (list) InputIterator C++ Standard Template Library (STL) 7

8 Container - Übersicht Container unordered_multiset unordered_set unordered_multimap unordered_map Sequenz-Container Sequenz-Adapter Assoziative Container array vector deque list neu: forward_list (einfach verkettet) stack queue priority queue set Menge von Unikaten multiset auch Duplikate Keys multimap 3 map Data Siehe auch: C++ Standard Template Library (STL) 8

9 Alle STL-Container: Anforderungen an die Objekte Die Objekte (Elemente) eines Containers müssen kopierbar (copy-constructable) sein und die erzeugte Kopie muss den gleichen 'Wert' wie das Original besitzen. Dieses Fähigkeit erhalten Objekte durch den Kopier- Konstruktor. class Any {... // Private Daten public: // Kopierkonstruktor Any(const Any& src);... }; Die Objekte müssen zuweisbar (assignable) sein. Hierzu muss die Klasse den Zuweisungsoperator definieren, wenn die Standard-Variante nicht ausreicht. Die Objekte müssen zerstörbar (destructable) sein. Container entfernen ihre Elemente durch den impliziten Aufruf des Element-Destruktors. Aber: Wenn der Container Pointer speichert, wird auch nur der von diesen belegte Speicherplatz freigegeben. Die Destruktoren der referenzierten Objekte muss also das Kompositum aufrufen, dessen Komponente der Container. Alle diese Operationen werden implizit durch den Compiler für jede Klasse generiert. Man muss diese Operationen also nur für nicht-triviale Klassen (solche, die z.b. dynamische Daten oder andere Objekte enthalten) selbst implementieren. class Any {... // Private Daten public: // Überladener = Operator Any & operator=(const Any &rhs);... }; class Any {... // Private Daten public: // Destruktor ~ Any();... }; C++ Standard Template Library (STL) 9

10 Alle STL-Container: Anforderungen an die Objekte Einige Algorithmen funktionieren nur, wenn die Objekte den operator== implementieren. Beispiel: std::find. Algorithmen und Container mit Sortierfunktionen setzen den operator< voraus. Weitergehende Anforderungen bezüglich Vergleichsoperatoren werden STL-intern durch eine Kombination der Operatoren == und < erfüllt. Beispiele: x>=y das Gleiche wie!(x<y) und x>y das Gleiche wie y<x und x!=y das Gleiche wie!(x==y) class Any {... // Private Daten public: // Implementierung == Operator bool operator==(const Any& rhs) const;... }; class Any {... // Private Daten public: // Implementierung < Operator bool operator<(const Any& rhs) const;... }; C++ Standard Template Library (STL) 10

11 Musterklasse Any (wird in Beispielen verwendet) class Any { int* pa; public: Any( int i=0 ) { pa = new int(i); } Any( const Any& a ) { pa = new int(*a.pa); } ~Any() { delete pa; } int get() const { return *pa; } Any& operator= ( const Any& a ) { this->pa = a->pa; return *this; } bool operator== ( const Any& a ) const { return this->pa == a->pa); } bool operator< ( const Any& a ) const { return this->pa < a->pa; } }; ostream& operator<< ( ostream& os, const Any& a ) { os << a.get(); return os; } C++ Standard Template Library (STL) 11

12 Alle STL Container bieten Iteratoren Container-Klasse: X (z.b. list<int> für X) first Container-Elemente last X::iterator begin() --iter iter ++iter end() X::reverse_iterator rend() ++riter riter --riter rbegin() Alle STL-Container stellen Iteratoren zur Verfügung, die sich bezüglich einer Inkrementierung unterschiedlich verhalten: X::iterator: Normaler Iterator, mit dem beim Inkrementieren ein Container von vorne nach hinten traversiert werden kann. X::reverse_iterator: Ein Iterator, mit dem durch Inkrementieren ein Container von hinten nach vorne traversiert werden kann; in STL implementiert als Adapterklasse der normalen Iteratoren C++ Standard Template Library (STL) 12

13 Read-only Iterator Typen Iteratoren können vom Typ read-write-access und read-only-access sein. Der read-write Iterator-Typ iterator liefert bei der Dereferenzierung eine Referenz auf das Element-Objekt (T&), die auch schreibenden Zugriff erlaubt. Der read-only Iterator-Typ const_iterator liefert bei der Dereferenzierung lediglich eine const-referenz (const T&) ohne Schreibzugriff auf das Objekt vector<konto> kto; vector<konto>::iterator iter = kto.begin(); iter->stand = iter->stand + 100; vector<konto>::const_iterator const_iter = kto.begin(); double betrag = const_iter->stand; const_iter->stand = 100; const_iter++; Alle STL-Container definieren sowohl die read-write-access als auch die read-only-access Iteratorvariante. // "stand" muss hier public sein. Container darf nicht leer sein! OK, weil nur lesender Zugriff Fehler, weil schreibender Zugriff über const_iterator OK! const bedeutet nicht, daß der Iterator selbst nicht verändert werden darf, sondern nur das Element auf das er zeigt! Achtung: keine Bereichs-Kontrolle für Iteratoren Hinweis: MS Visual C++2005ff weicht hier vom Standard ab und bietet sogenannte "Checked Iterators": Programmabbruch zur Laufzeit, wenn Iterator nicht im zulässigen More on this:visual C Hijacks the C++ Standard Bereich. Gleiches gilt auch für den []-Operator C++ Standard Template Library (STL) 13

14 Alle STL Container: Gemeinsame Typ-Definitionen Typ-Definitionen X::value_type X::reference X::const_reference X::pointer X::const_pointer X::iterator X::const_iterator Typ der Werte im Container (i.a: T bei Sequenzcontainer, Key bei std::set und pair<key,t> bei std::map) entspricht X::value_type& entspricht const X::value_type& entspricht X::value_type* entspricht const X::value_type* Kontrollabstraktion zum traversieren des Containers in Vorwärtsrichtung wie X::iterator aber nur lesender Zugriff auf ElementWerte X::reverse_iterator X::const_reverse_iterator wiex::iterator aber Rückwärtsrichtung X::difference_type kann Abstand zweier Iteratoren darstellen X::size_type kann Größe eines Containers darstellen. Die Container stellen mittels typedef-anweisungen mehrere Datentypen zur Verfügung. Durch Verwendung dieser Typ-Bezeichner in Anwendungen bzw. Algorithmen werden diese vom tatsächlichen, aktuellen Datentyp der Container weitgehend unabhängig. Werden zu einem späteren Zeitpunkt, anstelle von Any-Objekten, Objekte vom Typ Konto im Container abgelegt, so ändert sich damit auch der Datentyp der Variablen A1::value_type ist dann ein Alias für den Datentyp Konto. Konstruktoren X() X(a); X b(a); a.~x() Standard-Konstruktor; erzeugt leeren Container Copy-Konstruktor Destruktor Legende C++ Standard Template Library (STL) 14 X a,b r ist eine Container-Klasse für Objekte vom Typ T sind Variablen/Objekte vom Typ X ist eine Referenz-Variable/-Objekt vom Typ X& // Typ des Vektors typedef vector<any> AnyVect; // Vektor definieren AnyVect v; // v füllen // Variable definieren deren Datentyp mit dem // Datentyp der Vektor-Elemente überein stimmt Any A1 = v[0]; vector<any>::value_type A1= v[0]; AnyVect::value_type A1= v[0]; Äquivalente Anweisungen! // Erzeugt einen leeren Container list<any> anylist; // Dupliziert einen Container list<any> mylist(anylist)

15 Alle STL Container: Gemeinsame Methoden iterator X::begin() Gibt Iterator auf das erste Containerelement iterator X::end() Gibt Iterator, der die Ende-Markierung des Containers kennt. reverse_iterator X::rbegin() reverse_iterator X::rend() size_type size() bool empty() a==b, a!=b a<b a>b a<=b a>=b r=a a.swap(b) Gibt reverse-iterator zurück, der das Anfangselement für umgekehrtes Traversieren kennt. Gibt reverse-iterator, der die Ende-Markierung für reverses Traversieren kennt. gibt aktuelle Anzahl Elemente im Container liefert true, wenn Container leer ist true bei elementweiser (Un)Gleichheit; benutzt X::value_type::operator== vergleicht 2 Container lexikografisch; benutzt X::value_type::operator< returns true, wenn b<a returns true wenn!(b<a) returns true, wenn!(a<b) Zuweisungsoperator für Container Vertauschen der Inhalte 2er Container gleichen Typs (konstante Komplexität O(1)!). // Any-Vektor definieren AnyVect v; // hier Any-Vektor füllen AnyVect::iterator iter; // Kompl. Container ausgeben for ( iter = v.begin(); iter!= v.end(); ++iter ) cout << *iter << endl; // Any-Vektor definieren AnyVect v; // hier Any-Vektor füllen // Anzahl der Elemente ausgeben cout << v.size() << endl; // Test ob Vektor Elemente enthält if( v.empty() ) cout << "Keine Elemente im Vektor!\n"; // Any-Vektor definieren AnyVect anyv1, anyv2;... // Container-Inhalte vergleichen if( anyv1 == anyv2 ) cout << "Container enthalten die" " gleichen Elemente!\n"; // Vergleich auf kleiner als // Any-Vektor definieren AnyVect anyv1, anyv2; // Container füllen // Container-Inhalte vertauschen (konstante Komplexität) anyv1.swap( anyv2 ); // Container zuweisen if( anyv1 < anyv2 ) anyv = anyv1; C++ Standard Template Library cout (STL) << "anyv1 ist kleiner anyv2 \n"; 15

16 STL Sequenzcontainer vector<t> deque<t> list<t> bietet wahlfreien Zugriff auf Objektsequenzen ( O(1) ) variabler Länge mit schellem Einfügen und Löschen am Ende der Sequenz wie vector, aber schnelles Einfügen und Löschen am Anfang und Ende der Sequenz kein wahlfreier sondern linearer Zugriff ( O(N) ) auf eine Sequenz variabler Länge (hier N) aber schnelle Einfüge- und Löschoperationen an beliebiger Stelle ( O(1) ) Container vector<t> Element- Zugriff Einfügen / Löschen Beginn Mitte Ende O(1) O(N) O(N) O(1) deque<t> O(1) O(1) O(N) O(1) list<t> O(N) O(1) O(1) O(1) T a[n] O(1) O(N) O(N) O(1) Iterator Typ-Definitionen vector<t>::iterator vector<t>::const_iterator deque<t>::iterator deque<t>::const_iterator list<t>::iterator list<t>::const_iterator T* const T* Iterator-Kategorie mutable random access constant random access mutable random access constant random access mutable bidirectional constant bidirectional mutable random access constant random access C++ Standard Template Library (STL) 16

17 Alle Sequenz-Container: Zusätzliche Konstruktoren Konstruktoren: X(); X a; Standard-Konstruktor X(n); X a(n); Initialisiert Container mit n Kopien vom Typ T Für Typ T muss der Standard-Konstruktor definiert sein! X(n,t); X a(n,t) Erzeugen eine Sequenz mit n Kopien von t. X(i,j); X a(i,j) Erzeugen eine Sequenz mit gleichem Inhalt wie der Range [i,j) Legende X ist eine Container-Klasse für Objekte vom Typ T a ist eine Variable vom Typ X i,j Input-Iteratoren und [i,j) ist ein gültiger Bereich n Variable vom Typ X::size_type p gültiger Iterator für a q, q1, q2 gültige dereferenzierbare Iteratoren für a und [q1,q2) ist ein gültiger Bereich t Variable vom Typ X::value_type Jeder Sequenz-Container kann auf die fünf rechts dargestellten Arten definiert werden. Diese Definitionen gelten generell auch für die Container deque und list. #include <vector> using std::vector; class Any { /* */ }; // Leeren Vektor definieren vector<any> vect1; // Vektor mit 5 Elementen definieren vector<any> vect2(5); // Vektor aus 5 Objekten mit Wert Any(10) erzeugen vector<any> vect3(5, Any(10)); // Any-Feld definieren/initialisieren Any array[4] = { Any(1),Any(2),Any(3),Any(4) } // Vektor mit Feldinhalt initialisieren vector<any> vect4( &array[0], &array[4] ); vector<any> vect5( vect3.begin(), vect3.end() ); C++ Standard Template Library (STL) 17

18 Alle Sequenz-Container: Zusätzliche Methoden Einfügeoperationen: iterator X::insert(p,t) Fügt eine Kopie von t vor p ein. Gibt Iterator auf eingefügten Wert zurück void X::insert(p,n,t) Fügt n Kopien von t vor p ein. void X::insert(p,i,j) Fügt Kopien der Elemente im Range [i,j) eines anderen Containers vor p ein. void X::push_back(t) Fügt eine Kopie von t am Ende ein void X::assign(i,j) Entspricht { clear(); insert( begin(), i, j); } void X::assign(n,t) Entspricht { clear(); insert( begin(), n, t ); } Elementzugriff: reference X::front() reference X::back() Löschoperationen: iterator X::erase(q) Gibt Referenz auf 1.Element Gibt Referenz auf letztes Element Beide Rückgaben sind undefiniert, wenn der Container leer ist! Löscht das Element, auf das q verweist. Der Ergebnis-Iterator verweist auf das Element hinter q oder a.end(), wenn das letzte Element gelöscht wurde. iterator X::erase(q1,q2) Löscht alle Elemente im Bereich [q1,q2). Der Ergebnis-Iterator verweist auf das Element hinter q2 oder a.end(), wenn das letzte Element gelöscht wurde. void X::pop_back() void X::clear() void X::resize(n,t) // Vektor definieren typedef vector<any> AnyVect; AnyVect v, v1; // Den Wert Any(i) einf. iter = v.end(); for( int i=4; i>0; --i ) iter = v.insert( iter, Any(i) ); // Den Wert Any() vor der 1. Position einf. v.insert( v.begin(), Any() ); // 2x den Wert Any(5) vor der 6. Position einf. v.insert( v.begin()+5, 2, Any(5) ); // Feld definieren Any array[] = { Any(6), Any(7), Any(8) }; // Any-Feld am Ende einfuegen v.insert(v.end(),&array[0],&array[3]); // Existierenden Vektor löschen und aus aus array neu befüllen v1.assign( array, &array[3] ); // Erstes Element auslesen AnyVect::value_type var = v.front(); // Letztes Element auslesen cout << var << ' ' << v.back(); 0 8 // 2. Element entfernen v: cout << *v.erase(v.begin()+1); 2 // Letzte 4 Elemente entfernen v: v.erase( v.end()-4, v.end() ); Löscht letztes Element Löscht alle Elemente im Container // Letztes Element entfernen v: v.pop_back(); Löscht alle Elemente am Ende oder füllt v: //Containergröße verändern am Ende mit Kopien der Objekte t auf bis v.resize( 6, Any(7) ); v: size() == n. Eine Reduzierung des allokierten Speichers wird dadurch nicht // Alle Elemente entfernen erzwungen. v.clear(); C++ Standard Template Library (STL) 18

19 Container vector und deque : Direkter Elementzugriff Elementzugriff: = a[n] lesender Direktzugriff ohne Indexüberprüfung a[n]= schreibender Direktzugriff ohne Indexüberprüfung = a.at(n) lesender Direktzugriff mit Indexüberprüfung a.at(n)= schreibender Direktzugriff mit Indexüberprüfung; throw( std::out_of_range ) Der Zugriff auf die einzelnen Elemente eines Vektor/Deque-Containers kann, wie bei Feldern üblich, mit dem Indexoperator [] erfolgen. Es findet keine Indexüberprüfung statt. Über die Memberfunktion at(..) kann lesend/schreibend mit Indexprüfung ( 0<= index <=size() ) auf die Elemente zugegriffen werden. Bei Indexfehlern wird eine out_of_range Exception ausgeworfen. Bei list Objekten ist der []-operator nicht implementiert, da der Zugriffsaufwand mit O(N) zu ineffizient ist. // Indizierter Elementzugriff Any var = v[3]; // lesend v[4] = var; // schreibend // Abgesicherter Elementzugriff // kann out_of_range Exception auslösen var = v.at(15); // Fehler v.at(0) = var; Hinweis: MS Visual C weicht hier vom Standard ab und bietet sogenannte "Checked Iterators": Programmabbruch zur Laufzeit, wenn Iterator nicht im zulässigen Bereich. Gleiches gilt auch für den []- Operator. Mehr dazu hier: C++ Standard Template Library (STL) 19

20 Container deque und list : Zusätzliche Methoden zum Einfügen von Elementen Einfügen und Löschen von Elementen: void X::push_front(t) Fügt Objekt t am Listenanfang ein void X::pop_front() Entfernt erstes Objekt im Container Elemente können zusätzlich über die Memberfunktion void push_front(t) am Beginn von list- und deque-containern eingefügt werden. Das erste Element von list- und deque- Containern kann zusätzlich über die Memberfunktion void pop_front() entfernt werden. Beide Methoden sind beim vector- Container nicht definiert, weil Einfüge- und Löschoperationen am Beginn dieses Containers sehr ineffizient sind (O(N))! // Vektor definieren list<any> mylist; //Objekt Any(1) am Anfang einfügen mylist.push_front( Any(1) ); // Erstes Listenelement entfernen mylist.pop_front(); C++ Standard Template Library (STL) 20

21 Zusätzliche Methoden für list-container Return type method Meaning void merge(list&) void merge(list&,compare_object) void push_front(const T& t) void pop_front() void remove(const T& t) void remove_if(predicate pred) void reverse() void sort() Merges two sorted lists, using T::operator<(const T&) (time complexity O(n)). Merges two sorted lists, using a Compare_object for the comparison of elements (O(n)). Inserts an element at the beginning. Deletes the first element. Removes all elements that are equal to the passed element t (O(n)). Removes all elements to which the predicate applies (O(n)). Reverses the order of elements in the list (O(n)). Sorts the elements in the list. Time complexity is O(~N log N). The sorting criterion is the T::operator<(const T&) defined for the elements. Remark: Stable void sort(compare_object) as sort(), but with the sorting criterion of the comparison function object. void splice(iterator p,list&x, iterator i) Inserts element *i of x before p and removes *i from x. void splice(iterator pos, list& x, Inserts elements in the range [first, last) of x before pos and removes them from x. Calling the iterator first, iterator last) same object (that is, &x == this), takes constant time, otherwise, the cost is of the order O(n). pos must not lie in the range [first, last). void splice(iterator pos, list& x) Inserts the contents of list x before pos. Afterwards, x is empty. void unique() Deletes identical consecutive elements except for the first one (cost O(n)). Application to a sorted list leads to the effect that no element occurs more than once. void unique(binarypredicate) Ditto, only that instead of the identity criterion another binary predicate is used C++ Standard Template Library (STL) 21

22 Container vector : Größenmanagement Memberfunktion vector::capacity() ermittelt Maximalgröße, bis zu der der Vektor- Container erweitert werden kann, ohne dass hierfür neuer Speicherplatz angefordert werden muss. Memberfunktion vector::reserve(n) legt die Größe des allokierten Speicherplatzes fest. Ein Größenreduzierung kann mit reserve(n) nicht erzwungen werden. Sie sind deshalb so interessant, weil nach einer Anforderung von neuem Speicherplatz für einen Vektor-Container alle Element- Referenzen und -Zeiger sowie Iteratoren ungültig werden. Für die Container list und deque sind capacity() und reserve() nicht definiert. // Feld definieren/initialisieren int array[] = {1,2,3,4,5}; // Vektor mit Feldinhalt initialisieren vector<any> v3(&array[0],&array[5]); // Kenndaten des Vektors ausgeben cout << v3.size() << ',' << v3.capacity() << endl; 5, 5 // Vektor vergroessern v3.reserve(20); // Erneut Kenndaten ausgeben cout << v3.size() << ',' << v3.capacity() << endl; 5, C++ Standard Template Library (STL) 22

23 Sortierte Assoziative Container der STL Speichern die Daten intern in einer Baumstruktur Elementzugriff O(log 2 N) Das mathematische Konzept einer Relation oder eine diskrete Abbildung wird mit map realisiert, das einer Menge mit set multimap und multiset erlauben mehrfache identische Schlüssel Erklärung siehe STL-Algorithmen Container Zugriff Einfügen / Löschen Beginn Mitte Ende set<t> O(log N) O(1) O(1) O(1) multiset<t> O(log N) O(1) O(1) O(1) map<key,t> O(log N) O(1) O(1) O(1) multimap<key,t> O(log N) O(1) O(1) O(1) Iterator set<t>::iterator set<t>::const_iterator multiset<t>::iterator multiset<t>::const_iterator map<key,t>::iterator map<key,t>::const_iterator multimap<key,t>::const_iterator multimap<key,t>::const_iterator Iterator-Kategorie constant bidirectional 1) constant bidirectional constant bidirectional 1) constant bidirectional mutable bidirectional constant bidirectional mutable bidirectional constant bidirectional 1) Microsoft Visual C++ weicht hier vom Standard ab und realisiert "mutable bidirectional" Iteratoren C++ Standard Template Library (STL) 25

24 Assoziativer Container map map speichert Elemente, die aus einem Schlüsselwert "key" und assoziierten Daten "mapped" bestehen. Die Schlüsselwerte sind eindeutig, d.h. es gibt keine 2 Datensätze mit gleichem Schlüsselwert (keine Duplikate). Der Zugriff auf die assoziierten Daten erfolgt über den Schlüsselwert, anstatt über ihre absolute (Index) oder relative (front, back) Position im Container. Eine sortierte Anordnung der Schlüsselwerte ist für den Zugriff nicht erforderlich, reduziert aber den Zugriff auf die Komplexität O(logN) Schlüsselwerte und assoziierte Daten werden vom map-container gemeinsam in Objekten vom Typ std::pair<const Key, T> aufbewahrt. Die Konstanz des Schlüssels gewährleistet, dass er nach dem Einfügen nicht mehr verändert werden kann. Dies würde die Sortierung zerstören. Deklaration der Klasse in der STL template< class Key, class T, class Compare = std::less<key> > class map { /* */ }; key_type MatrikelNr Name Location mapped_type // Typ von key // Typ von mapped // Typ des Sortierers // (Key::operator< ist voreingestellt) Sudent TelNr Node Beispiele assoziierter Daten im map-element Anwendungsbeispiele folgen C++ Standard Template Library (STL) 26

25 1. Beispiel - Wörterbuch void main(void) { map<string,string> dictionary; Map_Demo_Anwendung // Leeres Wörterbuch erzeugen dictionary.insert(pair<string,string>("baum","tree")); dictionary.insert(pair<string,string>("auto","car")); cout << dictionary["baum"] << endl; // Element aufnehmen // noch ein Element // Assoziativer Zugriff tree } map<string,string>::iterator iter = dictionary.begin(); for( ; iter!=dictionary.end(); ++iter ) cout << (*iter).first << ' ' << iter->second << endl; Voreingestellt ist, dass der Operator < die interne Reihenfolge der Elemente in map- bzw- set-containern bestimmt. Falls das unerwünscht ist, muss ein anderes geeignetes Kriterium angeboten werden: Beispiel: // Sortierte Ausgabe Auto car Baum tree class Compare { public: bool operator()(const string& s1, const string& s2) const { return s2<s1; } }; void main(void) { Comp compare; // Sortierte Ausgabe map<string,string,compare> dictionary(compare); Buch book // weiter wie oben Auto car } C++ Standard Template Library (STL) 27

26 Container map und multimap : Übersicht und Typdefinitionen Typdefinitionen map definiert folgende öffentlichen Datentypen key_type mapped_type value_type pointer reference X::key_compare Fortsetzung des Beispiels: Typ Key der Schlüsselwerte Typ T der zugeordneten Werte Typ der gespeicherten Werte, pair<const Key,T> entspricht pair<const Key,T>* entspricht pair<const Key,T>& Typ des Funktionsobjekts Compare, das die Sortierreihenfolge der Schlüssel festlegt Weitere Typen wie Sequenz-Container void main(void) { // wie bisher cout << dictionary.size(); 2 typedef map<string,string,compare> Map Map::key_type key = "Ei"; // Typ ist string cout << dictionary[key]; cout << dictionary.size(); 3 dictionary[key] = "egg"; Map::mapped_type translation; // Typ ist string translation = dictionary[key]; cout << word; egg } typedef dient hier der Abkürzung map-element Key // Schreibender Zugriff auf assoziierte Daten T value_type Typ pair<key,t> key_type mapped_type Achtung: Ist die Suche nach dem Schlüssel erfolglos, wird ein neues map-element für diesen Schlüssel angelegt. Die assoziierten Daten werden mit dem Standardkonstruktor T() erzeugt (hier: string() ). Weitere Informationen zum Einfügen, Suchen und Löschen von Daten finden Sie hier: Breymann: C++. S. 756ff C++ Standard Template Library (STL) 28

27 1. Beispiel - Duplikate void main(void) { // wie bisher (siehe vorherige Seite) cout << dictionary.size(); 3 dictionary.insert(pair<string,string>("auto","vehicle")); cout << dictionary.size(); 3 Wie kann man dieses Verhalten zuverlässig kontrollieren? Deklaration von map::insert: // Versuch Duplikat einzufügen: // Schlüsselwert "Auto" gibt es schon // Duplikat wurde nicht gespeichert! pair<iterator,bool> insert( const value_type& x ); map::insert liefert einen return-value vom Typ std::pair. 1. Member pair::first: Iterator, der auf das neu eingefügte Element oder das Duplikat zeigt 2. Member pair::second: Ist false, wenn der Schlüsselwert bereits enthalten ist, sonst true. } typedef Map::iterator Iterator; std::pair<iterator,bool> result; // 2. Versuch result = dictionary.insert(map::value_type("auto","vehicle")); cout << result.second << endl; false // Duplikat wurde nicht gespeichert! cout << *(result.first) << endl; Auto car C++ Standard Template Library (STL) 29

28 2. Beispiel: Ein Telefonbuch mit class map typedef map<string,long> PhoneMap; string ist der key_type und long ist der mapped_type typedef PhoneMap::value_type MapElement; MapElement entspricht jetzt pair<string,long> void main() { PhoneMap directory; directory.insert(mapelement("iredviel",732457)); directory["haumich"] = ; directory[ DuBiDumm"] = ; directory.insert(mapelement("iredviel",732458)); } directory["iredviel"] = ; // immer noch kein 2. Telefon. Überschreibt 1. Nummer PhoneMap::const_iter iter = directory.begin(); const_iter weil read-only Zugriff ausreicht for( ; iter!=directory.end(); ++iter) cout << (*iter).first << ' ' << iter->second << ' '; // Sortierte Ausgabe: DuBiDumm HauMich IRedViel // Suchen im Telefonbuch string name = "Bin Laden"; // Suchen mit operator[ ]: // O( logn ) long number = directory[name]; // number = 0; Achtung: Suchfehler gibt es hier nicht!! Für "BinLaden" iter = directory.find(name); if( iter!=directory.end() ) cout << (*iter).second; // O( 1 ) else cout << name << " hat kein Telefon!" << endl; directory.erase(iter); // Leereintrag "BinLaden" wieder löschen typedef dient hier wieder der Abkürzung // Einfügen mit operator[ ] und insert: // 2. Telefon; wird nicht ausgeführt, weil Schlüssel // schon existiert // existiert jetzt ein Eintrag. // Suchen mit Iterator und find // O( logn ) // Prüfen, ob Iterator dereferenzierbar ist iterator find(k) liefert Iterator auf gefundenen Eintrag oder "past-theend" Iterator wenn nicht gefunden void erase(iter) löscht einzelnes Element an Position iter C++ Standard Template Library (STL) 30

29 Sortierter Assoziativer Container multimap Unterschiede zu map Elemente mit identischem Schlüssel (Duplikate) dürfen mehrfach vorkommen. Die assoziierten Daten dürfen sich dabei durchaus unterscheiden Beispiel: mehrere Telefonnummern unter gleichem Namen Es gibt keinen Indexoperator T& operator[ ](const key_type& k) C++ Standard Template Library (STL) 31

30 Sortierter Assoziativer Container set entspricht der Klasse map, mit dem Unterschied, dass nur Schlüsselwerte gespeichert werden (Elemente = Schlüsselwerte) set speichert wie map keine Duplikate set hat keinen Indexoperator -> Einfügen nur mit insert(key) void main(void) { set<string> names; names.insert("ichschonwieder"); names.insert( IbinSchlau"); names.insert( DuBiDumm"); set<string>::iterator iter = names.begin(); for( ; iter!=names.end(); ++iter ) cout << *iter << endl; names.insert("ichschonwieder"); pair<setiter,bool> success; success = names.insert("ichschonwieder"); if(success.second==true) cout << *(success.first) << " eingefuegt"; else cout << "Duplikat"; } // Einfügen mit insert // Sortierte Ausgabe DuBiDumm IbinSchlau IchSchonWieder // Duplikat nicht eingefügt. Wie erkennt man erfolgreiches Einfügen? pair<iterator,bool> insert(key) Duplikat C++ Standard Template Library (STL) 32

31 Container set : Übersicht und Typdefinitionen Deklaration der Klasse in der STL template< class Key class Compare = std::less<key> > class set { /* */ }; // Typ der Schlüssel // Typ des Sortierers // (Key::operator< ist voreingestellt) Definition eines leerenset-containers: set<konto> myset; Typdefinitionen set definiert folgende öffentlichen Datentypen key_type value_type pointer reference key_compare Weitere Informationen: Typ Key der Schlüsselwerte auch Typ Key, im Gegensatz zu map entspricht Key* entspricht Key& Typ Compare. Funktionsobjekt, das die Sortierreihenfolge der Schlüssel festlegt Weitere Typen wie Sequenz-Container set-element Key value_type key_type Weitere Informationen zum Einfügen, Suchen und Löschen von Daten finden Sie hier: Breymann: C++. S C++ Standard Template Library (STL) 33