Von Java/C nach C++ Fokus Der bekannteste Unterschied

Überblick
1
Primitive Datentypen
2
Komplexe Datentypen
3
Funktionen
Fabian Scheler, Peter Ulbrich, Niko Böhm
4
Zeiger und Parameterübergabe
Friedrich-Alexander-Universität Erlangen-Nürnberg
Lehrstuhl Informatik 4 (Verteilte Systeme und Betriebssysteme)
www4.informatik.uni-erlangen.de
5
Klassen
6
Typumwandlung
7
Namensräume
8
Templates
Von Java/C nach C++
21. Oktober 2008
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Fokus
Von Java/C nach C++
21. Oktober 2008
1 / 59
Generelles
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
2 / 59
Generelles
Der bekannteste Unterschied
Worum geht es hier nicht?
Standardbibliothek
Java-Programme werden auf einer virtuellen Maschine
ausgeführt:
Speicherverwaltung
mächtiges Laufzeitsystem (z.B. Garbage Collection)
Typinformation
dynamische Laden von Klassen
Überprüfungen zur Laufzeit
...
Ein- und Ausgabe
Warum geht es nicht darum?
Weil wir es hier nicht brauchen!
C++-Programme werden auf der nackten Hardware ausgeführt:
kein Laufzeitsystem
keine Typinformation
Ausnahme: RTTI und Exceptions (teuer!)
Worum es geht?
Abbildung von Java auf C++
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++
21. Oktober 2008
3 / 59
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
4 / 59
Primitive Datentypen
Primitive Datentypen
Primitive Datentypen in Java und C++
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):
Bezeichner
boolean
char
byte
short
int
long
float
double
void
primitive Datentypen in Java sind exakt spezifiziert
primitive Datentypen in C++ sind hochgradig abhängig von der
Implementierung
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
5 / 59
Primitive Datentypen
Java
min
Unicode 0
-128
−215
−231
−263
IEEE754
IEEE754
-
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
max
Unicode 216 − 1
127
215 − 1
231 − 1
263 − 1
IEEE754
IEEE754
-
Bezeichner
bool
char
signed char
unsigned char
signed short
unsigned short
signed int
unsigned int
signed long
unsigned long
float
double
long double
void
Von Java/C nach C++
max
Unicode 216 − 1
127
215 − 1
231 − 1
263 − 1
IEEE754
IEEE754
-
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Bezeichner
bool
char
signed char
unsigned char
signed short
unsigned short
signed int
unsigned int
signed long
unsigned long
float
double
long double
void
C++
Größe
8 Bit
8 Bit
8 Bit
16 Bit
16 Bit
32 Bit
32 Bit
32 Bit
32 Bit
32 Bit
64 Bit
96 Bit
-
min
-128
-128
0
−215
0
−231
0
−231
0
-
Von Java/C nach C++
max
+127
+127
255
215 − 1
216 − 1
231 − 1
232 − 1
231 − 1
232 − 1
-
21. Oktober 2008
6 / 59
Wie löst man dieses Problem?
Diese Angaben für C++-Datentypen gelten z.B. auf einem H8/300 mit
dem GNU C Compiler (Version 3.4):
Größe
16 Bit
8 Bit
16 Bit
32 Bit
64 Bit
32 Bit
64 Bit
-
Java
min
Unicode 0
-128
−215
−231
−263
IEEE754
IEEE754
-
Primitive Datentypen
Primitive Datentypen - Übersicht
Bezeichner
boolean
char
byte
short
int
long
float
double
void
Größe
16 Bit
8 Bit
16 Bit
32 Bit
64 Bit
32 Bit
64 Bit
-
C++
Größe
8 Bit
8 Bit
8 Bit
16 Bit
16 Bit
16 Bit
16 Bit
32 Bit
32 Bit
32 Bit
32 Bit
32 Bit
-
min
-128
-128
0
−215
0
−215
0
−231
0
-
typedef unsigned char
// ..
typedef long long
typedef e z s t u b s _ u i n t 3 2
max
+127
+127
255
215 − 1
216 − 1
215 − 1
216 − 1
231 − 1
232 − 1
-
21. Oktober 2008
Abbildung auf wohldefinierte Typen
Abbildung
ezstubs_uint8 ;
ezstubs_int64 ;
ezstubs_addrword ;
ausschließliche Verwendung der wohldefinierten Typen
Verwendung
e z s t u b s _ u i n t 3 2 MyClass : : myMethod ( ) {
// ...
}
7 / 59
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
8 / 59
Primitive Datentypen
Konstanten in Java:
Konstanten
Primitive Datentypen
Konstanten in C++:
Konstanten
Präprozessor
# define PI 3.14159
Keyword 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++
Primitive Datentypen
Konstanten in C++:
Schlecht, weil:
rein textuelle Ersetzung
keine Typprüfung möglich
21. Oktober 2008
9 / 59
Konstanten
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Arrays
Keyword const
Von Java/C nach C++
Komplexe Datentypen
21. Oktober 2008
10 / 59
21. Oktober 2008
12 / 59
Java
Arrays
const unsigned i n t k o n s t a n t e = 5 ;
i n t [ ] i = new i n t [ 5 ] ;
O b j e c t [ ] o = new O b j e c t [ 1 0 ] ;
muss initialisiert werden
nicht nur eine Reihung von Objekten gleichen Typs
ermöglicht Typüberprüfung
Arrays sind Objekte
Zusicherung des Programmierers an den Übersetzer!
Unterschied zu C: benötigt nicht unbedingt Speicherplatz
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
11 / 59
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
Klassen
Komplexe Datentypen
Java
Arrays
Komplexe Datentypen
C++
Schlüsselwort class
Arrays
class Foo {
private int x ;
int i [10];
myClass myClassObjects [ CONST_EXPRESSION ] ;
public i n t Bar ( ) {
return x ;
}
}
sind keine Objekte
einfache Aneinanderreihung von Objekten gleichen Typs
...
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Aufzählung
Von Java/C nach C++
Komplexe Datentypen
21. Oktober 2008
13 / 59
C++
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Verbund
Von Java/C nach C++
Komplexe Datentypen
21. Oktober 2008
14 / 59
C++
Schlüsselwort union
union TCSR {
unsigned char v a l ;
struct {
unsigned char OCLRA : 1 ;
unsigned char OVF
: 1;
...
unsigned char ICFA : 1 ;
} bits ;
};
Schlüsselwort enum
enum Wochentage {
Montag ,
Dienstag ,
...
Sonntag
};
fasst eine Menge von Werten zu einem eigenständigen Typen
zusammen
val und bits sollten gleich groß sein
unterschiedliche Interpretationen für den denselben
Speicherbereich
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
15 / 59
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
16 / 59
Komplexe Datentypen
Strukturen und Klassen
C++
Komplexe Datentypen
Benutzerdefinierte Typen
Schlüsselwort struct
Schlüsselwort class
Schlüsselwort typedef
s t r u c t Foo {
...
};
class Bar {
...
};
typedef type_A type_B ;
C++
type_B kann synonym zu type_A verwendet werden
Vorsicht bei Forward Declarations und typedef
Forward Declaration != typedef
Strukturen und Klassen sind in C++ fast äquivalent
Unterschied: Sichtbarkeit
typedef my_Class_A my_Class_B ;
...
class my_Class_B ;
Strukturen: standardmäßig public
Klassen: standardmäßig private
zu Klassen später mehr . . .
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
obiges Beispiel wird eine Fehlermeldung beim Übersetzen liefern!
Von Java/C nach C++
Funktionen
21. Oktober 2008
17 / 59
Definition
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
Funktionen
Funktionsdefinitionen in Java
21. Oktober 2008
18 / 59
Definition
Funktionsdefinitionen in C++
Funktionsdefinition im Klassenrumpf
Funktionsdefinition im Klassenrumpf
class Foo {
i n t Bar ( i n t i ) { r e t u r n
};
class Foo {
public i n t a ;
public i n t Bar ( i n t i ) {
return i + a ;
}
}
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 ) { r e t u r n i + 5 ; }
Alle Funktionen sind Methoden genau einer Klasse
Keine globalen Funktionen
Funktionen werden immer im Klassenrumpf definiert
Funktionsdefinition innerhalb oder außerhalb des Klassenrumpfs
auch globale Funktionen sind erlaubt
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
19 / 59
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
20 / 59
Funktionen
Überladen
Funktionen
Einbettung von Funktionen
Überladen von Funktionen in Java
void Bar ( i n t i ) { . . . }
void Bar ( long l ) { . . . }
void Bar ( O b j e c t o ) { . . . }
O b j e c t Bar ( i n t i ) { . . . }
O b j e c t Bar ( O b j e c t o , i n t i ) { . . . }
//
//
//
//
//
OK
Fehler
OK
Fehler
Fehler
//
//
//
//
//
OK
Fehler
OK
Fehler
OK
Überladen von Funktionen in C++
void Bar ( i n t i ) { . . . }
void Bar ( long l ) { . . . }
void Bar ( O b j e c t o ) { . . . }
O b j e c t Bar ( i n t i ) { . . . }
O b j e c t Bar ( O b j e c t o , i n t i ) { . . . }
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
Funktionen
Einbettung von Funktionen
21. Oktober 2008
Einbettung
Original
Eingebettet
int inc ( int a) {
return a + 1;
}
i n t main ( ) {
int a = 2;
a = inc (a ) ;
a = inc (a ) ;
a = inc (a ) ;
return 0;
}
i n t main ( ) {
int a = 2;
{ i n t a_temp
a = a_temp
{ i n t a_temp
a = a_temp
{ i n t a_temp
a = a_temp
return 0;
}
=
+
=
+
=
+
a;
1; }
a;
1; }
a;
1; }
Semantik der Parameterübergabe bleibt erhalten
(hier call by value)
21 / 59
Einbettung
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
Funktionen
21. Oktober 2008
22 / 59
Einbettung
Einbettung von Funktionen in Java
Schlüsselwort final
class Bar {
f i n a l i n t Foo ( ) { . . . }
}
Einbettung ist nicht gleich textueller Ersetzung
das macht der Präprozessor
Vorteil: Man spart den Overhead des Funktionsaufrufs
Gefahr: Code Bloat
Es gibt kein explizites Inlining in Java!
Achtung: sehr schwer die optimale Inlining-Strategie zu finden!
Schlüsselwort final signalisiert dem Compiler: diese Methode wird
nicht mehr überschrieben!
Solche Methoden kann der Compiler einbetten
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
23 / 59
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
24 / 59
Funktionen
Einbettung
Funktionen
Einbettung von Funktionen in C++
Beispiele
durch Definition im Klassenrumpf
class Foo {
/ / Zuweisungsoperator
Foo operator =( Foo v a l ) ;
/ / Typkonvertierung
operator Bar ( ) ;
};
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 ) { r e t u r n i + 5 ; }
Syntactic Sugar
Definition muss beim Aufruf für den Compiler sichtbar sein
keine echten benutzerdefinierten Operatoren
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++
Zeiger und Parameterübergabe
Was sind Zeiger
Operatoren
Operatoren entsprechen normalen Funktionen
21. Oktober 2008
gewisse Operatoren können nicht überladen werden
Präzedenz kann nicht beeinflusst werden
25 / 59
Zeiger
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
Zeiger und Parameterübergabe
Verwendung von Zeigern
ein Zeiger ist ein Tripel (Typ, Bezeichner, Wert)
Wert eines Zeigers: eine Adresse
Semantik eines Zeigers: an der Adresse findet man ein Objekt
vom Typ Typ
Java: alle komplexen Datentypen sind Zeiger
C++: wählbar
21. Oktober 2008
26 / 59
Zeiger
Deklaration:
int ∗ i ;
MyClass∗ f o o ;
Zugriff auf den referenzierten Wert:
Operator *
∗ i = 5;
int
ptr_int
0x0ae0
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Wo kommen Zeiger her?
0x0ae0
int
Von Java/C nach C++
21. Oktober 2008
27 / 59
Operator &
Operator new
int i ;
int ∗ ptr_to_i = &i ;
Foo∗ f = new Foo ( ) ;
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
28 / 59
Referenzen
Zeiger und Parameterübergabe
Zeiger
Zeiger und Parameterübergabe
C++
≈ konstanter Zeiger, der automatisch dereferenziert wird
muss initialisiert werden
Verwendung:
primitive Datentypen: call by value
komplexe Datentypen: call by reference
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 b y _ r e f e r e n c e ( i n t ∗ i , Foo& f ) ;
int i = 6;
in t& c = i ;
Foo bar ;
Foo& f o o b a r = bar ;
int i = 5;
Foo f ;
i n t main ( ) {
by_value ( i , f ) ;
b y _ r e f e r e n c e (& i , f ) ;
return 0;
}
c = 5;
/ / i == 5 !
f o o b a r . bar_method ( )
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Parameterübergabe
Java
Von Java/C nach C++
21. Oktober 2008
29 / 59
Klassen
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
/ / c a l l by v a l u e
/ / c a l l by r e f e r e n c e
Von Java/C nach C++
Klassen
Klassen in Java und C++
... sind im Großen und Ganzen sehr ähnlich, vor allem, was das
Konzept betrifft
Java
C++
class Foo {
public i n t a ;
protected i n t b ;
private int c ;
public i n t Bar ( ) {
...
}
}
class Foo {
private :
int c ;
protected :
int b;
public :
int a;
i n t Bar ( ) { . . . }
};
Angabe der Sichtbarkeit
für jedes Feld einer Klasse
einzeln
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
30 / 59
Sichtbarkeit
Sichtbarkeit von Klassenfeldern
21. Oktober 2008
31 / 59
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
Angabe der Sichtbarkeit
für eine Gruppe von
Feldern einer Klasse
21. Oktober 2008
32 / 59
Klassen
Statische Felder
Klassenvariablen - statische Felder
Einfache Vererbung
Deklaration wie in Java
Schlüsselwort static
class Foo {
s t a t i c i n t bar ;
s t a t i c void f o o b a r ( ) ;
};
Klassen
Vererbung
Java
C++
class Foo extends Bar {
...
}
class Foo : public Bar {
...
};
Felder und Methoden der
Basisklasse werden public
vererbt.
In C++ muss aber Speicher angefordert werden:
i n t Foo : : bar = 0 ;
Sichtbarkeit von Feldern
und Methoden der
Basisklasse muss
spezifiziert werden.
Vorsicht: static für globale Variablen/Funktionen existiert, hat
aber eine andere Bedeutung!
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
Klassen
Sichtbarkeit und Vererbung
Basisklasse
public
protected
private
21. Oktober 2008
33 / 59
Vererbung
Vererbung
public
protected
private
public
protected
private
public
protected
private
Wozu ist das gut?
Klassen
21. Oktober 2008
34 / 59
Vererbung
Schnittstelle
/ / n o t s y n c h ro n iz e d
class MyClass {
public :
myMethod ( ) ;
};
/ / s y n c h ro n iz e d
class MyGuardedClass
: protected myClass
{
public :
myMethod ( ) ;
};
Interface- vs. Implementation-Inheritance
default: private
Von Java/C nach C++
Von Java/C nach C++
Definition von Benutzerschnittstellen
Beispiel: Unterbrechungssynchronisation
Klasse
public
protected
private
protected
protected
private
private
private
private
Vorsicht: protected/private-Vererbung ändert die Schnittstelle
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
21. Oktober 2008
35 / 59
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Verwendung
MyGuardedClass myObject ;
/ / OK
myObject . myMethod ( ) ;
/ / Compiler F e h l e r
myObject .
MyClass : : myMethod ( ) ;
Von Java/C nach C++
21. Oktober 2008
36 / 59
Mehrfache Vererbung
Klassen
Vererbung
Polymorphismus
class Foo
: public Bar1 , protected Bar2 ,
{
...
};
i n t main ( ) {
Oberklasse ∗ o ;
U n t e r k l a s s e 1 ∗ u1 = new U n t e r k l a s s e 1 ( ) ;
U n t e r k l a s s e 2 ∗ u2 = new U n t e r k l a s s e 2 ( ) ;
. . . p r i v a t e Barn
/ / Unterklasse1 : : foo ( )
o = u1 ;
o−>f o o ( ) ;
/ / Unterklasse2 : : foo ( )
o = u2 ;
o−>f o o ( ) ;
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!
Virtuelle Methoden
Polymorphismus und virtuelle Methoden
Auswahl der Methode zur Laufzeit
Mehrfachvererbung
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Klassen
Von Java/C nach C++
Klassen
21. Oktober 2008
}
37 / 59
Polymorphismus und virtuelle Methoden
return 0;
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
Klassen
21. Oktober 2008
38 / 59
21. Oktober 2008
40 / 59
Abstrakte Klassen und Interfaces
Schnittstellenbeschreibungen
Klassen
Interfaces in Java
Schlüsselwort interface
Polymorphismus nur bei virtuellen Methoden
in Java sind alle Methoden virtuell
i n t e r f a c e Comparable {
public i n t compare ( O b j e c t o ) ;
}
in C++ müssen Methoden als virtuell deklariert werden
Schlüsselwort virtual
class Foo {
v i r t u a l void bar ( ) ;
};
Abstrakte Klassen in C++: rein virtuelle Methoden
class Comparable {
public :
v i r t u a l i n t compare ( O b j e c t o ) = 0 ;
};
Vorsicht: Virtuelle Methoden sind teuer!
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
39 / 59
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
Konstruktoren
Klassen
Konstruktoren und Destruktoren
Destruktoren
sehr ähnlich zu Java
Reihenfolge:
1
2
räumt ein Objekt auf, wenn seine Lebenszeit endet
Reihenfolge:
1
2
Achtung: Reihenfolge der Basisklassenkonstruktoren bei
Mehrfachvererbung ist nicht immer definiert!
Unterschied: kein super
Basisklassenkonstruktor in der Initializer-list des Konstruktors
Es gibt für jede Klasse genau einen Destruktor!
Syntax
class Foo {
Foo ( ) { . . }
~Foo ( ) { . . }
};
nicht notwendig bei Default-Konstruktoren
Von Java/C nach C++
Klassen
21. Oktober 2008
41 / 59
Erzeugung von Objekten
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
/ / Konstruktor
/ / Destruktor
Von Java/C nach C++
Klassen
21. Oktober 2008
42 / 59
Erzeugung von Objekten
Implizite Erzeugung - lokale Variablen
Lokale Variablen
dynamische Erzeugung von Objekten mit dem Operator new
i n t main ( ) {
myClass a ;
/ / D e f a u l t −K o n s t r u k t o r
yourClass b ( 3 ) ; / / b e n u t z e r d e f i n i e r t e r K o n s t r u k t o r
...
return 0;
}
MyClass∗ mc = new MyClass ( ) ;
liefert einen Zeiger auf das erzeuge Objekt
benötigt dynamische Speicherverwaltung
Vorsicht: Speicher mit delete wieder freigegeben!
d e l e t e mc ;
werden auf dem Stapel angelegt
beim Betreten des Sichtbarkeitsbereichs: Konstruktor
Keine Garbage Collection!
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Destruktor der eigentlichen Klasse
Destruktor der Basisklasse
Achtung: Reihenfolge der Basisklassendestruktoren bei
Mehrfachvererbung ist nicht immer definiert!
class Foo : public Bar {
Foo ( ) : Bar ( ) {
...
}
};
Explizite Erzeugung
Konstruktoren und Destruktoren
ähnelt dem finalize aus Java
Konstruktor der Basisklasse
Konstruktor der eigentlichen Klasse
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Klassen
Von Java/C nach C++
beim Verlassen des Sichtbarkeitsbereichs: Destruktor
21. Oktober 2008
43 / 59
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
44 / 59
Klassen
Erzeugung von Objekten
Klassen
Implizite Erzeugung - Felder
Felder einer Klasse
class Foo {
myClass a ;
yourClass b ;
ourClass c ;
};
Erzeugung von Objekten
Implizite Erzeugung - global
Globale Variablen
/ / D e f a u l t −K o n s t r u k t o r
/ / benutzerdefinierter Konstruktor
/ / benutzerdefinierter Konstruktor
Foo ( ) : b ( 3 ) , c ( " H a l l o " ) { . . . }
myClass a ;
/ / D e f a u l t −K o n s t r u k t o r
yourClass b ( 3 ) ; / / b e n u t z e r d e f i n i e r t e r K o n s t r u k t o r
globaler Sichtbarkeitsbereich wird beim
Start der Anwendung betreten
Beenden der Anwendung verlassen
Compiler erzeugt entsprechende Konstruktor/Destruktor-Aufrufe
Kind-Objekte werden implizit mit dem Eltern-Objekt erzeugt
Vorsicht: Reihenfolge nicht spezifiziert!
Aufruf des Default-Konstruktors durch den Compiler
Compiler-spezifische Erweiterungen notwendig
andere Konstruktoren in der Initializer-Liste
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
Klassen
21. Oktober 2008
45 / 59
Zugriff auf Felder
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
Klassen
Zugriff auf nicht-statische Felder
21. Oktober 2008
46 / 59
Zugriff auf Felder
Zugriff auf nicht-statische Felder
Zugriff auf nicht-statische Felder bei Objekten
Zugriff auf nicht-statische Felder bei Zeigern auf Objekte
Operator ->
Operator .
class Foo {
public :
i n t bar_var ;
i n t bar_method ( ) ;
};
class Foo {
public :
i n t bar_var ;
i n t bar_method ( ) ;
};
i n t main ( ) {
int a ,b;
Foo f o o ;
i n t main ( ) {
int a ,b;
Foo∗ f o o = new Foo ( ) ;
a = foo −>b a r _ v a r ;
b = foo −>bar_method ( ) ;
a = foo . bar_var ;
b = f o o . bar_method ( ) ;
}
}
return 0;
return 0;
foo->a ist Kurzform für (*foo).a
Syntactic Sugar
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
47 / 59
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
48 / 59
Klassen
Zugriff auf statische Felder
Zugriff auf Felder
Typumwandlung
Typumwandlung in C++
t y p e v a r = const_cast < t y p e >(param ) ;
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 ( ) {
int a ,b;
entfernt const-Qualifizierung
besser: mutable-Qualifizierung für Instanzvariablen
a = Foo : : b a r _ v a r ;
b = Foo : : bar_method ( ) ;
}
return 0;
Ausnahme: existierende API, die kein const unterstützt
void f o o ( const char ∗ s t r ) {
l e g a c y _ f u n c ( const_cast < char ∗ >( s t r ) ) ;
}
Achtung: legacy_func darf str nicht verändern!
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
49 / 59
Typumwandlung
21. Oktober 2008
50 / 59
t y p e v a r = dynamic_cast< t y p e >(param ) ;
Konvertierung zwischen verschiedenen Zahlenformaten
(z.B. int und float)
Konvertierung zwischen verwandten Zeiger- und Referenztypen
(die Typen werden statisch während der Übersetzung aufgelöst)
nur möglich wenn die Typdefinition bekannt ist (eine Deklaration
alleine reicht nicht aus), ansonsten 7→ Übersetzungsfehler
this-Zeiger werden bei Bedarf angepasst
(z.B. im Falle der Mehrfachvererbung)
Von Java/C nach C++
Von Java/C nach C++
Typumwandlung in C++
t y p e v a r = s t a t i c _ c a s t < t y p e >(param ) ;
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Typumwandlung
Typumwandlung in C++
Konvertierung zwischen verwandten Zeiger- und Referenztypen
(wird dynamisch während der Laufzeit aufgelöst)
Im Fehlerfall wird 0 zurück gegeben (Zeiger) oder eine Ausnahme
bad_cast geworfen (Referenzen).
Ist nur in Verbindung mit polymorphen Typen möglich
(virtuelle Methoden!)
Alternative: dynamic dispatch durch virtuelle Funktionen
21. Oktober 2008
51 / 59
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
52 / 59
Typumwandlung
Typumwandlung
Typumwandlung in C++
Typumwandlung im C-Stil
t y p e v a r = r e i n t e r p r e t _ c a s t < t y p e >(param ) ;
class A { . . . } ;
class B : public class A { . . . } ;
erzwungene Reinterpretation einer bestimmten Speicherstelle
ähnlich zu Typumwandlungen für Zeiger in C
(6= Typumwandlung im C-Stil)
keine Überprüfung - weder zur Übersetzungs- noch zur Laufzeit
in der Regel: Finger weg!
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
53 / 59
A∗
B∗
A∗
B∗
B∗
B∗
B∗
a = new A ( ) ;
b = new B ( ) ;
pa = b ;
b1 = a ;
b2 = pa ;
b3 = (B∗ ) pa ;
b4 = (B∗ ) a ;
//
//
//
//
//
//
//
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Typumwandlung
Von Java/C nach C++
21. Oktober 2008
54 / 59
21. Oktober 2008
56 / 59
Namensräume
Typumwandlung im C-Stil (considered harmful)
Java: Packages
Schlüsselwort package
package Bar ;
6= Typumwandlung in C
probiert verschiedene C++-Typumwandlungen:
1
2
3
4
5
OK
OK
OK
Fehler
Fehler
OK ( m i t e i n f a c h e r Vererbung )
F e h l e r ( n i c h t erkennbar )
public class Foo { . . . }
const_cast
static_cast
static_cast, dann const_cast
reinterpret_cast
reinterpret_cast, dann const_cast
Vollständiger Name der Klasse “Foo”: Bar.Foo
C++: Namensräume
Schlüsselwort namespace
das Ergebnis unterscheidet sich, je nachdem ob
alle Header eingebunden wurden 7→ static_cast oder
nur eine Deklaration verfügbar ist 7→ reinterpret_cast
namespace Bar {
solange es irgendwie geht: Finger weg!
Problem: Verwendung von C-Bibliotheken in C++-Programmen
}
class Foo { . . .
};
Vollständiger Name der Klasse “Foo”: Bar::Foo
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
55 / 59
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
Funktionstemplates
Templates
Klassentemplates
Zweck: parametrisierbare Klassen
Zweck: generische Funktion für verschiedene Parameter- und
Rückgabetypen
Syntax:
Syntax:
template < class class_name > d e c l a r a t i o n
template < t y p e type_name > d e c l a r a t i o n
template < class class_name > d e c l a r a t i o n
template < t y p e type_name > d e c l a r a t i o n
Beispiel:
Beispiel:
template < t y p e T , i n t I > class Tuple {
T content [ I ] ;
public :
T get ( i n t i ) { return content [ i ] ; }
void s e t ( T v a l , i n t i ) { c o n t e n t [ i ] = v a l ; }
};
template < t y p e 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++
21. Oktober 2008
57 / 59
21. Oktober 2008
59 / 59
Literatur
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
Templates
F. Scheler, P. Ulbrich, N. Böhm (Informatik 4)
Von Java/C nach C++
21. Oktober 2008
58 / 59