|
Die Klasse Point bildet die Basisklasse, von ihr werden die Klassen Circle und Line abgeleitet.
Die Klasse Arc ist von der Klasse Circle abgeleitet und damit auch von der Klasse Point,
Vereinbarung der abgeleiteten Klassen:
Bei der Vereinbarung der Klasse gibt man nach einem Doppelpunkt an, von welcher Klasse man erben will.
Daraufhin werden alle Eigenschaften und Methoden auf die man Zugriff hat geerbt (->Zugriffsrechte).
class Circle: public Point {
int r;
public: Circle(int ix,int iy, int ir);
void Show ();
void Hide ();
void MoveTo (int nx, int ny);
};
class Arc: public Circle {
int sangl;
int eangl;
public: Arc(int ix, int iy, int ir, int isangl, int ieangl);
void Show ();
...
};
class Line: public Point {
int x2;
int y2;
public: Move Parallel(int dx, int dy)
...
Implementierung der abgeleiteten Klassen:
Bei der Implementierung des Konstruktors gibt man nach einem Doppelpunkt den Konstruktor der Basisklasse an.
Daraufhin wird auch der Konstruktor der Basisklasse aufgerufen.
Innerhalb einer Funktion muß man aufpassen ob man auf die geerbten Eigenschaften zugreifen kann.
Ansonsten sind Zugriffe nur über Hilfsunktionen ( getx( ), gety( ), ...) möglich
Circle:Circle(int ix,int iy, int ir): Point {int ix, int iy)
{
r= ir;
}
void Circle:Show ()
{
circle (getx(), gety(), r);
}
...
2. Zugriffsrechte
Zugriffsrechte steuern die Zugriffs-Erlaubnis von Eigenschaften und Methoden einer Klasse. Mit ihnen kann man auch festlegen wie sich
abgeleitete Klassen bei der Vererbung verhalten.
Es gibt 3 Typen von Zugriffsrechten:
private nur Methoden der eigenen Klassen dürfen auf Eigenschaften und Methoden der Klasse zugreifen.
Bei einer Vererbung können abgeleitete Klassen nicht direkt auf Eigenschaften und Methoden zugreifen, sondern brauchen Hilfsfunktionen ( getx ( ), gety ( ), .....).
protected Methoden der eigenen und Methoden der abgeleiteten Klassse könnern zugreifen.
Wird verwendet wenn zwar die abgeleitete Klassen, aber keine \"normalen\" Funktionen und fremde Klassen
Zugriff auf die Klasse haben dürfen.
public Alle dürfen auf die Eigenschaften und Methoden der Klasse zugreifen.
Hilfsfunktionen sind sinnvollerweise public. Damit kann z.B jeder private Eigenschaften lesen ( mit getx( ) ) ,
sie aber nicht verändern. (Außer es gibt auch eine Hilffunktion z.B.: setx( int ix);
Bei sauberer Datenkapselung sind alle Eigenschaften private, einige der Methoden public um Zugriff von außen zu ermöglichen.
Zugriffsrechte der gererbten Klasse können in der abgeleiteten Klasse eingeschränkt werden:
class Aklasse: public Bklasse { ... } Zugriffsrechte der geerbten Elemente bleiben unverändert
class Aklasse: protected Bklasse { ... } alle geerbten public - Elemente sind in Aklasse protected
class Aklasse: private Bklasse { ... } alle geerbten public - und protected - Elemente sind in Aklasse private (!!!!DEFAULT)
3. Virtuelle Methoden
Frühe Bindung:
Beim Aufruf einer Element-Funktion wird die Sprung-Adresse bereits zum Übersetzungs-Zeitpunkt festgelegt.
Beispiel:
Point:MoveTo(int nx, int ny)
{
Hide ();
x= nx;
y= ny;
Show();
}
Der Compiler erzeugt den Aufruf von Point::Hide und Point::Show
VT: speicherplatzsparend, schnell
NT: die abgeleitete Klasse Circle muss MoveTo neu definieren obwohl logisch der gleiche Ablauf besteht.
Späte Bindung:
Beim Aufruf einer Element-Funktion wird die tatsächliche Sprung-Adresse erst zu Laufzeit ermittelt.
Dies geschieht in dem man bei der Element-Funktion das Präfix virtual angibt
Beispiel:
class Point {
..
..
public: Point( int ix, int iy);
virtual void Show();
virtual void Hide();
void MoveTo (int nx, int ny);
.....
};
class Circle: public Point {
..
..
public: Circle ( int ix, int iy, int ir);
void Show();
void Hide();
};
Circle::Hide und Circle::Show sind automatisch auch virtuelle Funktionen da die Basisfunktion virtuell ist.
NT: braucht mehr Speicherplatz, langsam
VT: Show und Hide werden in der Funktion MoveTo verwendet, da sie aber virtuelle Funktionen sind
braucht die abgeleitete Klasse Circle MoveTo nicht neu definieren, sondern kann die geerbte Funktion verwenden.
Durch den Einsatz der späten Bindung wird die \"Polymorphie\" ( = Vielgestaltigkeit ) sichergestellt. Die gleiche Methode ist je nach Objektart
unterschiedlich realisiert.
Wann muss eine Methode virtuell sein ?:
wenn sie in den abgeleiteten Klassen unterschiedlich implementiert ist.
wenn Sie in einer anderen Methode der Basisklasse aufgerufen wird ( siehe obiges Beispiel )
wenn man mit Zeigern auf Basisklasse arbeitet. Siehe C-HÜ ARCHOPIE
4. Zugriff auf Objekte mittels Zeigern
Zeiger vom Typ Basisklasse sind teilweise kompatibel mit Zeigern auf abgeleitete Klassen.
Beispiel
Point *pp, p1(100,200);
Circle *pc, c1 (100,200,50);
folgende Operation möglich
pp= &c1;
pp->MoveTo (120,200);
oder
cout GetRadius();
nicht erlaubt ist es umgekehrt z.B.:
pc = &p1;
Hier könnte man die Funktion getRadius aufrufen, die es bei einem
Punkt aber gar nicht gibt, daher VERBOTEN!!
5. Abstrakte Klasse
Abstrakte Klassen dienen nur als Basisklasse für andere Klassen haben aber sonst keine Funktion
Es können keine Objekte angelegt werden. Allerdings kann man Zeiger und Referenzen anlegen.
Eine abstrakte Klasse muss eine abstrakte Funktion (pure virtuel function) enthalten.
Defintion einer abstrakten Funktion
class APoint{
..
..
virtual void Show() = 0;
virtual void Hide() = 0;
...
};
wichtig ist das Angeben des = 0
Erst dies macht sie zu einer abstrakten Funktion
In den abgeleiteten Klassen müssen die abstrakten Funktionen dann durch \"konkrete\" Funktionen ersetzt werden.
6. Info & Download
Diese Seite wurde für ein Auflösung von 1024*768 Pixel und mindestens 256 Farben entworfen.
Bei Fragen,Verbesserungsvorschlägen oder gefundenen Fehlern meldet euch bei Elias Natmessnig
Die gesamte Homepage gibt es auch zum Download: VERERBUNG.ZIP
|
