Von Java/C nach C++
Fabian Scheler, Peter Ulbrich, Niko Böhm
Friedrich-Alexander-Universität Erlangen-NürnbergLehrstuhl Informatik 4 (Verteilte Systeme und Betriebssysteme)
www4.informatik.uni-erlangen.de
19. Oktober 2009
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 1 / 59
Überblick
Primitive Datentypen
Komplexe Datentypen
Funktionen
Zeiger und Parameterübergabe
Klassen
Typumwandlung
Namensräume
Templates
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 2 / 59
Generelles
Fokus
Worum geht es hier nicht?
I StandardbibliothekI SpeicherverwaltungI Ein- und Ausgabe
Warum geht es nicht darum?
I Weil wir es hier nicht brauchen!
Worum es geht?
I Abbildung von Java auf C++I Was gibt es in C++, was es in Java nicht gibt?
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 3 / 59
Generelles
Der bekannteste Unterschied
I Java-Programme: Ausführung auf einer virtuellen MaschineI mächtiges Laufzeitsystem (z.B. Garbage Collection)I TypinformationI dynamische Laden von KlassenI Überprüfungen zur LaufzeitI . . .
I C++-Programme: Ausführung auf der nackten HardwareI kein LaufzeitsystemI keine TypinformationI Ausnahme: RTTI und Exceptions (teuer!)
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 4 / 59
Primitive Datentypen
Primitive Datentypen in Java und C++
I primitive Datentypen in Java 7→ exakt spezifiziertI Breite (in Bits) von Ganzzahltypen exakt und absolut angegeben
I primitive Datentypen in C++ 7→ implementierungsabhängigI Breite von Ganzzahltypen ist relativ angegeben
I z.B. Bits(int) ≥ Bits(short)
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 5 / 59
Primitive Datentypen
Primitive Datentypen - Übersicht
Diese Angaben für C++-Datentypen gelten z.B. auf heutigenx86-Systemen mit dem GNU C Compiler (Version 3.3.5):
Java C++Bezeichner Größe min max Bezeichner Größe min maxboolean - - - bool - - -char 16 Bit Unicode 0 Unicode 216 − 1 char 8 Bit -128 +127- - - - signed char 8 Bit -128 +127- - - - unsigned char 8 Bit 0 255byte 8 Bit -128 127 - - - -short 16 Bit −215 215 − 1 signed short 16 Bit −215 215 − 1- - - - unsigned short 16 Bit 0 216 − 1int 32 Bit −231 231 − 1 signed int 32 Bit −231 231 − 1- - - - unsigned int 32 Bit 0 232 − 1long 64 Bit −263 263 − 1 signed long 32 Bit −231 231 − 1- - - - unsigned long 32 Bit 0 232 − 1float 32 Bit IEEE754 IEEE754 float 32 Bit - -double 64 Bit IEEE754 IEEE754 double 64 Bit - -- - - - long double 96 Bit - -void - - - void - - -
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 6 / 59
Primitive Datentypen
Primitive Datentypen - Übersicht
Diese Angaben für C++-Datentypen gelten z.B. auf einem H8/300 mitdem GNU C Compiler (Version 3.4):
Java C++Bezeichner Größe min max Bezeichner Größe min maxboolean - - - bool - - -char 16 Bit Unicode 0 Unicode 216 − 1 char 8 Bit -128 +127- - - - signed char 8 Bit -128 +127- - - - unsigned char 8 Bit 0 255byte 8 Bit -128 127 - - - -short 16 Bit −215 215 − 1 signed short 16 Bit −215 215 − 1- - - - unsigned short 16 Bit 0 216 − 1int 32 Bit −231 231 − 1 signed int 16 Bit −215 215 − 1- - - - unsigned int 16 Bit 0 216 − 1long 64 Bit −263 263 − 1 signed long 32 Bit −231 231 − 1- - - - unsigned long 32 Bit 0 232 − 1float 32 Bit IEEE754 IEEE754 float 32 Bit - -double 64 Bit IEEE754 IEEE754 double 32 Bit - -- - - - long double 32 Bit - -void - - - void - - -
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 7 / 59
Primitive Datentypen
Wie löst man dieses Problem?
I Abbildung auf wohldefinierte TypenAbbildung
typedef unsigned char ezstubs_u in t8 ;/ / . .typedef long long ezstubs_ in t64 ;typedef ezstubs_uint32 ezstubs_addrword ;
I ausschließliche Verwendung der wohldefinierten TypenVerwendung
ezstubs_uint32 MyClass : : myMethod ( ) {/ / . . .
}
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 8 / 59
Primitive Datentypen Konstanten
Konstanten in Java:
Schlüsselwort final
class Foo {s t a t i c f i n a l i n t Bar = 0 x f f ;
}
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 9 / 59
Primitive Datentypen Konstanten
Konstanten in C++:
Präprozessor
#define PI 3.14159
Problematisch, weil:
I rein textuelle ErsetzungI keine Integration ins C++-Typsystem
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 10 / 59
Primitive Datentypen Konstanten
Konstanten in C++:
Schlüsselwort const
const unsigned i n t konstante = 5;
I muss initialisiert werdenI ins C++-Typsystem integriertI Zusicherung des Programmierers an den Übersetzer!I Unterschied zu C: benötigt nicht unbedingt Speicherplatz
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 11 / 59
Komplexe Datentypen Java
Arrays
Arrays
i n t [ ] i = new i n t [ 5 ] ;Object [ ] o = new Object [ 1 0 ] ;
I mehr als eine Reihung von Objekten gleichen Typs+ Arrays sind Objekte
I enthalten z.B. Information über die Anzahl der Elemente
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 12 / 59
Komplexe Datentypen Java
Klassen
Schlüsselwort class
class Foo {private i n t x ;
public i n t Bar ( ) {return x ;
}
. . .}
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 13 / 59
Komplexe Datentypen C++
Arrays
Arrays
i n t i [ 1 0 ] ;myClass myClassObjects [CONST_EXPRESSION ] ;
I sind keine ObjekteI einfache Aneinanderreihung von Objekten gleichen Typs
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 14 / 59
Komplexe Datentypen C++
Aufzählung
Schlüsselwort enum
enum Wochentage {Montag ,Dienstag ,. . .Sonntag
} ;
I Zusammenfassung: Menge von Werten 7→ eigenständiger Typ
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 15 / 59
Komplexe Datentypen C++
Verbund
Schlüsselwort union
union TCSR {unsigned char va l ;struct {
unsigned char OCLRA : 1 ;unsigned char OVF : 1 ;. . .unsigned char ICFA : 1 ;
} b i t s ;} ;
I val und bits sollten gleich groß seinI derselbe Speicherbereich aber unterschiedliche Interpretationen
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 16 / 59
Komplexe Datentypen C++
Strukturen und Klassen
Schlüsselwort struct
struct Foo {. . .
} ;
Schlüsselwort class
class Bar {. . .
} ;
I Strukturen und Klassen sind in C++ fast äquivalentI Unterschied: Sichtbarkeit
I Strukturen: standardmäßig publicI Klassen: standardmäßig private
I zu Klassen später mehr . . .
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 17 / 59
Komplexe Datentypen C++
Benutzerdefinierte Typen
Schlüsselwort typedef
typedef type_A type_B ;
I type_B kann synonym zu type_A verwendet werdenI Vorsicht: Forward Declarations und typedef
Forward Declaration 6= typedef
typedef my_Class_A my_Class_B ;. . .class my_Class_B ;
obiges Beispiel wird eine Fehlermeldung beim Übersetzen liefern!
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 18 / 59
Funktionen Definition
Funktionsdefinitionen in Java
Funktionsdefinition im Klassenrumpf
class Foo {public i n t a ;public i n t Bar ( i n t i ) {
return i + a ;}
}
I Alle Funktionen sind Methoden genau einer KlasseI Keine globalen FunktionenI Funktionen werden immer im Klassenrumpf definiert
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 19 / 59
Funktionen Definition
Funktionsdefinitionen in C++
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 ; }
I Funktionsdefinition innerhalb oder außerhalb des KlassenrumpfsI auch globale Funktionen sind erlaubt
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 20 / 59
Funktionen Überladen
Überladen von Funktionen in Java
void Bar ( i n t i ) { . . . } / / OKvoid Bar ( long l ) { . . . } / / Fehlervoid Bar ( Object o ) { . . . } / / OKObject Bar ( i n t i ) { . . . } / / FehlerObject Bar ( Object o , i n t i ) { . . . } / / Fehler
Überladen von Funktionen in C++
void Bar ( i n t i ) { . . . } / / OKvoid Bar ( long l ) { . . . } / / Fehlervoid Bar ( Object o ) { . . . } / / OKObject Bar ( i n t i ) { . . . } / / FehlerObject Bar ( Object o , i n t i ) { . . . } / / OK
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 21 / 59
Funktionen Einbettung
Einbettung von Funktionen
Original
i n t i nc ( i n t a ) {return a + 1;
}i n t main ( ) {
i n t a = 2;a = inc ( a ) ;a = inc ( a ) ;a = inc ( 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;
}
I erhält Semantik der Parameterübergabe: hier call by value
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 22 / 59
Funktionen Einbettung
Einbettung von Funktionen
I Einbettung 6= textueller ErsetzungI letzteres macht der Präprozessor
I Vorteil: Man spart den Overhead des Funktionsaufrufs.I Gefahr: Code Bloat durch Code-DuplikationI Achtung: Die optimale Inlining-Strategie zu finden ist schwer!
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 23 / 59
Funktionen Einbettung
Einbettung von Funktionen in Java
Schlüsselwort final
class Bar {f i n a l i n t Foo ( ) { . . . }
}
I Es gibt kein explizites Inlining in Java!I Schlüsselwort final ; Methode wird nicht überschrieben!
+ Solche Methoden kann der Compiler einbetten.
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 24 / 59
Funktionen Einbettung
Einbettung von Funktionen in C++
I durch Definition im KlassenrumpfI 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 ; }
I Definition muss beim Aufruf für den Compiler sichtbar sein!I Letztendliche Einbettung hängt vom Compiler und den
Compiler-Optionen ab!
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 25 / 59
Funktionen Operatoren
Operatoren entsprechen normalen Funktionen
Beispiele
class Foo {/ / ZuweisungsoperatorFoo operator =(Foo va l ) ;/ / Typkonver t ierungoperator Bar ( ) ;
} ;
I Syntactic SugarI keine echten benutzerdefinierten OperatorenI Gewisse Operatoren können nicht überladen werden.I Die Präzedenz kann nicht beeinflusst werden.
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 26 / 59
Zeiger und Parameterübergabe Zeiger
Was sind Zeiger
I ein Zeiger ist ein Tripel (Typ, Bezeichner, Wert)I Wert eines Zeigers: eine AdresseI Semantik: an der Adresse ist ein Objekt vom Typ Typ
I Java: alle komplexen Datentypen sind ZeigerI C++: wählbar
int
ptr_int
0x0ae0
0x0ae0int
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 27 / 59
Zeiger und Parameterübergabe Zeiger
Verwendung von Zeigern
I Deklaration:
i n t ∗ i ;MyClass∗ foo ;
I Zugriff auf den referenzierten Wert:Operator *
∗ i = 5 ;
I 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 ( ) ;
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 28 / 59
Zeiger und Parameterübergabe Zeiger
Referenzen
I ≈ konstanter Zeiger, der automatisch dereferenziert wirdI muss initialisiert werdenI Verwendung:
i n t i = 6 ;i n t& c = i ;Foo bar ;Foo& foobar = bar ;
c = 5 ; / / i == 5 !foobar . bar_method ( )
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 29 / 59
Zeiger und Parameterübergabe Parameterübergabe
I JavaI primitive Datentypen: call by valueI komplexe Datentypen: call by reference
I C++I call by value: ein Objekt übergebenI 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 valueby_reference (& i , f ) ; / / c a l l by re ferencereturn 0;
}
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 30 / 59
Klassen
Klassen in Java und C++
... sind im Großen und Ganzen sehr ähnlich, vor allem, was dasKonzept betrifft
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 31 / 59
Klassen Sichtbarkeit
Sichtbarkeit von Feldern und Methoden
Java
class Foo {public i n t a ;protected i n t b ;private i n t c ;public i n t Bar ( ) {
. . .}
}
I Angabe der Sichtbarkeitfür jedes Feld einer Klasseeinzeln
C++
class Foo {private :
i n t c ;protected :
i n t b ;public :
i n t a ;i n t Bar ( ) { . . . }
} ;
I Angabe der Sichtbarkeitfür eine Gruppe vonFeldern einer Klasse
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 32 / 59
Klassen Statische Felder
Klassenvariablen - statische Felder
I Deklaration wie in JavaSchlüsselwort static
class Foo {s t a t i c i n t bar ;s t a t i c void foobar ( ) ;
} ;
I In C++ muss aber explizit Speicher belegt werden:
i n t Foo : : bar = 0 ;
I sonst ; undefined reference ... beim BindenI Vorsicht: static für globale Variablen/Funktionen
I Das gibt es auch, es hat aber eine andere Bedeutung:+ Sichtbarkeit auf die umgebende Übersetzungseinheit beschränkt
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 33 / 59
Klassen Vererbung
Einfache Vererbung
Java
class Foo extends Bar {. . .
}
I Felder und Methoden derBasisklasse werden publicvererbt.
C++
class Foo : public Bar {. . .
} ;
I Sichtbarkeit von Feldernund Methoden derBasisklasse mussspezifiziert werden.
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 34 / 59
Klassen Vererbung
Sichtbarkeit und Vererbung
Basisklasse Vererbung Klasse
publicpublic publicprotected protectedprivate private
protectedpublic protectedprotected protectedprivate private
privatepublic privateprotected privateprivate private
I Vorsicht: protected/private-Vererbung ändert die SchnittstelleI Interface- vs. Implementation-InheritanceI Standard: private
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 35 / 59
Klassen Vererbung
Wozu ist das gut?
I Definition von BenutzerschnittstellenI Beispiel: Unterbrechungssynchronisation
Schnittstelle
/ / not synchronizedclass MyClass {public :
myMethod ( ) ;} ;/ / synchronizedclass MyGuardedClass
: protected myClass{public :
myMethod ( ) ;} ;
Verwendung
MyGuardedClass myObject ;
/ / OKmyObject . myMethod ( ) ;
/ / Compiler FehlermyObject .
MyClass : : myMethod ( ) ;
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 36 / 59
Klassen Vererbung
Mehrfache Vererbung
Mehrfachvererbung
class Foo: public Bar1 , protected Bar2 , . . . private Barn
{. . .
} ;
I eine Klasse kann mehr als eine Basisklasse habenI Vorsicht: Konflikte können entstehen
I Klasse Bar1 definiert Methode void Bar1::FooBar()I Klasse Bar2 definiert Methode void Bar2::FooBar()
in Klasse Foo: welche Methode ist gemeint?I Konflikte müssen vom Programmierer aufgelöst werden!
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 37 / 59
Klassen Polymorphismus und virtuelle Methoden
PolymorphismusAuswahl der Methode zur Laufzeit
i n t main ( ) {Oberklasse∗ o ;Unterk lasse1 ∗ u1 = new Unterk lasse1 ( ) ;Unterk lasse2 ∗ u2 = new Unterk lasse2 ( ) ;
/ / Unterk lasse1 : : foo ( )o = u1 ;o−>foo ( ) ;/ / Unterk lasse2 : : foo ( )o = u2 ;o−>foo ( ) ;
return 0;}
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 38 / 59
Klassen Polymorphismus und virtuelle Methoden
Virtuelle Methoden
I Polymorphismus nur bei virtuellen MethodenI in Java sind alle Methoden virtuellI in C++ müssen Methoden als virtuell deklariert werden
Schlüsselwort virtual
class Foo {v i r t u a l void bar ( ) ;
} ;
I Vorsicht: Virtuelle Methoden sind teuer!
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 39 / 59
Klassen Abstrakte Klassen und Interfaces
Schnittstellenbeschreibungen
I KlassenI Interfaces in Java
Schlüsselwort interface
in ter face Comparable {public i n t compare ( Object o ) ;
}
I Abstrakte Klassen in C++: rein virtuelle Methoden
class Comparable {public :
v i r t u a l i n t compare ( Object o ) = 0 ;} ;
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 40 / 59
Klassen Konstruktoren und Destruktoren
Konstruktoren
I sehr ähnlich zu JavaI Reihenfolge:
1. Konstruktor der Basisklasse2. Konstruktor der eigentlichen Klasse
I Achtung: Reihenfolge der Basisklassenkonstruktoren beiMehrfachvererbung ist nicht immer definiert!
I Unterschied: kein superI Basisklassenkonstruktor in der Initializer-list des Konstruktors
class Foo : public Bar {Foo ( ) : Bar ( ) {
. . .}
} ;
I nicht notwendig bei Default-KonstruktorenF. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 41 / 59
Klassen Konstruktoren und Destruktoren
Destruktoren
I ähnelt dem finalize aus JavaI räumt ein Objekt auf, wenn seine Lebenszeit endetI Reihenfolge:
1. Destruktor der eigentlichen Klasse2. Destruktor der Basisklasse
I Achtung: Reihenfolge der Basisklassendestruktoren beiMehrfachvererbung ist nicht immer definiert!
I Es gibt für jede Klasse genau einen Destruktor!
Syntax
class Foo {Foo ( ) { . . } / / Kons t ruk to r~Foo ( ) { . . } / / Des t ruk to r
} ;
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 42 / 59
Klassen Erzeugung von Objekten
Explizite Erzeugung
I dynamische Erzeugung von Objekten mit dem Operator new
MyClass∗ mc = new MyClass ( ) ;
I liefert einen Zeiger auf das erzeugte ObjektI benötigt dynamische SpeicherverwaltungI Vorsicht: Speicher mit delete wieder freigegeben!
delete mc;
I Keine Garbage Collection!
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 43 / 59
Klassen Erzeugung von Objekten
Implizite Erzeugung - lokale Variablen
Lokale Variablen
i n t main ( ) {myClass a ; / / Defau l t−Kons t ruk to ryourClass b ( 3 ) ; / / b e n u t z e r d e f i n i e r t e r Kons t ruk to r. . .return 0;
}
I werden auf dem Stapel angelegtI beim Betreten des Sichtbarkeitsbereichs: KonstruktorI beim Verlassen des Sichtbarkeitsbereichs: Destruktor
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 44 / 59
Klassen Erzeugung von Objekten
Implizite Erzeugung - Felder
Felder einer Klasse
class Foo {myClass a ; / / Defau l t−Kons t ruk to ryourClass b ; / / b e n u t z e r d e f i n i e r t e r Kons t ruk to rourClass c ; / / b e n u t z e r d e f i n i e r t e r Kons t ruk to r
Foo ( ) : b ( 3 ) , c ( " Ha l lo " ) { . . . }} ;
I Kind-Objekte werden implizit mit dem Eltern-Objekt erzeugtI Aufruf des Default-Konstruktors durch den CompilerI andere Konstruktoren in der Initializer-Liste
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 45 / 59
Klassen Erzeugung von Objekten
Implizite Erzeugung - global
Globale Variablen
myClass a ; / / Defau l t−Kons t ruk to ryourClass b ( 3 ) ; / / b e n u t z e r d e f i n i e r t e r Kons t ruk to r
I globaler Sichtbarkeitsbereich wird beimI Start der Anwendung betretenI Beenden der Anwendung verlassen
I Compiler erzeugt entsprechende Konstruktor/Destruktor-AufrufeI Vorsicht: Reihenfolge nicht spezifiziert!I Compiler-spezifische Erweiterungen notwendig
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 46 / 59
Klassen Zugriff auf Felder
Zugriff auf nicht-statische FelderZugriff 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;}
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 47 / 59
Klassen Zugriff auf Felder
Zugriff auf nicht-statische FelderZugriff 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;}
I foo->a ist Kurzform für (*foo).aI Syntactic Sugar
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 48 / 59
Klassen Zugriff auf Felder
Zugriff auf statische 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;}
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 49 / 59
Typumwandlung
Typumwandlung in C++
type var = const_cast< type >(param ) ;
I entfernt const-QualifizierungI besser: mutable-Qualifizierung für InstanzvariablenI Ausnahme: existierende API, die kein const unterstützt
void foo ( const char∗ s t r ) {legacy_func ( const_cast< char∗ >( s t r ) ) ;
}
I Achtung: legacy_func darf str nicht verändern!
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 50 / 59
Typumwandlung
Typumwandlung in C++
type var = stat ic_cast < type >(param ) ;
I Konvertierung zwischen Zahlenformaten (z.B. int und float)I Konvertierung zwischen verwandten Zeiger- und Referenztypen
I Typen werden statisch während der Übersetzung aufgelöstI Achtung: Typdefinition muss bekannt sein
I Deklaration ist nicht ausreichend ; ÜbersetzungsfehlerI this-Zeiger werden bei Bedarf angepasst
I z.B. im Falle der Mehrfachvererbung
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 51 / 59
Typumwandlung
Typumwandlung in C++
type var = dynamic_cast< type >(param ) ;
I Konvertierung zwischen verwandten Zeiger- und ReferenztypenI wird dynamisch während der Laufzeit aufgelöstI Typinformation notwendig ; RTTI
I FehlerfallI Zeiger: 0 wird zurück gegebenI Referenzen: bad_cast-Ausnahme wird geworfen
I nur mit polymorphen Typen möglich ; virtuelle MethodenI Alternative: dynamic dispatch durch virtuelle Funktionen
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 52 / 59
Typumwandlung
Typumwandlung in C++
type var = re interpret_cast < type >(param ) ;
I erzwungene Reinterpretation einer bestimmten SpeicherstelleI ähnlich zu Typumwandlungen für Zeiger in C
( 6= Typumwandlung im C-Stil)I keine Überprüfung - weder zur Übersetzungs- noch zur LaufzeitI in der Regel: Finger weg!
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 53 / 59
Typumwandlung
Typumwandlung im C-Stil
class A { . . . } ;class B : public class A { . . . } ;
A∗ a = new A ( ) ; / / OKB∗ b = new B ( ) ; / / OKA∗ pa = b ; / / OKB∗ b1 = a ; / / FehlerB∗ b2 = pa ; / / FehlerB∗ b3 = (B∗ ) pa ; / / OK ( mi t e in facher Vererbung )B∗ b4 = (B∗ ) a ; / / Fehler ( n i c h t erkennbar )
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 54 / 59
Typumwandlung
Typumwandlung im C-Stil (considered harmful)
I 6= Typumwandlung in CI probiert verschiedene C++-Typumwandlungen:
1. const_cast2. static_cast3. static_cast, dann const_cast4. reinterpret_cast5. reinterpret_cast, dann const_cast
I das Ergebnis unterscheidet sich, je nachdem obI alle Header eingebunden wurden 7→ static_cast oderI nur eine Deklaration verfügbar ist 7→ reinterpret_cast
I solange es irgendwie geht: Finger weg!I Problem: Verwendung von C-Bibliotheken in C++-Programmen
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 55 / 59
Namensräume
I Java: PackagesSchlüsselwort package
package Bar ;
public class Foo { . . . }
I Vollständiger Name der Klasse “Foo”: Bar.FooI C++: Namensräume
Schlüsselwort namespace
namespace Bar {
class Foo { . . . } ;}
I Vollständiger Name der Klasse “Foo”: Bar::Foo
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 56 / 59
Templates
Funktionstemplates
I Zweck: generische FunktionI verschiedene ParametertypenI verschiedene Rückgabetypen
I Syntax:
template < class class_name > d e c l a r a t i o ntemplate < type type_name > d e c l a r a t i o n
I Beispiel:
template < type T > T max(T a , T b ) {return a > b ? a : b ;
}
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 57 / 59
Templates
Klassentemplates
I Zweck: parametrisierbare KlassenI Syntax:
template < class class_name > d e c l a r a t i o ntemplate < type type_name > d e c l a r a t i o n
I Beispiel:
template < type T , i n t I > class Tuple {T content [ I ] ;
public :T get ( i n t i ) { return content [ i ] ; }void set (T val , i n t i ) { content [ i ] = va l ; }
} ;
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 58 / 59
Literatur
Bruce Eckel.Thinking in C++.Prentice Hall PTR, Upper Saddle River, NJ, USA, 1995.
Thomas Strasser.C++ Programmieren mit Stil.dpunkt Verlag, 1997.
Bjarne Stroustrup.The C++ Programming Language.Addison-Wesley, 1997.
Andre Willms.C++ - Einstieg für Anspruchsvolle.Addison-Wesley, 2005.
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4) Von Java/C nach C++ WS 2009/10 59 / 59