Programmieren, Algorithmen und Datenstrukturen 2 (Vorlesung 8)

Square / Quadrat

• Ableitung aus der Rechteck-Klasse:
  • „Square“ erbt die Methoden von „Rectangle“
  • ist sehr leicht zu erstellen, da man die Klasse Rectangle 1:1 übernehmen kann

class Square : public Rectangle {
public:

    Square() :
    Rectangle() {
    }

    Square(int x1, int y1, int len) :
    Rectangle(x1, y1, x1 + len, y1 + len) {
    }
};

Mehrfache Vererbung

• Hinweise:
  • Kommt nicht in der Klausur vor!!
  • Wenn möglich vermeiden!!
• Aufbau:
  • Abgeleitete Klassen mit mehreren Basisklasse
  • Zulässig in C++
  • Sämtliche Eigenschaften der Basisklassen gelten für die abgeleitete Klasse
  • Es ist aber auch möglich, dass eine Abgeleitete Klasse eine Vorfahrensklasse mehrfach besitzt
• Vorteil:
  • Mehr Flexibilität
• Nachteil:
  • Hohe Komplexität
  • Schwierig zu debuggen

Schnittstellen-Klassen

• Wenn eine abgeleitete Klasse bei Mehrfachvererbung zwei mal die gleich lautende Methode überschreiben müsste, werden Schnittstellen-Klassen verwendet
• Die Schnittstellen-Klassen dienen nur dazu, neue Namen für die draw()-Methoden einzuführen, damit diese neuen virtuellen Methoden ausgeführt werden, wenn Shape::draw() bzw. Framebuffer::draw() aufgerufen wird
• Man sollte immer nur eine Methode mit diesem Namen haben, Bsp.:

//Größe berechnen
sz*sizeof(double);

// Speicherzugriffsverletzung
MyV[sz]

 Explicit

• Wenn nur ein Argument übergeben wird, dann muss explicit definiert werden, sonst versucht der Konstruktur das mitgegebene Argument umzuwandeln in den Typen,
• z.B.: myVector -> int in einen Vector casten

explicit myVector( int s ): sz( s ), elem( new double[s] ) {
for( int i=0; i}

Schnittstellen-Klasse „myVec“

• Gibt dem Indexoperator für den Typ „myVector“ frei vom Benutzer definierbare Indexgrenzen

class myVector {
    int sz;
    double* elem;
public:

    myVector() : sz(0), elem(0) {
    }

    explicit myVector(int s) : sz(s), elem(new double[s]) {
	for (int i = 0; i < s; ++i) elem[i] = 0.0;
    }

    ~myVector() {
	delete[] elem;
	elem = 0;
    }
    //…
    double& operator[](int);
};

double& myVector::operator[](int index) {
    if (0 > index || sz <= index) error("myVector::invalid_index\n");
    return elem[index];
};

class myVec : public myVector {
public:

    myVec() : myVector() {
    }

    myVec(int low, int high)
    : myVector(high - low + 1) {
	lb = low;
    }

    double& operator[](int i) {
	return myVector::operator[](i - lb);
    }

    int lo() const {
	return lb;
    }

    int hi() const {
	return lb + size() - 1;
    }
private:
    int lb;
};