C++ f¨ur Wissenschaftliches Rechnen

(1)

C++ f¨ ur Wissenschaftliches Rechnen

Dan Popovi´c

Interdisziplinäres Institut für Wissenschaftliches Rechnen, Universät Heidelberg

13. Oktober 2009

(2)

C++ f¨ ur Wissenschaftliches Rechnen

1 Warum C++?

Motivation

2 Vorausgesetzte Techniken

3 Das erste Programm

4 Grundlagen C++

Datentypen Kontrollfluss Funktionen

5 Abstrakte Datentypen und ihre Realisierung in C++

Klassen

Konstruktoren und Destruktoren

6 Vererbung in C++

7 Virtuelle Funktionen und abstrakte Basisklassen Virtuelle Funktionen

Rein virtuelle Funktionen und abstrakte Basisklassen

8 Templates und generische Programmierung

9 Die Standard Template Library (STL)

(3)

Warum C++? Motivation

Anforderungen an die Programmiersprache

→ Effizienz. . .

• des Programms

• der Entwicklung

→ Hardware-nahe Programmiersprachen

→ Integration mit existierendem Code

→ Abstraktion

→

(4)

Vergleich von C++ mit anderen Sprachen

Fortran & C

+ schneller Code

+ gute Optimierungen

– nur prozedurale Sprachen

– wenig Flexibilit¨at

– schlechte Wartbarkeit

C++

+ gute Wartbarkeit

+ schneller Code

+ gute Integration mit Fortran und C Bibliotheken

+ hoher Abstraktionsgrad

– schwerer zu optimieren

– meistens mehr Speicherverbrauch

(5)

Vergleich von C++ mit anderen Sprachen

Fortran & C

+ schneller Code

+ gute Optimierungen

– nur prozedurale Sprachen

– wenig Flexibilit¨at

– schlechte Wartbarkeit

C++

+ gute Wartbarkeit

+ schneller Code

+ gute Integration mit Fortran und C Bibliotheken

+ hoher Abstraktionsgrad

– schwerer zu optimieren

– meistens mehr Speicherverbrauch

(6)

Literatur

Literatur zu C++

• B. Stroustrup: C++ – Die Programmiersprache (Die Bibel)

• A. Willms: C++ Programmierung (F¨ur Anf¨anger gut geeignet)

• S. Oualline: Practical C++-Programming

• O’Reilly-Verlag: Scientific C++

(7)

Vorausgesetzte Techniken

Grundlegende vorausgesetzte C++-Kenntnisse

Um die Vorz¨uge von C++ auszunutzen, sind abstrakte Techniken notwendig.

Folgende grundlegenden Konzepte sind als Basis unumg¨anglich:

• Grundlegende Datentypen und Kontrollstrukturen:

• int, double, bool, char, ...

• conditionals:if, switch, ...

• loops:for, while

• Grundlegende Programmstrukturen:

• Funktionen

• Rekursive und iterative Programmierung

• Zeiger und Referenzen

• Klassen und Vererbung

• classundstruct

• private, public, protected

• Konstruktoren und Destruktoren

• public, private-Vererbung

(8)

Das erste Programm

Ein erstes Programm: Hello World

Hallo, Welt!

1 // u s e t h e i o s t r e a m e x t e n s i o n 2 # include < iostream >

3

4 // main i s a l w a y s t h e f i r s t f u n c t i o n t o be c a l l e d 5 int main (int argc , char** argv )

6 {

7 std :: cout << " Hello , World ... " << std :: endl ; 8

9 return 0;

10 }

(9)

Grundlagen C++ Datentypen

Datentypen in C++

Die elementaren Datentypen in C++ sind:

• int: Ganzzahlen,int a = 2;

• char: Zeichen,char a = ’b’;

• float: Gleitkommazahlen 4 Byte,float b = 3.14;

• double: Gleitkommazahlen 8 Byte,double c = 3.1415;

• bool: Wahrheitswerte,bool d = false;

Daneben gibt es eine Vielzahl erweiterter Datentypen und die M¨oglichkeit, beliebige eigene zu definieren.

(10)

Grundlagen C++ Kontrollfluss

Kontrollfluss

if-Verzweigungen:

# include < iostream >

int main (int argc , char** argv ) {

int a = 5;

if ( a < 0) {

std :: cout << " Hello , World ... " << std :: endl ; }

else {

std :: cout << " Hello , World ... " << std :: endl ; }

return 0;

}

(11)

Realisierung von Schleifen

• for-Schleifen,

• while-Schleifen,

• do..while-Schleifen.

for-Schleifen

for (int i =1; i <10; i ++) {

...

}

while-Schleifen

int i = 0;

while (i <10) {

...

(12)

Realisierung von Schleifen

• for-Schleifen,

for-Schleifen

for (int i =1; i <10; i ++) {

...

}

while-Schleifen

int i = 0;

while (i <10) {

...

++ i ;

(13)

Realisierung von Schleifen

• for-Schleifen,

for-Schleifen

for (int i =1; i <10; i ++) {

...

}

while-Schleifen

int i = 0;

while (i <10) {

...

(14)

Grundlagen C++ Funktionen

Funktionen

Funktionen dienen zur Kapselung von Programmabschnitten und k¨onnen bei Bedarf aufgerufen werden.

In C++ haben sie immer die Syntax

R u e c k g a b e t y p F u n k t i o n s n a m e ( Parameter1 , Parameter2 , ..) ;

(15)

Ein Beispielprogramm mit Funktion

# include < iostream >

using n a m e s p a c e std ;

// A f u n c t i o n t h a t g r e e t s e v e r y o n e void greet ()

{

cout << " Hello , World . " << endl ; }

// main f u n c t i o n

greet ();

return 0;

}

(16)

Call-by-Reference und Call-by-Value

Bei Call-by-Value wird die Adresse des Objekts als Funktionsparameter ¨ubergeben und keine Kopie des Objekts erzeugt:

void s w a p _ w r o n g (int a , int b ) {

int tmp = a ;

a = b ; // d o e s n o t work , a and b a r e l o c a l c o p i e s b = tmp ; // i n t h e s c o p e o f t h e f u n c t i o n

}

void s w a p _ r i g h t (int& a , int& b ) {

int tmp = a ; a = b ;

b = tmp ; // t h i s w o r k s }

(17)

Call-by-Reference und Call-by-Value

// main f u n c t i o n

int a =5 , b =6;

// Ausgabe 5 , 6 s w a p _ w r o n g (a , b )

std :: cout << a << " , " << b << std :: endl ; // Ausgabe 6 , 5

s w a p _ r i g h t (a , b )

std :: cout << a << " , " << b << std :: endl ; return 0;

}

(18)

Abstrakte Datentypen und ihre Realisierung in C++ Klassen

Klassen und Datentypen

Eine C++-Klasse definiert einen Datentyp. Ein Datentyp ist eine Zustandsmenge mit Operationen, die die Zustände ineinander überführen. Beispiel:

Beispielklasse

class C o m p l e x N u m b e r s {

public: ...

void print () {

std :: cout << u << " + i * " << v << std :: endl ; }

private: double u , v ; };

(19)

Klassen und Datentypen

// u s a g e o f t h e c o m p l e x number c l a s s int main (int argc , char** argv ) {

C o m p l e x N u m b e r a , b , c ; a . print (); // o u t p u t ?

c = a + b ; // w h e r e d e f i n e d ? return 0;

};

(20)

Klassen und Datentypen

• C++ erm¨oglicht die Kapselung des Datentyps, d.h. Trennung von Implementierung und Interface.

• public: Interface-Spezifikation,

• private: Daten und Implementierung.

• Von außen kann nur auf Methoden und Daten impublic-Teil zugegriffen werden.

• Implementierung der Methoden kann ausserhalb der Klasse geschehen.

(21)

Abstrakte Datentypen und ihre Realisierung in C++ Konstruktoren und Destruktoren

Konstruktoren

• Der BefehlComplexNumber a;veranlasst den Compiler, eine Instanz der Klasse zu erzeugen.

• Zur Initialisierung wird ein Konstruktor aufgerufen.

• Es k¨onnen verschiedene Konstruktoren existieren (Polymorphismus!).

• In gewissen F¨allen erzeugt der Compiler default-Konstruktoren.

(22)

Konstruktoren

Die KlasseComplexNumber mit zwei Konstruktoren:

class C o m p l e x N u m b e r s {

public:

// some c o n s t r u c t o r s

C o m p l e x N u m b e r () { u = 0; v = 0; } // d e f a u l t

C o m p l e x N u m b e r (double re , double im ) // i n i t i a l i z e w i t h

{ u = re ; v = im ; } // g i v e n numbers

void print () { ... } private:

double u , v ; };

(23)

Konstruktoren

// u s a g e o f t h e c o m p l e x number c l a s s int main (int argc , char** argv ) {

C o m p l e x N u m b e r a (3.0 ,4.0);

C o m p l e x N u m b e r b (1.0 ,2.0);

C o m p l e x N u m b e r c ;

a . print (); // o u t p u t : 3 + i ∗ 4 c = a + b ; // w h e r e d e f i n e d ? return 0;

};

(24)

Destruktoren

• Dynamisch erzeugte Objekte k¨onnen vernichtet werden, falls sie nicht mehr ben¨otigt werden.

• Das L¨oschen von Objekten ¨ubernimmt der Destruktor.

• Destruktoren sind insbesondere auszuimplementieren, wenn die Klasse Zeiger (etwa Felder!) enth¨alt.

• Ebenso bei Verwendung von dynamischen Speicher in einer Klasse.

• Stichworte zur Dynamischen Speicherverwaltung:new, delete.

(25)

Vererbung in C++

Vererbung

• bedeutet, dass das Verhalten eines Datentyps an einen abgeleiteten Datentyp weitergegeben werden kann.

• Die Datentypen stehen dabei in

”Ist-ein“ Relation: Ein Mensch ist auch ein S¨augetier, d.h. Klasse Mensch ist von Klasse S¨augetier abzuleiten.

(26)

Vererbung in C++

// e x a m p l e o f i n h e r i t a n c e i n C++

class Matrix { public:

...

private:

double data [3][3]; // ( 3 x 3)−M a t r i x };

// t h e d e r i v e d c l a s s

class S y m M a t r i x : public Matrix { public:

double g e t E n t r y (int i , int j ) { return data [ i ][ j ]; } // e r r o r : d a t a p r i v a t e i n b a s e c l a s s

// p e r f o r m a n c e ? ...

// d e r i v e d c o n s t r u c t o r c a l l s a c o n s t r u c t o r o f b a s e c l a s s S y m M a t r i x () : Matrix () { ... }

};

(27)

Vererbung in C++

Verschiedene Arten der Vererbung in C++

Bei Vererbung ist darauf zu achten, auf welche member die abgeleitete Klasse Zugriff erh¨alt→verschiedene Arten der Vererbung:

• private-Vererbung: Alle Elemente der Basisklasse werden private Member der abgeleiteten Klasse.

• public-Vererbung:public-Member der Basisklasse werdenpublic-Member der abgeleiteten Klasse,privatewird zuprivate.

(28)

Vererbung in C++

Verschiedene Arten der Vererbung in C++

• Private member der Basisklasse bleiben immer privat (sonst macht die Kapselung keinen Sinn).

• Problem:private-Member sind zu stark gekapselt,public-Member ¨uberhaupt nicht.

• Ausweg:protected-Member, auf die abgeleitete Klassen zugreifen k¨onnen.

(29)

Virtuelle Funktionen und abstrakte Basisklassen Virtuelle Funktionen

Virtuelle Funktionen

Klassenhierarchie mit virtuellen Funktionen

class G e o m O b j e c t { // b a s e c l a s s f o r geo o b j e c t s public:

virtual double area () { return 0.0; } ...

};

class T r i a n g l e : public G e o m O b j e c t { // a d e r i v e d c l a s s public:

double area () {

return 0.5 * a * h ; }

...

private: double h , a ; };

(30)

Virtuelle Funktionen

Wof¨ur ben¨otigen wir virtuelle Funktionen?

Virtuelle Funktionen

Wenn Basis- und abgeleitete Klasse enthalten Mitglieder gleichen Namens enthalten – Welche Methode wird aufgerufen?

int main () { G e o m O b j e c t * geo ; T r i a n g l e t ; geo = & t ;

std :: cout << geo - > area << std :: endl ; // ? return 0;

};

(31)

Virtuelle Funktionen

L¨ osung:

• Falls nicht anders angegeben, die Methode des Basisobjekts (!).

• Durch das Schl¨usselwortvirtual wird der Aufruf an die abgeleitete Klasse durchgereicht.

• StichwortLate Binding, d.h. Zuordnung Methodenname ↔ Implementierung erst zur Laufzeit.

(32)

Dynamischer Polymorphismus

Die Technik der sp¨aten Typ-Bindung mit virtuellen Funktionen hat einen eigenen Namen:

Dynamischer Polymorphismus

• Genaue Typbestimmung zur Laufzeit.

• Realisierung ¨uber:

• Virtuelle Funktionen (function lookup table),

• Uberschreiben von Funktionen.¨

(33)

Dynamischer Polymorphismus

Die Technik der sp¨aten Typ-Bindung mit virtuellen Funktionen hat einen eigenen Namen:

Dynamischer Polymorphismus

• Genaue Typbestimmung zur Laufzeit.

• Realisierung ¨uber:

• Virtuelle Funktionen (function lookup table),

• Uberschreiben von Funktionen.¨

Vorteile des dynamischen Polymorphismus

• Basisklassen sind Obermengen der abgeleiteten Klassen

• Algorithmen, die auf Basisklasse operieren, k¨onnen auch auf den abgeleiteten Klassen operieren.

• Beispiel: Liste, die Pointer aufGeomObjects speichert. Pointer kann auf ein

(34)

Virtuelle Funktionen und abstrakte Basisklassen Rein virtuelle Funktionen und abstrakte Basisklassen

Abstrakte Basisklassen und Schnittstellen

Oftmals sind virtuelle Funktionen nicht sinnvoll in der Basisklasse definierbar.

Dann

• Deklararation der Funktion in der Basisklasse als

”rein virtuell“:

virtual printArea() = 0.

• Abgeleitete Klassen m¨ussen rein virtuelle Funktionen implementieren.

(35)

Abstrakte Basisklassen und Schnittstellen

Abstrakte Basisklassen

• Enth¨alt eine Basis-Klasse eine rein virtuelle Funktionen, heisst die Klasse abstrakt.

• Von abstrakten Klassen k¨onnen keine Objekte instanziiert werden.

• Eine abstrakte Basisklasse definiert einheitliches Erscheinungsbild (Interface) einer Abstraktion.

• Algorithmen operieren auf diesem Interface, d.h. unabh¨angig der tats¨achlichen Implementierung.

(36)

Abstrakte Basisklassen und Schnittstellen

Beispiel:

(37)

Abstrakte Basisklassen und Schnittstellen

Beispiel:

-1 0 1 2 3 4 5 6 7

p(x)

Integration mit der Mittelpunktsregel midpoint rule boxes

p(x) = x³-2x+2 p(x) = sin(x)

(38)

Abstrakte Basisklassen und Schnittstellen

Erkl¨ arung des Beispiels:

• Der AlgorithmusMittelpunktsregelintegriert beliebige Funktionen

• Es existiert eine (u.U. abstrakte) Basis-Klasse f¨ur Funktionen

• Allgemeine Funktionen wie Polynome, Sinus, . . . werden von der Basisklasse abgeleitet.

• Mittelpunktsregeloperiert nur auf der Funktionsschnittstelle!

Es folgt der Code zum Beispiel, es wird ein Sinus integriert:

(39)

Abstrakte Basisklassen und Schnittstellen

// main . cpp : T e s t d e r I n t e g r a t i o n m i t d e r F u n k t i o n s−S c h n i t t s t e l l e // System−H e a d e r i n k l u d i e r e n

#i n c l u d e<c s t d l i b>

#i n c l u d e<i o s t r e a m>

#i n c l u d e<cmath>

// e i g e n e H e a d e r i n k l u d i e r e n

#i n c l u d e " sinus . h "

#i n c l u d e " m i t t e l p u n k t s r e g e l . h "

// main−F u n k t i o n

i n t main (i n t a r g c , c h a r∗∗a r g v ) {

// O b j e k t d e r K l a s s e M i t t e l p u n k t s r e g e l a n l e g e n M i t t e l p u n k t s R e g e l m i p u r ( 1 0 0 ) ;

// S i n u s−O b j e k t e r z e u g e n S i n u s s 1 ;

// I n t e g r a t i o n d e r Polynome t e s t e n

s t d : : c o u t<<" I n t e g r a l Sinus : "<<m i p u r . i n t e g r a l A u s w e r t e n ( s1 ,−2 . 0 , 2 . 0 )<<s t d : : e n d l ; s t d : : c o u t<<" I n t e g r a l Sinus : "<<m i p u r . i n t e g r a l A u s w e r t e n ( s1 ,−3 . 1 4 1 5 , 6 . 2 8 9 0 )<<s t d : : e n d l ; s t d : : c o u t<<s t d : : e n d l ;

r e t u r n 0 ; }

(40)

Abstrakte Basisklassen und Schnittstellen

// m i t t e l p u n k t s r e g e l . h : D i e K l a s s e M i t t e l p u n k t s r e g e l

#i n c l u d e " f u n k t i o n . h "

#i f n d e f MIPUREGEL H

#d e f i n e MIPUREGEL H

// M i t t e l p u n k t s r e g e l−K l a s s e c l a s s M i t t e l p u n k t s R e g e l {

p u b l i c:

M i t t e l p u n k t s R e g e l (i n t a n z a h l ) : n ( a n z a h l ){}

˜ M i t t e l p u n k t s R e g e l ( ) {};

// I n t e g r a l e i n e r F u n k t i o n a u s w e r t e n

d o u b l e i n t e g r a l A u s w e r t e n ( F u n k t i o n& f , d o u b l e a , d o u b l eb ) c o n s t {

d o u b l e e r g = 0 . 0 ;

d o u b l e h = ( b−a ) / ( 1 . 0∗n ) ; // L a e n g e d e r I n t e r v a l l e // A n t e i l e d e r e i n z e l n e n Boxen a u f s u m m i e r e n

f o r (i n t i =0; i<n ; ++i ) {

d o u b l e x = a + i∗h + 0.5∗h ; // I n t e r v a l l−M i t t e l p u n k t e r g += h∗ f . a u s w e r t e n ( x ) ; // F u n k t i o n s a u s w e r t u n g }

r e t u r n e r g ; }

p r i v a t e: i n t n ;

(41)

Abstrakte Basisklassen und Schnittstellen

// f u n k t i o n . h : A b s t r a k t e S c h n i t t s t e l l e n k l a s s e f u e r F u n k t i o n e n // I n k l u s i o n s−Waechter

#i f n d e f FUNKTION H

#d e f i n e FUNKTION H

// A b s t r a k t e B a s i s k l a s s e f u e r F u n k t i o n e n c l a s s F u n k t i o n

{ p u b l i c:

// K o n s t r u k t o r e n F u n k t i o n ( ) {};

// v i r t u e l l e r D e s t r u k t o r v i r t u a l ˜ F u n k t i o n ( ) {};

// F u n k t i o n a u s w e r t e n , r e i n v i r t u e l l ! v i r t u a l d o u b l e a u s w e r t e n (d o u b l e x ) c o n s t= 0 ; p r i v a t e:

};

#e n d i f

(42)

Abstrakte Basisklassen und Schnittstellen

#i n c l u d e<cmath>

// i n k l u d i e r e B a s i s k l a s s e / S c h n i t t s t e l l e

#i n c l u d e " f u n k t i o n . h "

#i f n d e f S I N U S H

#d e f i n e S I N U S H

// K a p s e l u n g s−K l a s s e f u e r den S i n u s c l a s s S i n u s : p u b l i c F u n k t i o n {

p u b l i c : S i n u s ( ) {}

// E r f u e l l u n g d e r S c h n i t t s t e l l e d o u b l e a u s w e r t e n (d o u b l e x ) c o n s t {

r e t u r n s i n ( x ) ; }

p r i v a t e : };

#e n d i f

(43)

Templates und generische Programmierung

Templates

Templates – Code-Schablonen

• Templates erm¨oglichen die Parametrisierung von Klassen und Funktionen.

• Templates entkoppeln Funktionen oder Algorithmen vom Datentyp.

• Zul¨assige Parameter:

• Standard-Typen wieint, double, ...,

• Eigene Typen (Klassen),

• Templates.

• Templates erm¨oglichen statischen Polymorphismus (siehe sp¨ater).

• Templates verallgemeinern Code→

”Generische Programmierung“.

(44)

Beispiel: Templatisierte Funktion

1 # include < iostream >

2

3 // e x a m p l e f o r a f u n c t i o n t e m p l a t e 4 t e m p l a t e <class T >

5 T getMax (const T & a , const T & b ) 6 {

7 return (a > b ) ? a : b ; 8 }

9

10 int main ()

11 {

12 int i =5 , j =6 , k ;

13 double l =10.4 , m =10.25 , n ; 14

15 k = getMax <int>( i , j ); n = getMax <double>( l , m );

16 std :: cout << k << " , " << n << std :: endl ; 17 // o u t p u t : 6 , 1 0 . 4

18

19 return 0;

(45)

Beispiel: Templatisierte Array-Klasse

1 // a c l a s s t h a t t a k e s a t e m p l a t e p a r a m e t e r 2 t e m p l a t e <class T > class Array

3 { 4 public:

5 int add (const T & next , int n );

6 T & at (int n );

7 T & o p e r a t o r[](int n ) { return at ( n ); } 8

9 private:

10 T data [10];

11 };

12

13 // add a new d a t a member

14 t e m p l a t e <class T > int Array <T >:: add (const T & next , int n ) 15 {

16 if (n >=0 && n <10)

17 {

18 data [ n ] = next ; return 0;

19 }

(46)

Beispiel: Templatisierte Array-Klasse

23 // g e t a c e r t a i n d a t a member

24 t e m p l a t e <class T > T & Array <T >:: at (int n ) 25 {

26 if (n >=0 && n <10) return data [ n ];

27 } 28

29 // main program

31 int main () 32 {

33 Array <int> c ; c . add (3 ,0); c . add (4 ,5); c . add (0 ,1);

34 std :: cout << c . at (5) << std :: endl ; 35 // o u t p u t : 4

36

37 Array <char> d ; d . add ( ’x ’ ,9);

38 std :: cout << d . at (9) << std :: endl ; 39 // o u t p u t : x

40

41 return 0;

(47)

Weiteres zu Templates

• Mehrere Template-Parameter sind m¨oglich

• Parameter k¨onnen default-Werte haben

• Templates k¨onnen ausspezialisiert werden

(48)

Die STL

STL – Die Standard Template Library

In C++ gibt es viele vorgefertigte Template-Container, die ohne Kenntnis der Implementierung verwendet werden k¨onnen. Sie sind in einer Bibliothek, der STL, zusammengefasst.

Die STL

• ist eine Sammlung von Template Klassen und Algorithmen,

• bietet viele Containerklassen (Klasse, die eine Menge anderer Objekte verwaltet),

• hat dabei vereinheitlichte User-Interfaces f¨ur die Container,

• ist in der C++-Standardbibliothek enthalten.

(49)

Die STL

Container-Arten der STL

Die STL stellt verschiedene Arten von Containern bereit:

• Sequentielle Container Beispiele: Vektoren, Listen

• Container adapter

Eingeschr¨anktes Interface zu beliebigen Containern Beispiele: Stacks, Queues

• Assoziative Container Schl¨ussel-Wert Container Beispiel: Maps, Multimaps

(50)

Die STL

Vor- und Nachteile der STL

+ Dynamisches Speichermanagment

+ Vermeidung von array-¨Uberl¨aufen

+ Hohe Qualit¨at der Container

+ Optimierbarkeit durch statischen Polymorphismus

– Un¨ubersichtliche Fehlermeldungen

– Hohe Anforderungen an Compiler und Entwickler

– Nicht alle Compiler sind STL-f¨ahig (obwohl die STL im C++-Standard enthalten ist)

(51)

Die STL Bespiel einer Container-Klasse: Vektoren

Beispiele f¨ ur die Verwendung von STL-Containern: vector

Vector-Container

2 # include < vector >

3

4 int main () 5 {

6 // e x a m p l e u s a g e o f an STL v e c t o r

7 int result = 0;

8 std :: vector <int> x (100);

9

10 for (int j =0; j <100; j ++) x [ j ] = j ; 11

12 x . p u s h _ b a c k (100);

13

14 for (int j =0; j < x . size (); j ++)

15 result += x [ j ];

16

17 // o u t p u t : 5050

(52)

Die STL Das Iterator-Interface

Das Iterator-Interface

Iteratoren bieten Zugriff auf die Elemente eines Containers. Sie

• Iterieren ¨uber die Elemente eines Containers,

• Liefern Zeiger auf Container-Elemente,

• Werden von jeder Container-Klasse bereitgestellt,

• Gibt es in

”rw“- und einer

”w“-Varianten,

• Helfen, array-¨Uberl¨aufe zu vermeiden.

• Die Iteratoren werden von vielen STL-Algorithmen wie Sortieren, Suchen u.

¨a. verwendet.

(53)

Die STL Das Iterator-Interface

Beispiel: Iteratorieren ¨ uber eine Map

Map-Container mit Iterator

2 # include < map >

3 # include < cstring >

4

5 int main () 6 {

7 // e x a m p l e u s a g e o f an STL−map 8 std :: map < std :: string , int> y ; 9

10 y [ " eins " ] = 1; y [ " zwei " ] = 2;

11 y [ " drei " ] = 3; y [ " vier " ] = 4;

12

13 std :: map < std :: string , int>:: i t e r a t o r it ; 14 for ( it = y . begin (); it != y . end (); ++ it )

15 std :: cout << it - > first << " : " << it - > second << std :: endl ; 16 // o u t p u t : 1 : e i n s

17 // 2 : z w e i . . . usw .

(54)

STL Algorithmen

Algorithmen

Algorithmen, die die STL bereitstellt

Die STL enth¨alt viele hilfreiche Algorithmen, die

• Elemente eines Datencontainerns manipulieren k¨onnen,

• die Iteratoren zum Elementzugriff verwenden.

Beispiele:

• Sortieren

• Suchen

• Kopieren

• Umkehren der Reihenfolge im Container

• . . .

(55)

STL Algorithmen

Algorithmen

Beispiel: Sortier-Algorithmen f¨ ur Vektoren

• Verschiedene Sortierungen f¨ur Vektoren stehen bereit

• Unterscheidung z.B. durch:

• Benutzte Vergleichsoperation

• Bereich der Sortierung

• Stabilit¨at

• Komplexit¨at des Standard-Sortierers f¨ur Vektoren:

• O(n·logn) ideal

• O(n²) ung¨unstigster Fall

• eigene Vergleichsfunktionen m¨oglich

• Achtung: (doppelt verkettete) Listen sind auf Einf¨ugen und L¨oschen von Elementen optimiert⇒spezielle Sortier-Algorithmen

(56)

STL Algorithmen

Algorithmen

Beispiel: Verwendung eines Sortier-Algorithmus f¨ ur Vektoren

// a v e c t o r f o r i n t e g e r s vector <int> x ;

x . p u s h _ b a c k (23); x . p u s h _ b a c k ( -112);

x . p u s h _ b a c k (0); x . p u s h _ b a c k (9999);

x . p u s h _ b a c k (4); x . p u s h _ b a c k (4);

// s o r t t h e i n t e g e r v e c t o r sort ( v . begin () , v . end ());

// o u t p u t : −112 0 4 4 23 9999 for (int i = 0; i < x . size (); i ++)

cout << x [ i ] << " \ t " ;

(57)

Weiterf¨uhrende Literatur

Weiterf¨ uhrende Literatur

Literatur zu

” Scientific Computing with C++“

• N. Josuttis: C++ Templates – The Complete Guide

• T. Veldhuizen: Techniques for Scientific C++

• T. Veldhuizen: Template Metaprogramming

• E. Unruh: Prime Number Computation (historisches Beispiel f¨ur TMP)