003-Folien: Standard Template Library und Templates

Templates und STL
VL MRT-2, SS 2013
Professur für Prozessleittechnik

Übersicht
• Neugestaltung des endlichen Zustandsautomaten mit
Containern der Standard Template Library (statt Arrays)
• C++ Konzepte:
– Konzepte der Standard Template Library
– Eigene Templates erzeugen
– Spezialisierung von Templates
– Boost
• Entwurfsmuster:
– Container und Iteratoren
24.04.2013 MRT2 (c) 2013, UR Folie 2

Standard Template Library (STL)
• Ziele der STL:
– Hohe Wiederverwendung von Datenstrukturen und typsicherer
Algorithmen auf diesen Datenstrukturen
• Problem:
– Es gibt unendlich viele Datentypen (Classes)
– Es gibt erstaunlich viele Möglichkeiten Sammlungen von Daten
anzulegen (Collections)
– Es gibt eine immense Vielfalt von Dingen die wir mit den Daten
tun wollen (Algorithmen)
TU Dresden, 21.04.13 MRT2 2006-2011 (c) UR Folie 3

Beispiele für Algorithmen auf Sammlungen
• Sortiere die Einträge eines Wörterbuchs
• Suche die Telefonnummer zu einem Namen
• Finde den höchsten Temperaturmesswert der vergangenen
10 Jahre
• Finde alle Werte > 8000
• Finde die erste Instanz mit einem Wert von 17
• Finde den ersten Unterschied in zwei Sequenzen
• Berechne das paarweise Produkt der Elemente zweier
Sequenzen
• Berechne die Summe der Elemente
• ...
TU Dresden, 21.04.13 MRT2 2006-2011 (c) UR Folie 4

Grundlegende Konzepte der STL
• Container: Objekte zur Verwaltung anderer Objekte
– abgelegt als Wert (Wertsemantik) oder als Referenz
– formuliert als Template-Klassen
– Algorithmennamen (werden zur Compilezeit ausgewertet) sind für
gleichartige Operationen, aber unterschiedliche Container gleich.
Beispiel: Die Methode size() gibt die Anzahl der Elemente eines
Containers zurück, sei er nun vom Typ vector,list oder map).
• Iteratoren: Zugriff auf Containerelement über Iteratoren
– sind normale Zeiger oder zeigerähnliche Objekte
– können sich von einem zum nächsten Element weiterbewegen, Methode
bleibt aber verborgen
– Beispiel: in einem Vektor: ++ das einfache Weiterschalten zur nächsten
Position im Speicher; in einem binären Suchbaum: ++ Entlangwandern
im Baum)
• Algorithmen: arbeiten mit Iteratoren, die auf Container zugreifen
– Allgemeinheit des Entwurfs, arbeiten auch mit normalen Zeigern
TU Dresden, 21.04.13 MRT2 2006-2011 (c) UR Folie 5

Wir nutzen in dem Automaten bereits
Container und Iterator
• Zeichenketten sind Containertemplates
string f("--0002*30+-+1234=");
• Klassisch: Iteration über C-String mit Zeiger (C):
for (const char* cp = f.c_str(); *cp != 0; ++cp) { c =
*cp; a.run(); }
• STL-Iterator: Iteration über Container mit Iterator (C++):
for (string::iterator it=f.begin(); it != f.end();
++it) { c = *it; a.run(); }
• Ab C++ C11: Iteration über Range
for (const char cf : f) { c = cf; a.run(); }
24.04.2013 MRT2 (c) 2013, UR Folie 6

Wichtige Klassen der STL
• Sequenz-Container:
– : basic_string, string, wstring - Zeichenketten
– : deque – Liste mit zwei Enden
• schnelles Anfügen von Elementen, kein wahlfreier Zugriff
– : list
• schnelles Anfügen von Elementen, kein wahlfreier Zugriff
– : vector
• schnelles Anfügen nur am Ende, wahlfreier Zugriff
• Assoziative Container
– : map, multimap
• Paare von Schlüsseln. Einfügen, Löschen, Suchen O(log(N))
– : set, multiset
• Schlüssel. Komplexität wie map
24.04.2013 MRT2 (c) 2013, UR Folie 7

Sequenz
• Jede STL-Sammlung ist eine Sequenz
– Eine Sequenz hat ein Anfang und ein Ende
– Es gibt eine Möglichkeit vom Anfang zum Ende zu kommen
– Anfang und Ende sind jeweils durch einen Iterator festgelegt.
• Ein Iterator ist ein Objekt, das ein Element einer Sequenz
identifiziert
begin: end:
...
TU Dresden, 21.04.13 MRT2 2006-2011 (c) UR Folie 8

Iterator
• Ein Iterator „zeigt“ auf ein Element einer Sammlung (oder
das nach dem letzten)
• Iteratoren können verglichen werden (==)
• Durch dreferenzieren bekommt man das Element, auf das
der Iterator zeigt (*)
• Der Iterator kann auf das nächste Element der Sammlung
vorwärts bewegt werden (++)
TU Dresden, 21.04.13 MRT2 2006-2011 (c) UR Folie 9

Iteratoren verbinden
• Iteratoren verbinden Datenstrukturen mit Algorithmen
sort, find, search, copy, ...
Iterator
vector, list, map, array, ..., meinContainer
TU Dresden, 21.04.13 MRT2 2006-2011 (c) UR Folie 10

Automaton: TransitionTable als Container
der STL
• Anforderungen an die TransitionTable
– Elemente: Zeiger auf konstante Transition-Objekte
– Neue Elemente: am Ende anfügen
– Durchsuchen: linear von Anfang bis Ende
• list ist ein geeigneter Container
für Zeiger auf unveränderliche Objekte
vom Typ Transition:
#include
class Automaton {
list tt;
Automaton(const State& startState);
void add(const Transition& t);
...
< Parameter >:
Liste, deren
Elemente Zeiger auf
unveränderliche
Transitionsobjekte
sind
Referenz auf ein
unveränderliches
Tranisitionsobjekt
24.04.2013 MRT2 (c) 2013, UR Folie 11

Automaton: TransitionTable
• Modifikation Automaton.h
#include
class Automaton {
list tt;
Automaton(const State& startState);
void add(const Transition& t);
• Modifikation Implementierung
Automaton::add(const Transition& t) {
tt.push_back(&t); }
Automaton::run() { // [...]
for (const Transition* pt : tt) {
if ( &(pt->start) == pCurrentState ) {
Referenz wird wie
Variable behandelt,
deshalb Adresse
bestimmen
push_back: Element
an Container
anhängen
Über alle Elemente
der Liste
24.04.2013 MRT2 (c) 2013, UR Folie 12

STL: Übersicht Container-Methoden
TU Dresden, 21.04.13 MRT2 2006-2011 (c) UR Folie 13

Initialisierung TransitionTable
• Objektinitialisierung
Automaton a(s0);
a.add(Transition(s0, s0, guardPlus));
a.add(Transition(s0, s1, guardMinus, behavior_lOp_Sign));
a.add(Transition(s0, s2, guardDigit, behavior_lOp_Digit));
a.add(Transition(s1, s0, guardMinus, behavior_lOp_Sign));
a.add(Transition(s1, s2, guardDigit, behavior_lOp_Digit));
a.add(Transition(s2, s2, guardDigit, behavior_lOp_Digit));
a.add(Transition(s2, s3, guardOp, behavior_Op1));
// ...
24.04.2013 MRT2 (c) 2013, UR Folie 14

C++: Templates - Motivation
• Für alle Typen, für die die Relation < definiert ist, kann eine
min bzw. max-Funktion spezifiziert werden.
• Das ist mit Überladen von Funktionen in C++ grundsätzlich
lösbar:
string& min(string& a, string& b) {
return (a < b) ? a : b;
}
double& min(double& a, double& b) {
}
return (a < b) ? a : b;
• u.s.w für alle Datentypen, für die bool T& operator

C++: Funktionstemplates
string& min(string& a,
string& b)
{
}
return (a < b) ? a : b;
double& min(double& a,
double& b)
{
return (a < b) ? a : b;
}
• Funktionstemplate =
typunabhängige Formel
• Aus der Formel erzeugt der
Compiler typspezifische
Versionen (wenn benötigt)!
template
T& min(T& a, T& b)
{
}
Parameterliste des
Templates
return (a < b) ? a : b;
TU Dresden, 21.04.13 MRT2 2006-2011 (c) UR Folie 16

C++: Templateparameterliste (1/2)
• Zur Erinnerung: Funktionsparameterliste
– Definiert lokale Variablen eines bestimmten Typs
– Variablen werden nicht initialisiert
– Belegung zur Laufzeit bei Aufruf
• Templateparameterliste
– Liefert Typen oder Werte, die bei der Definition der Funktion
oder Klasse verwendet werden können:
template T& min(T& a, T& b);
– Die Verwendung im Programm bestimmt, welcher Typ mit T
gemeint ist.
TU Dresden, 21.04.13 MRT2 2006-2011 (c) UR Folie 17

C++: Templateparameterliste (2)
• Typparameter
– Repräsentation eines zur Zeit der Programmierung
unbekannten Datentypy
– Eingeleitet durch Schlüsselwort typename oder class
• Nichttypparameter
– Repräsentation eines zur Zeit der Programmierung
unbekannten Werts
– Eingeleitet durch Typspezifizierer, z.B. int, size_t
TU Dresden, 21.04.13 MRT2 2006-2011 (c) UR Folie 18

C++: Regeln für Templateparameter
• Gültigkeitsbereich folgt den normalen Regeln des
Versteckens von Namen
typedef double T;
template
T& min(T& a, T& b)
{
}
T tmp = a;
return (a < b) ? a : b;
Das globale typedef von T als
double wird durch den
Typparameter T versteckt.
• Ein Name der als Templateparameter benutzt wird, darf
innerhalb des Templates nicht für etwas anderes benutzt
werden!
TU Dresden, 21.04.13 MRT2 2006-2011 (c) UR Folie 19

C++: Templatedeklaration
• Templates können wie Klassen oder Funktionen auch nur
deklariert werden
template T &min(T &a, T &b);
• In der Definition muss der Name des Templateparameters
nicht gleich sein!
template U &min(U &a, U &b) { /**/ };
TU Dresden, 21.04.13 MRT2 2006-2011 (c) UR Folie 20

Anwendung Automaton
• Problembeschreibung: State und Transition sind
zugeschnitten auf Verhaltensspezifikationen vom Typ
typedef function Behavior;
• Herausforderung: Beschreibung der Klassen als Template,
damit der Compiler typsicheren Code für
Strategiefunktionen erzeugt, beispielsweise zur Übergabe
von const char, int, container, shared memory...
State s0("s0",...);
Automaton a(s0);
TU Dresden, 21.04.13 MRT2 2006-2011 (c) UR Folie 21

Vorbereitung (1/3) CalcAsFSM
• Schritt 1: Die ad-hoc Realisierung des Speichers als globale
Variablen und Funktionen war keine gute Praxis
• Kapseln in Klasse Calc
typedef char const cc;
class Calc {
// rechter Operand - Wert und Vorzeichen
int rOp;
int rSign;
// ...
Das wird später
unser Templateparameter!
void behavior_rOp_Digit(const AutomatonElement& ae, cc& c) {
rOp = rOp * 10 + c - '0';
}
24.04.2013 MRT2 (c) 2013, UR Folie 22

Vorbereitung (2/3) Automaton
• Schritt 2: Verwendung von std::function in Automaton für
die vereinheitlichte Behandlung von Methoden und
Funktionen
• Behavior.h
#include
using namespace std;
Rückgabewert
Argumentliste
// Typdefinition für
typedef std::function Behavior;
void defaultBehavior(const AutomatonElement&, const char&);
// default behavior
24.04.2013 MRT2 (c) 2013, UR Folie 23

Vorbereitung (3/3) CalcAsFSM
• Schritt 3: Definition der Strategy durch Binden der
Methoden der Klasse Calc an das Object
calc
#include
using namespace std;
using namespace std::placeholders;
int main() {
// ...
Calc calc();
// ...
State s0("0",
defaultBehavior,
defaultBehavior,
std::bind(&Calc::behavior_logState,&calc,_1,_2);
Binden der Argumente
std::placeholders::_1,
std::placeholders::_2,
std::function auch für
Funktionszeiger
Methode
Instanzreferenz
Argumentliste ermöglicht
Umsortieren, Variablen
24.04.2013 MRT2 (c) 2013, UR Folie 24

Templates für leere Verhaltensfunktionen
(Behavior.h, AutomatonElement.h)
• Template-Typdefinition für Behavior (leider erst ab C++11)
template
using Behavior = std::function<
void(constAutomatonElement&, T&)>;
( Bis dahin jeweils lokal in den Klassen zu definieren)
• Verhaltensspezifikationen für „Nichts Tun“
template
void defaultBehavior(const AutomatonElement& ae, T&
arg) {
#ifdef DEBUG
clog

Klassentemplate für State
(analog für Transition)
template
class State: public AutomatonElement {
typedef std::function Behavior;
private:
Behavior enterFunc;
public:
State(const string& id, Behavior enterFunc =
defaultBehavior, [...]) :
AutomatonElement(id), enterFunc(enterFunc), [...] { }
inline void enter(T& arg) const {
enterFunc(*this, arg);
private:
static const string myType;
}
template
const string State::myType = "state";
Templateparameter
T
Wird bei lokaler
Typdefinition des
Funktionszeigers
eingesetzt!
Nachgestellt:
Direkte
Spezifikation der
Funktion ohne
Argumentliste!
Alle Methoden die
T verwenden!
Implementierungen
müssen auch als
Template formuliert
werden
24.04.2013 MRT2 (c) 2013, UR Folie 26

Klassentemplate für Automaton
template
class Automaton {
private:
State const * pCurrentState;
list< Transition const * > tt;
int currentStateTicks;
bool first;
public:
};
Automaton(State const & startState);
~Automaton();
void add(Transition const & t);
void run(T& arg);
Bei allen betroffene
Datentypen
„durchziehen“
Ein geschachteltes
Template!
24.04.2013 MRT2 (c) 2013, UR Folie 27

Implementierungen (1/3)
template
Automaton::Automaton(State const & startState) :
pCurrentState(&startState), currentStateTicks(0),
first(true) { }
template
void Automaton::add(Transition const & t) {
}
tt.push_back(new Transition(t));
template
Automaton::~Automaton() {
}
for (typename list::iterator it=tt.begin();
it != tt.end(); ++it) delete (*it);
tt.clear(); // eventually clear tt
Implementierungen
sind ebenfalls
Templates
Lege Zeiger auf
eine dynamisch
erzeugte Kopie in
der Sammlung ab
Alles was mit new
angelegt wurde
muss selbst mit
delete aufgeräumt
werden !!!!
24.04.2013 MRT2 (c) 2013, UR Folie 28

Implementierungen (2/3)
template
Automaton::Automaton(State const & startState) :
pCurrentState(&startState), currentStateTicks(0),
first(true) { }
template
void Automaton::add(Transition const & t) {
}
tt.push_back(new Transition(t));
template
Automaton::~Automaton() {
}
for (typename list::iterator it=tt.begin();
it != tt.end(); ++it) delete (*it);
tt.clear(); // eventually clear tt
Hier benötigt der
Compiler unsere
Hilfe: er kann nicht
selbst entscheiden
ob er einen Typ
oder eine Instanz
anlegen soll.
24.04.2013 MRT2 (c) 2013, UR Folie 29