Embedded C++ Peter Ulbrich

Transkript

1 Embedded C++ Peter Ulbrich Friedrich-Alexander-Universität Erlangen-Nürnberg Lehrstuhl Informatik 4 (Verteilte Systeme und Betriebssysteme) www4.informatik.uni-erlangen.de 3. November 2010 P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 1 / 73

2 Überblick Primitive Datentypen Komplexe Datentypen Funktionen Zeiger und Parameterübergabe Klassen Typumwandlung Namensräume Tipps und Tricks Templates P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 2 / 73

3 Fokus Generelles Worum geht es hier nicht? Standardbibliothek Speicherverwaltung Ein- und Ausgabe Warum geht es nicht darum? Weil wir es hier nicht brauchen! C++-Programme: Ausführung auf der nackten Hardware kein Laufzeitsystem keine Typinformation Ausnahme: RTTI und Exceptions (teuer!) P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 3 / 73

4 Primitive Datentypen Primitive Datentypen in C++ primitive Datentypen in Java exakt spezifiziert Breite (in Bits) von Ganzzahltypen exakt und absolut angegeben primitive Datentypen in C++ implementierungsabhängig Breite von Ganzzahltypen ist relativ angegeben z.b. Bits(int) Bits(short) P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 4 / 73

5 Primitive Datentypen Primitive Datentypen - Übersicht Diese Angaben für C++-Datentypen gelten z.b. auf heutigen x86-systemen mit dem GNU C Compiler (Version 3.3.5): Java C++ Bezeichner Größe min max Bezeichner Größe min max boolean bool char 16 Bit Unicode 0 Unicode char 8 Bit signed char 8 Bit unsigned char 8 Bit byte 8 Bit short 16 Bit signed short 16 Bit unsigned short 16 Bit int 32 Bit signed int 32 Bit unsigned int 32 Bit long 64 Bit signed long 32 Bit unsigned long 32 Bit float 32 Bit IEEE754 IEEE754 float 32 Bit - - double 64 Bit IEEE754 IEEE754 double 64 Bit long double 96 Bit - - void void P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 5 / 73

6 Primitive Datentypen Primitive Datentypen - Übersicht Diese Angaben für C++-Datentypen gelten z.b. auf einem H8/300 mit dem GNU C Compiler (Version 3.4): Java C++ Bezeichner Größe min max Bezeichner Größe min max boolean bool char 16 Bit Unicode 0 Unicode char 8 Bit signed char 8 Bit unsigned char 8 Bit byte 8 Bit short 16 Bit signed short 16 Bit unsigned short 16 Bit int 32 Bit signed int 16 Bit unsigned int 16 Bit long 64 Bit signed long 32 Bit unsigned long 32 Bit float 32 Bit IEEE754 IEEE754 float 32 Bit - - double 64 Bit IEEE754 IEEE754 double 32 Bit long double 32 Bit - - void void P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 6 / 73

7 Primitive Datentypen Wie löst man dieses Problem? Abbildung auf wohldefinierte Typen Abbildung typedef unsigned char ezstubs_uint8 ; / /.. typedef long long ezstubs_int64 ; typedef ezstubs_uint32 ezstubs_addrword ; ausschließliche Verwendung der wohldefinierten Typen Verwendung ezstubs_uint32 MyClass : : mymethod ( ) { / /... } P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 7 / 73

8 Konstanten in C++: Primitive Datentypen Konstanten Präprozessor # define PI Problematisch, weil: rein textuelle Ersetzung keine Integration ins C++-Typsystem P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 8 / 73

9 Konstanten in C++: Primitive Datentypen Konstanten Schlüsselwort const const unsigned i n t konstante = 5; muss initialisiert werden ins C++-Typsystem integriert Zusicherung des Programmierers an den Übersetzer! Unterschied zu C: benötigt nicht unbedingt Speicherplatz P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 9 / 73

10 Arrays Komplexe Datentypen C++ Arrays i n t i [ 1 0 ] ; myclass myclassobjects [ CONST_EXPRESSION ] ; sind keine Objekte einfache Aneinanderreihung von Objekten gleichen Typs P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 10 / 73

11 Aufzählung Komplexe Datentypen C++ Schlüsselwort enum enum Wochentage { Montag, Dienstag,... Sonntag } ; Zusammenfassung: Menge von Werten eigenständiger Typ P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 11 / 73

12 Verbund Komplexe Datentypen C++ Schlüsselwort union union TCSR { unsigned char v a l ; struct { unsigned char OCLRA : 1; unsigned char OVF : 1;... unsigned char ICFA : 1; } b i t s ; } ; val und bits sollten gleich groß sein derselbe Speicherbereich aber unterschiedliche Interpretationen P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 12 / 73

13 Komplexe Datentypen Strukturen und Klassen C++ Schlüsselwort struct struct Foo {... } ; Schlüsselwort class class Bar {... } ; Strukturen und Klassen sind in C++ fast äquivalent Unterschied: Sichtbarkeit Strukturen: standardmäßig public Klassen: standardmäßig private zu Klassen später mehr... P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 13 / 73

14 Komplexe Datentypen Benutzerdefinierte Typen C++ Schlüsselwort typedef typedef type_a type_b ; type_b kann synonym zu type_a verwendet werden Vorsicht: Forward Declarations und typedef Forward Declaration typedef typedef my_class_a my_class_b ;... class my_class_b ; obiges Beispiel wird eine Fehlermeldung beim Übersetzen liefern! P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 14 / 73

15 Funktionen Funktionsdefinitionen in C++ Definition Funktionsdefinition im Klassenrumpf class Foo { i n t Bar ( i n t i ) { return i + 5; } } ; Funktionsdefinition außerhalb des Klassenrumpfs class Foo { i n t Bar ( i n t i ) ; } ; i n t Foo : : Bar ( i n t i ) { return i + 5; } Funktionsdefinition innerhalb oder außerhalb des Klassenrumpfs auch globale Funktionen sind erlaubt P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 15 / 73

16 Funktionen Einbettung von Funktionen Einbettung Original i n t i n c ( i n t a ) { return a + 1; } i n t main ( ) { i n t a = 2; a = i n c ( a ) ; a = i n c ( a ) ; a = i n c ( a ) ; return 0; } Eingebettet i n t main ( ) { i n t a = 2; { i n t a_temp = a ; a = a_temp + 1; } { i n t a_temp = a ; a = a_temp + 1; } { i n t a_temp = a ; a = a_temp + 1; } return 0; } erhält Semantik der Parameterübergabe: hier call by value P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 16 / 73

17 Funktionen Einbettung von Funktionen Einbettung Einbettung textueller Ersetzung letzteres macht der Präprozessor Vorteil: Man spart den Overhead des Funktionsaufrufs. Gefahr: Code Bloat durch Code-Duplikation Achtung: Die optimale Inlining-Strategie zu finden ist schwer! P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 17 / 73

18 Funktionen Einbettung Einbettung von Funktionen in Java Schlüsselwort final class Bar { f i n a l i n t Foo ( ) {... } } Es gibt kein explizites Inlining in Java! Schlüsselwort final Methode wird nicht überschrieben! Solche Methoden kann der Compiler einbetten. P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 18 / 73

19 Funktionen Einbettung Einbettung von Funktionen in C++ durch Definition im Klassenrumpf durch entsprechende Deklaration Schlüsselwort inline class Foo { i n l i n e i n t Bar ( i n t i ) ; } ; i n t Foo : : Bar ( i n t i ) { return i + 5; } Definition muss beim Aufruf für den Compiler sichtbar sein! Letztendliche Einbettung hängt vom Compiler und den Compiler-Optionen ab! P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 19 / 73

20 Funktionen Operatoren Operatoren entsprechen normalen Funktionen Beispiele class Foo { / / Zuweisungsoperator Foo operator =(Foo v a l ) ; / / Typkonvertierung operator Bar ( ) ; } ; Syntactic Sugar keine echten benutzerdefinierten Operatoren Gewisse Operatoren können nicht überladen werden. Die Präzedenz kann nicht beeinflusst werden. P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 20 / 73

21 Was sind Zeiger Zeiger und Parameterübergabe Zeiger ein Zeiger ist ein Tripel (Typ, Bezeichner, Wert) Wert eines Zeigers: eine Adresse Semantik: an der Adresse ist ein Objekt vom Typ Typ Java: alle komplexen Datentypen sind Zeiger C++: wählbar int ptr_int 0x0ae0 int 0x0ae0 P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 21 / 73

22 Zeiger und Parameterübergabe Verwendung von Zeigern Zeiger Deklaration: i n t i ; MyClass foo ; Zugriff auf den referenzierten Wert: Operator * i = 5; Wo kommen Zeiger her? Operator & i n t i ; i n t p t r _ t o _ i = & i ; Operator new Foo f = new Foo ( ) ; P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 22 / 73

23 Referenzen Zeiger und Parameterübergabe Zeiger konstanter Zeiger, der automatisch dereferenziert wird muss initialisiert werden Verwendung: i n t i = 6; i n t& c = i ; Foo bar ; Foo& foobar = bar ; c = 5; / / i == 5! foobar. bar_method ( ) P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 23 / 73

24 Zeiger und Parameterübergabe Parameterübergabe Java primitive Datentypen: call by value komplexe Datentypen: call by reference C++ call by value: ein Objekt übergeben call by reference: einen Zeiger oder eine Referenz übergeben void by_value ( i n t i, Foo f ) ; void by_reference ( i n t i, Foo& f ) ; i n t i = 5; Foo f ; i n t main ( ) { by_value ( i, f ) ; / / c a l l by value by_reference (& i, f ) ; / / c a l l by reference return 0; } P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 24 / 73

25 Klassen Statische Felder Klassenvariablen - statische Felder Deklaration Schlüsselwort static class Foo { s t a t i c i n t bar ; s t a t i c void foobar ( ) ; } ; In C++ muss aber explizit Speicher belegt werden: i n t Foo : : bar = 0; sonst undefined reference... beim Binden Vorsicht: static für globale Variablen/Funktionen Das gibt es auch, es hat aber eine andere Bedeutung: Sichtbarkeit auf die umgebende Übersetzungseinheit beschränkt P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 25 / 73

26 Einfache Vererbung Klassen Vererbung C++ class Foo : public Bar {... } ; Sichtbarkeit von Feldern und Methoden der Basisklasse muss spezifiziert werden. P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 26 / 73

27 Klassen Sichtbarkeit und Vererbung Vererbung Basisklasse Vererbung Klasse public public public protected protected private private public protected protected protected protected private private public private private protected private private private Vorsicht: protected/private-vererbung ändert die Schnittstelle Interface- vs. Implementation-Inheritance Standard: private P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 27 / 73

28 Wozu ist das gut? Klassen Vererbung Definition von Benutzerschnittstellen Beispiel: Unterbrechungssynchronisation Schnittstelle / / not synchronized class MyClass { public : mymethod ( ) ; } ; / / synchronized class MyGuardedClass : protected myclass { public : mymethod ( ) ; } ; Verwendung MyGuardedClass myobject ; / / OK myobject. mymethod ( ) ; / / Compiler Fehler myobject. MyClass : : mymethod ( ) ; P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 28 / 73

29 Mehrfache Vererbung Klassen Vererbung Mehrfachvererbung class Foo : public Bar1, protected Bar2,... private Barn {... } ; eine Klasse kann mehr als eine Basisklasse haben Vorsicht: Konflikte können entstehen Klasse Bar1 definiert Methode void Bar1::FooBar() Klasse Bar2 definiert Methode void Bar2::FooBar() in Klasse Foo: welche Methode ist gemeint? Konflikte müssen vom Programmierer aufgelöst werden! P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 29 / 73

30 Polymorphismus Auswahl der Methode zur Laufzeit Klassen Polymorphismus und virtuelle Methoden i n t main ( ) { Oberklasse o ; Unterklasse1 u1 = new Unterklasse1 ( ) ; Unterklasse2 u2 = new Unterklasse2 ( ) ; / / Unterklasse1 : : foo ( ) o = u1 ; o >foo ( ) ; / / Unterklasse2 : : foo ( ) o = u2 ; o >foo ( ) ; } return 0; P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 30 / 73

31 Virtuelle Methoden Klassen Polymorphismus und virtuelle Methoden Polymorphismus nur bei virtuellen Methoden in Java sind alle Methoden virtuell in C++ müssen Methoden als virtuell deklariert werden Schlüsselwort virtual class Foo { v i r t u a l void bar ( ) ; } ; Vorsicht: Virtuelle Methoden sind teuer! P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 31 / 73

32 Konstruktoren Klassen Konstruktoren und Destruktoren Reihenfolge: 1. Konstruktor der Basisklasse 2. Konstruktor der eigentlichen Klasse Achtung: Reihenfolge der Basisklassenkonstruktoren bei Mehrfachvererbung ist nicht immer definiert! Unterschied: kein super Basisklassenkonstruktor in der Initializer-list des Konstruktors class Foo : public Bar { Foo ( ) : Bar ( ) {... } } ; nicht notwendig bei Default-Konstruktoren P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 32 / 73

33 Destruktoren Klassen Konstruktoren und Destruktoren räumt ein Objekt auf, wenn seine Lebenszeit endet Reihenfolge: 1. Destruktor der eigentlichen Klasse 2. Destruktor der Basisklasse Achtung: Reihenfolge der Basisklassendestruktoren bei Mehrfachvererbung ist nicht immer definiert! Es gibt für jede Klasse genau einen Destruktor! Syntax class Foo { Foo ( ) {.. } / / Konstruktor ~Foo ( ) {.. } / / D e s t r u k t o r } ; P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 33 / 73

34 Explizite Erzeugung Klassen Erzeugung von Objekten dynamische Erzeugung von Objekten mit dem Operator new MyClass mc = new MyClass ( ) ; liefert einen Zeiger auf das erzeugte Objekt benötigt dynamische Speicherverwaltung Vorsicht: Speicher mit delete wieder freigegeben! delete mc; Keine Garbage Collection! P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 34 / 73

35 Klassen Erzeugung von Objekten Implizite Erzeugung - lokale Variablen Lokale Variablen i n t main ( ) { myclass a ; / / Default Konstruktor yourclass b ( 3 ) ; / / b e n u t z e r d e f i n i e r t e r Konstruktor... return 0; } werden auf dem Stapel angelegt beim Betreten des Sichtbarkeitsbereichs: Konstruktor beim Verlassen des Sichtbarkeitsbereichs: Destruktor P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 35 / 73

36 Klassen Implizite Erzeugung - Felder Erzeugung von Objekten Felder einer Klasse class Foo { myclass a ; / / Default Konstruktor yourclass b ; / / b e n u t z e r d e f i n i e r t e r Konstruktor ourclass c ; / / b e n u t z e r d e f i n i e r t e r Konstruktor Foo ( ) : b ( 3 ), c ( " Hallo " ) {... } } ; Kind-Objekte werden implizit mit dem Eltern-Objekt erzeugt Aufruf des Default-Konstruktors durch den Compiler andere Konstruktoren in der Initializer-Liste P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 36 / 73

37 Klassen Implizite Erzeugung - global Erzeugung von Objekten Globale Variablen myclass a ; / / Default Konstruktor yourclass b ( 3 ) ; / / b e n u t z e r d e f i n i e r t e r Konstruktor globaler Sichtbarkeitsbereich wird beim Start der Anwendung betreten Beenden der Anwendung verlassen Compiler erzeugt entsprechende Konstruktor/Destruktor-Aufrufe Vorsicht: Reihenfolge nicht spezifiziert! Compiler-spezifische Erweiterungen notwendig P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 37 / 73

38 Klassen Zugriff auf Felder Zugriff auf nicht-statische Felder Zugriff auf nicht-statische Felder bei Objekten Operator. class Foo { public : i n t bar_var ; i n t bar_method ( ) ; } ; i n t main ( ) { i n t a, b ; Foo foo ; a = foo. bar_var ; b = foo. bar_method ( ) ; } return 0; P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 38 / 73

39 Klassen Zugriff auf Felder Zugriff auf nicht-statische Felder Zugriff auf nicht-statische Felder bei Zeigern auf Objekte Operator -> class Foo { public : i n t bar_var ; i n t bar_method ( ) ; } ; i n t main ( ) { i n t a, b ; Foo foo = new Foo ( ) ; a = foo >bar_var ; b = foo >bar_method ( ) ; } return 0; foo->a ist Kurzform für (*foo).a Syntactic Sugar P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 39 / 73

40 Klassen Zugriff auf statische Felder Zugriff auf Felder Operator :: (scope-operator) class Foo { public : s t a t i c i n t bar_var ; s t a t i c i n t bar_method ( ) ; } ; i n t main ( ) { i n t a, b ; a = Foo : : bar_var ; b = Foo : : bar_method ( ) ; } return 0; P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 40 / 73

41 Typumwandlung Typumwandlung in C++ type var = const_cast < type >(param ) ; entfernt const-qualifizierung besser: mutable-qualifizierung für Instanzvariablen Ausnahme: existierende API, die kein const unterstützt void foo ( const char s t r ) { legacy_func ( const_cast < char >( s t r ) ) ; } Achtung: legacy_func darf str nicht verändern! P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 41 / 73

42 Typumwandlung Typumwandlung in C++ type var = static_cast < type >(param ) ; Konvertierung zwischen Zahlenformaten (z.b. int und float) Konvertierung zwischen verwandten Zeiger- und Referenztypen Typen werden statisch während der Übersetzung aufgelöst Achtung: Typdefinition muss bekannt sein Deklaration ist nicht ausreichend Übersetzungsfehler this-zeiger werden bei Bedarf angepasst z.b. im Falle der Mehrfachvererbung P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 42 / 73

43 Typumwandlung Typumwandlung in C++ type var = dynamic_cast< type >(param ) ; Konvertierung zwischen verwandten Zeiger- und Referenztypen wird dynamisch während der Laufzeit aufgelöst Typinformation notwendig RTTI Fehlerfall Zeiger: 0 wird zurück gegeben Referenzen: bad_cast-ausnahme wird geworfen nur mit polymorphen Typen möglich virtuelle Methoden Alternative: dynamic dispatch durch virtuelle Funktionen P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 43 / 73

44 Typumwandlung Typumwandlung in C++ type var = reinterpret_cast < type >(param ) ; erzwungene Reinterpretation einer bestimmten Speicherstelle ähnlich zu Typumwandlungen für Zeiger in C ( Typumwandlung im C-Stil) keine Überprüfung - weder zur Übersetzungs- noch zur Laufzeit in der Regel: Finger weg! P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 44 / 73

45 Typumwandlung Typumwandlung im C-Stil class A {... } ; class B : public class A {... } ; A a = new A ( ) ; / / OK B b = new B ( ) ; / / OK A pa = b ; / / OK B b1 = a ; / / Fehler B b2 = pa ; / / Fehler B b3 = (B ) pa ; / / OK ( mit e i n f a c h e r Vererbung ) B b4 = (B ) a ; / / Fehler ( n i c h t erkennbar ) P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 45 / 73

46 Typumwandlung Typumwandlung im C-Stil (considered harmful) Typumwandlung in C probiert verschiedene C++-Typumwandlungen: 1. const_cast 2. static_cast 3. static_cast, dann const_cast 4. reinterpret_cast 5. reinterpret_cast, dann const_cast das Ergebnis unterscheidet sich, je nachdem ob alle Header eingebunden wurden static_cast oder nur eine Deklaration verfügbar ist reinterpret_cast solange es irgendwie geht: Finger weg! Problem: Verwendung von C-Bibliotheken in C++-Programmen P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 46 / 73

47 Namensräume C++: Namensräume Schlüsselwort namespace namespace Bar { } class Foo {... } ; Vollständiger Name der Klasse Foo : Bar::Foo P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 47 / 73

48 Präprozessormakros Tipps und Tricks Memory-mapped IO Register entspricht einer Stelle im Speicherbereich Register hat eine Adresse Interpretiere Adresse als Zeiger #define TIER ( ( v o l a t i l e unsigned char )0 x f f 9 0 ) unsigned char a = TIER ; TIER = 5; TIER = 0x80 ; volatile schützt vor übereifrigem Compiler P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 48 / 73

49 Präprozessormakros Tipps und Tricks Memory-mapped IO eleganter: union (aber nicht wirklich standardkonform) union t i e r { v o l a t i l e unsigned char v a l ; struct { v o l a t i l e unsigned char ICIAE : 1;... } b i t s ; } ; #define TIER ( ( union t i e r )0 x f f 9 0 ) unsigned char a = TIER. v a l ; TIER. b i t s. ICIAE = 1; TIER. v a l = 0x85 ; P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 49 / 73

50 Operatoren Tipps und Tricks Memory-mapped IO Überladen des Zuweisungsoperators Typumwandlungsoperators (für Referenzen) template < typename TYPE, i n t ADDR > class MemMap { public : TYPE operator =(TYPE v a l ) const { ( ( v o l a t i l e TYPE )ADDR) = v a l ; return v a l ; } operator TYPE ( ) const { return ( ( v o l a t i l e TYPE )ADDR) ; } operator TYPE& ( ) const { return ( ( v o l a t i l e TYPE )ADDR) ; } } ; P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 50 / 73

51 Operatoren Tipps und Tricks Memory-mapped IO Verwendung MemMap< unsigned char,0 x f f 9 0 > TIER ; unsigned char a = TIER ; TIER = 0x80 ; TIER = 0x40 ; TIER &= ~0x80 ; P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 51 / 73

52 Warum Assembler? Tipps und Tricks Assembler Effizienz??? in unserem Fall eher nicht Der Compiler unterstützt nicht alle Instruktionen der CPU. Manches lässt sich in einer Hochsprache nicht formulieren. P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 52 / 73

53 Assemblerdateien Tipps und Tricks Assembler my_add.s _my_add : mov 8(%esp ),%eax mov 12(%esp),%edx add %edx,%eax r e t my_source.c unsigned i n t my_add ( unsigned int, unsigned i n t ) ; i n t main ( ) { unsigned i n t a = 3,b = 5, c = 0; c = my_add ( a, b ) ; return 0; } P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 53 / 73

54 Inline-Assembler Tipps und Tricks Assembler kleine Assembler-Abschnitte: Aufwand einer eigenen Datei groß Inline-Assembler i n t main ( ) { unsigned i n t a = 3,b = 5, c = 0; asm ( "mov %2,%eax ; " "mov %3,%edx ; " " add %edx,%eax ; " "mov %eax,%1 " : " =m" ( c ) : "m" ( a ), "m" ( b ) : " eax ", " edx " ) ; return 0; } P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 54 / 73

55 Tipps und Tricks Vorsicht: Ganzzahlarithmetik Arithmetik Divisionen unsigned i n t a = 99, b = 100; unsigned i n t c = a / b ; / / c == 0! Multiplikationen unsigned short a = 1000, b = 100; unsigned short c = a b ; / / c! = ! / / c == 34464! Additionen und Subtraktionen unsigned short a = 0 x f f f f ; a++; / / a!= 0x10000! / / a == 0! P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 55 / 73

56 Gleitkommaarithmetik Tipps und Tricks Arithmetik Viele Prozessoren unterstützen keine Gleitkommazahlen Abbildung auf Ganzzahlarithmetik Extrem teuer (Nur mit FPU sinnvoll) Vorsicht mit mathematischen Funktionen! P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 56 / 73

57 Tipps und Tricks Speicherallokation Keine dynamische Speicherverwaltung! kein malloc/free kein new/delete keine Speicherlöcher! Speicher wird angefordert: dynamisch auf dem Stack statisch im Datensegment (globale Variablen) P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 57 / 73

58 Globale Variablen Tipps und Tricks Speicherallokation Problem: A a ; B b ; C c ; In welcher Reihenfolge werden die Konstruktoren aufgerufen? Lösung: attribute ((init_priority(x))) A a attribute ( ( i n i t _ p r i o r i t y ( ) ) ) ; / / 1. B b attribute ( ( i n i t _ p r i o r i t y ( ) ) ) ; / / 2. C c attribute ( ( i n i t _ p r i o r i t y ( ) ) ) ; / / 3. GCC only - im Standard nicht spezifiziert P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 58 / 73

59 Allgemein Templates Allgemein Templates ermöglichen generische Programmierung in C++ Generische Programmierung möglichst allgemeine Algorithmen und Datenstrukturen verzichte auf die Festlegung von Typen Anforderungen an Typen sind erlaubt structural vs. nominative type system zwei Ausprägungen Funktionstemplates Klassentemplates P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 59 / 73

60 Funktionstemplates Templates Funktionstemplates generische Beschreibung von Algorithmen Deklaration/Definition Verwendung P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 60 / 73

61 Definition/Deklaration Templates Funktionstemplates Deklaration template <class class_name > void myfunc ( ) ; template < t y p e type_name> void myfunc ( ) ; Definition template <class class_name > void myfunc ( ) { / /... } es sind auch mehrere Parameter erlaubt template <class A, class B> void myfunc ( ) ; gültige Parameterarten: Typen (auch Zeiger) und Ganzzahlen P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 61 / 73

62 Verwendung Templates Funktionstemplates Beispiel: generische max()-funktion template < type T > T max( T a, T b ) { return a > b? a : b ; } Verwendung i n t a = 5,b = 7, c ; c = max< i n t >(a, b ) ; manchmal kann der Übersetzer den Typ erraten i n t a = 5,b = 7, c ; c = max( a, b ) ; P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 62 / 73

63 Klassentemplates Templates Klassentemplates generische Beschreibung von Datenstrukturen und zugehöriger Algorithmen Deklaration/Definition Definition von Methoden Verwendung P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 63 / 73

64 Deklaration/Definition Templates Klassentemplates Deklaration template < type T, i n t I > class Tuple ; Definition template < type T, i n t I > class Tuple { public : void put ( T item, i n t pos ) ; T get ( i n t pos ) ; void s o r t ( ) ; } ; Parameterlisten: siehe Funktionstemplates P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 64 / 73

65 Templates Definition von Methoden Klassentemplates im Klassenrumpf template < type T, i n t I > class Tuple { public : void put ( T item, i n t pos ) { /... / } / /... } ; außerhalb des Klassenrumpfs template < type T, i n t I > void Tuple < T, I > : : put ( T item, i n t pos ) { / /... } Achtung: Trennung in Header (.h) und Implementierungseinheit (.cc) existiert für Templates in gängigen Toolchains noch nicht P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 65 / 73

66 Verwendung Templates Klassentemplates Beispiel i n t a = 1,b = 2, c ; Tuple < int,5 > my_tuple ; my_tuple. put ( a, 0 ) ; my_tuple. put ( b, 1 ) ; my_tuple. put ( 4, 2 ) ; c = my_tuple. get ( 2 ) ; Templates ermöglichen typsichere Programmierung f l o a t d = 0; my_tuple. put ( d, 3 ) ; / / compile time e r r o r P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 66 / 73

67 Templates Template-Instantiierung Template-Instantiierung Templates beschreiben noch keinen ausführbaren Code Übersetzer muss erst noch Lücken (Parameter) füllen diesen Vorgang bezeichnet man als Instantiierung Beispiel: generische max()-funktion Template template < type T > T max( T a, T b ) { return a > b? a : b ; } Instantiierung (T == int) i n t max( i n t a, i n t b ) { return a > b? a : b ; } Wann findet die Instantiierung statt? - Bei der Verwendung! c = max< i n t >(a, b ) ; P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 67 / 73

68 Templates Template-Spezialisierung Template-Spezialisierung Unterschiedliche Behandlung bestimmter Template-Parameter Behandlung von Sonderfälle Beispiel: Sortieren Tupel der Länge 1 sind trivialerweise sortiert Lösung: man spezialisiert das Template template < type T, i n t L > struct S o rter { void s o r t ( T array ) {... } } ; template < type T > struct Sorter < T,1 > { void s o r t ( T array ) { } } P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 68 / 73

69 Templates Template-Spezialisierung vollständige vs. partielle Spezialisierung vollständige Spezialisierung legt alle Parameter fest template <> struct Sorter < int,1 > { void s o r t ( i n t array ) { } } partielle Spezialisierung schränkt den Parameterraum ein template < type T > struct Sorter < T,1 > { void s o r t ( T array ) { } } Funktionstemplates sind nicht partiell spezialisierbar! P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 69 / 73

70 Templates Template Metaprogramming Template Metaprogramming... C++ Templates sind noch viel mehr als das... C++ Templates sind eine funktionale Programmiersprache eingebettet in C++ wird vom Übersetzer ausgeführt geeignet zum schreiben von Metaprogrammen geeignet für generative Programmierung Metaprogramme Ein Metaprogramm verarbeitet, modifiziert oder erzeugt ein oder mehrere andere Programme. Generative Programmierung Generative Programmierung ist ein Paradigma, dessen charakteristische Eigenschaft es ist, dass Quelltext durch einen Generator erzeugt wird. P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 70 / 73

71 Templates Template Metaprogramming Fakultät als Template Metaprogramm v o l a t i l e i n t c ; template < i n t I > struct Faculty { enum { r e s u l t = I Faculty < I 1 > : : r e s u l t } ; } ; template <> struct Faculty < 1 > { enum { r e s u l t = 1 } ; } ; i n t main ( void ) { c = Faculty < 5 > : : r e s u l t ; return 0; } P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 71 / 73

72 Templates Template Metaprogramming Fakultät als Template Metaprogramm die Fakultätsfunktion wird komplett im Übersetzer berechnet Assembler-Dump der Funktion main() <main >: lea 0x4(%esp),%ecx and $ 0 x f f f f f f f 0,%esp push 0 x f f f f f f f c (%ecx ) push %ebp mov %esp,%ebp push %ecx mov $0x78, 0 x mov $0x0,%eax pop %ecx pop %ebp lea 0 x f f f f f f f c (%ecx),%esp r e t P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 72 / 73

73 Literatur Andrei Alexandrescu. Modern C++ Design: Generic Programming and Design Patterns Applied. Addison-Wesley, Krysztof Czarnecki and Ulrich W. Eisenecker. Generative Programming. Methods, Tools and Applications. Addison-Wesley, May Bruce Eckel. Thinking in C++. Prentice Hall PTR, Upper Saddle River, NJ, USA, Stefan Kuhlins and Martin Schader. Die C++-Standardbibliothek. Springer-Verlag, Thomas Strasser. C++ Programmieren mit Stil. dpunkt Verlag, P. Ulbrich, F. Scheler (Informatik 4) Embedded C++ WS 2010/11 73 / 73