Template:

 

·        Templates sind Codevorlagen, die beispielsweise für eine Gruppe von Funktionen eingesetzt werden, die sich nur in den Typbezeichnern unterscheiden.

 

·        Mit  erzwungener Template-typisierung können Variablen unterschiedlicher Typen miteinander verglichen werden. Dadurch wird dafür gesorgt, dass beim Aufruf die jeweils richtige Funktion erzeugt wird.

 

·        Durch eine Template-Definition wird nicht nur eine einzelne Funktion, sondern gleich ein ganzer Satz von Funktionen definiert. Für jeden Aufruf im Programm erzeugt der Compiler die zugehörige Fkt-Instanz mit dem richtigen Parametertyp.

 

·        Bei der Verwendung von Templates können für einzelne Datentypen auch spezielle Funktionen definiert werden. Sie haben dann Vorrang vor den Templates, d.h, wenn der Compiler bereits eine geeignete Fkt findet, erzeugt er keine weitere Funktion mehr, an Hand der Templatedefinition.

 

·        Mit Hilfe von template können sowohl Fkt als auch Klassen in Abhängigkeit von einem noch festzulegenden Typ konstruiert werden.

 

·        Templates sind Werkzeuge, mit denen die Erstellung von Programmcode automatisiert werden kann.

 

·        Template legt die Anweisung einer Fkt oder die Definition einer Klasse fest, wobei statt eines konkreten Typs ein formaler Parameter eingesetzt wird. Erst bei der Instanzierung, d.h bei der Festlegung des Konkreten Typs wird eine einzelne Klasse anhand des Templates erzeugt.

 

·        Vorteile:

 

·        Template muss für mehrere Datentypen nur einmal codiert werden.

 

·        Template bietet eine einheitliche Lösung für gleichartige Probleme.

 

·        Fehler durch mehrfache Kodierung werden vermieden.

 

 

Die Methoden eines Klassen-Templates sind über den noch festzulegenden Typ parametrisiert. Jede Methode eines Klassen-Templates ist ein Funktions-Template.

 

Die Definition von Methoden eines Klassen-Templates wird normalerweise in der selben Header-Datei vorgenommen. Damit ist sichergestellt, dass der Compiler die Definition „sieht“, aus der er den Maschinencode für konkrete Template-Argumente erzeugt.

 

Syntax:

-         Template< class T> class meine_klasse {…;};

-         Template< class T> meine_klasse <T> ::methode ( ) {…;}

 

 

Container (begriffe):  -Kapazität (zur Kompilierzeit).

                                    -Grösse (zur Laufzeit).

                                    -Index

 

Syntax:   template < class T > T meinefkt ( T  einarg ) {  }

 

 

 

Polymorphie  

Templates

Flexibilität

Deklaration der Klasse

Deklaration der Klasse

 

Aufruf meine_variable im Code

-

 

 

Methoden-Implementierung bei Spezialisierung des formalen T-Parameters.

 

Allgemein:      template < class T, int n > void Klasse < T, n> :: fkt ( ) { }

Spezial:           void Klasse < char, 5> :: fkt ( ) { }

 

 

Algorithmus / Datenstruktur

            (Template)

Wirklichkeit

(Polymorphie)

Werkzeuge für Programmierer

Werkzeuge für Anwender

Komponenten-Entwicklung

Anwendungs-Entwicklung

 

 

 

 

 

Container:

 

·        Templates, die eine Datenstruktur abbilden und folglich als Daten-Element Klassen enthalten können.

·        Klasse, die DS  modelliert.

·        Datenstrukturen sind auch zyklische Strukturen, Listen, Netze, Heap, Stack,

  1. bringt bestimmte Elemente zusammen.
  2. Inhalt wird auf eine bestimmte Art und Weise erfasst.

 

Globale Fkt für Algorithmen /Management sind Template-Fkt, in denen es formale Parameter, Container-Elemente und Container gibt.

 

Datenstruktur

Zugriff

Management

Container

Iteratoren

Algorithmen

 

Container: Basisklasse

 

Public:-management

            -iteratoren

 

iterator-fkt:

·         Haben gemeinsame Schnittstelle für Elementzugriff.

·          Sind meistens Fkt mit Rückgabewert (geben Zeiger zurück).

·         Bringen gleiches Resultat für alle DS, auch wenn der Prozess je nach Datentyp unterschiedlich ist.

·         Sind eingebettete Container.

 

 

iteratoren:

 

·         lineare DS.

·         assoziative DS.

 

2 Vorteile:

 

·         Für den Menschen.

·         Algorithmen haben einen einheitlichen Input. Die Zugriffe sind standardisiert.

 

 

Container

Linear (sequentielle)

Assoziative

·                    vector

·                    list

·                    deque

·                    (1)sortieren sich automatisch:

·                    set /multiset      //(nach sich selbst)

·                    map /multimap //(nach Schlüssel(Element key; Objekt))

·                    (2) direkter Zugriff.

·                    (3)einfügen / löschen.

 

Iteratoren

Vordefinierte

Selbstdefinierte

·        Begin ( ): das erste Element

·        rbegin( ) : das letzte Element (reverse beginn)

·        end ( )    : Zeiger auf das Element hinter dem letzten Element

·        rend( )   : das Element vor dem ersten Element (reverse ende)

 

 

Gültigkeit der Zeigerarithmetik: Operatoren ++ / --

 

1. Element:            Notenliste.begin ( ) -> 1

2. Element        ( Notenliste.begin ( ) ) ++

 

 

 

 

Deklaration einer selbstdefinierten Iteratorvariablen ohne Initialisierung:

Typ:   List<int>::iterator

 

       (Datentyp)             (Variablentyp)

Instanzierte_Klasse::iterator beste_Note ;

 

Zugriff mit Zuweisung:

*(Notenliste.beste_Note) = Notenliste.begin ( );

 

Deklaration eines selbstdefinierten Iterators mit Initialisierung:

Instanzierte_Klasse::iterator beste_Note = Notenliste.begin ( ) ;

 

 

 

Iteratoren:

 

            für unterschiedliche Container eine Einheitliche Basis zum positionieren.

 

Arten von Iterationen

 

Random-Access-Iteratoren

Bidirektionale

Index : vektor/ deque.

Sortierschlüssel.

 

Bidirektionale + zusätzlich wahlfreier positionieren.

Z.b: vector<T>, deque<T>;

positionieren [ -> (++) , <- (--)  ]

zugreifen auf Objekte

(lesen oder schreiben).

 

…für alle container.

Maps + multimaps:

 

Textfeld: vorbereitungTextfeld: zugriff 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


Beispiel:

 

pos = kursteilnehmer.begin( );

pos = kursteilnehmer.find( );                  //key nicht Objekt

cout<< pos->second;                           //Objekt

 

zusätzliche Möglichkeiten:

count                                                    //aktuelle Anzahl der Objekte im Netz

pos = lower_bound (3);

lowerbound(key)<= key <= upperbound (key)

 

 

#include < deque>

#include < vector >

#include < list >

#include <map >

begin ( )

end ( )

push_front (…)

pop_front (…)

push_back (…)

pop_back (…)

swap (  ,  )

insert (  ,  )

size ( )

capacity ( )

empty ( )

[ ]

begin ( )

end ( )

push_back (…)

pop_back (…)

swap (  ,  )

insert (  ,  )

size ( )

capacity ( )

empty ( )

[ ]

 

begin ( )

end ( )

push_front (…)

pop_front (…)

push_back (…)

pop_back (…)

swap (  ,  )

erase (…)

insert (  ,  )

size ( )

capacity ( )

empty ( )

sort ( )

begin ( )

end ( )

swap (  ,  )

insert (  ,  )

size ( )

max_size ( )

empty ( )

[ ]