4. Objektorientierte Konzepte

Inhalt:

4.1 Datenschutz
4.2 Überladen von Operatoren
4.3 Namensräume
4.4 Templates
4.5 Beispiele
4.6 Übungen

4.1 Datenschutz

• Vollständige Klassen-Deklaration:

       class whatever {
       private:
           // ...
  
       protected:
           // ...
  
       public:
           // ...
       }; 

  Die verschiedenen Bereiche geben an wer Zugriff hat, wobei Zugriff hier lesen und schreiben bei Attributen und aufrufen bei Methoden bedeutet. Im Detail:

  private:

  Nur die Methoden der Klasse selbst haben Zugriff auf die Attribute und Methoden die als "private" markiert sind. Abgeleitete Klassen und sonstige Funktionen haben keinen Zugriff.

  public:

  Sowohl die Klasse selbst als auch abgeleitete Klassen und die Öffentlichkeit hat Zugriff.

  protected:

  Die Klasse selbst und von ihr abgeleitete Klassen haben Zugriff. Sonstige Funktionen bleiben außen vor.

• Default-Zugriff bei "class" ist "private", und bei "struct" "public".

• Bedeutung bei Vererbung:

       class foo : public bar {
         ...
       }; 

  Bei Vererbung kann angegeben werden, wie die geerbten Attribute und Methoden weitergegeben werden:

  public:

  public-Member bleiben in der abgeleiteten Klasse public, protected-Member bleiben protected. Implementierung von "ist ein".

  protected:

  public und protected-Members sind in der abgeleiteten Klasse protected. Implementierung von "implementiert durch".

  private:

  public und protected-Members sind in der abgeleiteten Klasse private. Striktere Implementierung von "implementiert durch".

• Eine Klasse kann mittels "friend"-Deklaration angeben, dass eine Methode einer anderen Klasse oder eine Funktion die zu keiner Klasse gehoert auf die Attribute zugreifen (schreiben und lesen) darf:

       class Complex {
       private:
           double re, im;
  
       public:
           Complex(double r=0.0, double i=0.0){ re=r; im=i; }
           friend void print_Complex(Complex &x);
       };
  
       // Friend-Funktion von Complex, gehoert nicht zur Klasse Complex
       // aber darf auf private Members zugreifen
       //
       void print_Complex(Complex &c)
       {
           cout << c.re << "+" << c.im << "i" << endl;
       }
  
       int main(void)
       {
           Complex x;
           print_Complex(x);
       
         

4.2 Überladen von Operatoren

• Einführendes Beispiel: Komplexe zahlen addieren

  class Complex {
          double re, im;
          
  public:
          Complex(double r=0.0, double i=0.0){ re=r; im=i; }
          void print(void){ printf("(%.2f+%.2fi)", re, im); }
  
          // Deklaration Member-Funktion:
          Complex add(Complex op);
  
          // Deklaration globale (-> friend) Funktion:
          friend Complex sub_Complex(Complex a, Complex b);
  };
  
  // Definition Member-Funktion:
  Complex Complex::add(Complex op)
  {
          return Complex(re + op.re, im + op.im);
  }
  
  // Definition globale Funktion:
  Complex sub_Complex(Complex a, Complex b)
  {
          return Complex(a.re - b.re, a.im - b.im);
  }
  
  // Hauptprogramm:
  int main(void)
  {
          Complex a(1,0), b(0,1), c(0,0), d(0,0);
          printf("a="); a.print(); printf(", ");
          printf("b="); b.print(); printf("\n");
  
          // Abwendung Member-Funktion:
          c = a.add(b);
          printf("c="); c.print(); printf("\n");
          
          // Anwendung globale Funktion:
          d = sub_Complex(a,b);
          printf("d="); d.print(); printf("\n");
          
          return 0;
  }
  

  Ausgabe:

  a=(1.00+0.00i), b=(0.00+1.00i)
  c=(1.00+1.00i)
  d=(1.00+-1.00i)
  

  (Quellcode)

• Die meisten der C++-Operatoren können überladen werden, d.h. mit eigenen Funktionen hinterlegt werden, die dann auf die eigenen Klassen angewendet werden.

• Beispielklasse für komplexe Zahlen:

  class Complex {
          ...
  
          // Deklaration Member-Funktion:
          Complex operator+(Complex op);
  
          // Deklaration globale (-> friend) Funktion
          friend Complex operator-(Complex a, Complex b);
  };
  
  // Member-Funktion:
  Complex Complex::operator+(Complex op)
  {
          return Complex(re + op.re, im + op.im);
  }
  
  // Globale Funktion:
  Complex operator-(Complex a, Complex b)
  {
          return Complex(a.re - b.re, a.im - b.im);
  } 

• Beispielanwendung:

  int main(void)
  {
          Complex a(1,0), b(0,1), c(0,0);
          
          c = a + b;
          printf("c="); c.print(); printf("\n");
          
          d = a - b;
          printf("d="); d.print(); printf("\n");
          
          return 0;
  }
  

• Überladbare Operatoren:

  Overloadable operators
  + - * / = < > += -= *= /= << >> <<= >>= == != <= >= ++ -- % & ^ ! | ~ &= ^= |= && || %= [] () , ->* -> new delete new[] delete[]

  Expression	Operator	Member function	Global function
  @a	+ - * & ! ~ ++ --	A::operator@()	operator@(A)
  a@	++ --	A::operator@(int)	operator@(A,int)
  a@b	+ - * / % ^ & | < > == != <= >= << >> && || ,	A::operator@ (B)	operator@(A,B)
  a@b	= += -= *= /= %= ^= &= |= <<= >>= []	A::operator@ (B)	-
  a(b, c...)	()	A::operator() (B, C...)	-
  a->x	->	A::operator->()	-

  Where a is an object of class A, b is an object of class B and c is an object of class C.

  (Quelle)

• Weiterhin kann der "<<"-Operator überladen werden, wodurch die iostream-Bibliothek durch eigene Klassen ergänzt werden kann:

  class Complex {
      ...
  
      // Achtung!
      // Keine Member-Funktion, sondern hier nur inline Deklariert!!!
      // 
      friend ostream& operator<<(ostream &os, Complex &c) {
        os << c.re << "+" << c.im << "i";
        return os;    // Für weitere Ausgaben
      }
  };
  
  int main(void)
  {
      int i = 17;
      double f = 4.2;
      Complex a(1,0), b(0,1), c(0,0), d(0,0);
  
      c = a + b;
      d = a - b;
      
      cout << "i=" << i << endl;
      cout << "f=" << f << endl;
      cout << "c=" << c << endl;
      cout << "d=" << d << endl; 

  Ausgabe:

  i=17
  f=4.2
  c=1+1i
  d=1+-1i 

  (Quellcode)

• Man beachte daß die operator<<-Funktion keine Member-Funktion der Klasse Complex ist. Aus diesem Grund hat Sie auch zwei Parameter. Die friend-Deklaration hilft, auf die privaten Attribute des Complex-Arguments zuzugreifen.

4.3 Namensräume

• Namensräume (Namespaces) helfen, Namenskonflikte zu vermeiden.
• Deklarieren, aus welchem Namensraum Symbole benutzt werden sollen:

       #include <iostream>
       using namespace std; 

• Beispiel:
  • hersteller1.h:

    class String {
            ...
    }; 

  • hersteller2.h:

    class String {
            ...
    }; 

  • Hauptprogramm:

    #include "hersteller1.h"
    #include "hersteller2.h"
    
    String s; // Welche String-Klasse wird verwendet? 

• Lösung mit Namespaces
  • hersteller1.h:

    namespace Hersteller1 {
            class String {
                    ...
            };
    } 

  • hersteller2.h:

    namespace Hersteller2 {
            class String {
                    ...
            };
    } 

  • Hauptprogramm:

    #include "hersteller1.h"
    #include "hersteller2.h"
    
    using namespace Hersteller1;
    String s1;
    
    Hersteller2::String s2; 

• Mehr: "C++ Namespaces" von Glen McCluskey & Associates, Stand 10.1.2007

4.4 Templates

• Templates erlauben, Klassen unabhängig von den in ihnen gespeicherten Typen zu halten. Interessant für sog. Container-Klassen für Listen, Bäume, Stacks, etc.

• C++ bietet in der C++ Standard Library selbst eine Auswahl an fertigen Templates, die Standard Template Library bietet weitere Templates an:
  • C++ Standard Library
  • Standard Template Library

• Beispiel: Komplexe Zahlen aus der C++ Standard Library benutzen

      #include <complex>
      
      int main(void)
      {
          complex<double> a(1.0, 0.0);
          complex<double> b(0.0, 1.0);
          complex<double> c(0.0, 0.0);
      
          c = a + b;
      
          cout << a << "+" << b << "=" << c << endl; 

  Ausgabe:

       (1,0)+(0,1)=(1,1) 

  (Quellcode)

• Zum erstellen eigener Templates ist jeweils anzugeben daß die Klassendeklaration als Template zu sehen ist, mit einem oder mehreren Datentypen als Argument, die dann auch beim Instantiieren angegeben werden, siehe oben.

• Ausgangsbeispiel: Klasse für komplexe Zahlen mit festen Daten als double

       class Complex {
            double re, im;
  
       public:
            Complex(double r=0.0, double i=0.0){ re=r; im=i; }
            Complex operator+(Complex op); 
            friend ostream& operator<<(ostream &os, Complex &c);
       };
  
       Complex Complex::operator+(Complex op);
       {
           // Achtung, folgende Funktionen werden im Folgenden aufgerufen,
           // und muessen damit definiert sein:
           // 
           // 1) double operator+(double, double)
           // 2) Complex(double, double)
           //
           return Complex(re + op.re, im + op.im);
       }
  
       ostream& operator<<(ostream &os, Complex &c);
       {
           // Achtung, folgende Funktion wird im Folgenden aufgerufen,
           // und muß damit definiert sein:
           //
           // ostream &operator<<(ostream &, double)
           // 
           os << c.re << "+" << c.im << "i";
           return os;
       }
       
       int main(void)
       {
           Complex a(1.0, 0.0);
           Complex b(0.0, 1.0);
           Complex c(0.0, 0.0);
      
           c = a + b;
      
           cout << a << "+" << b << "=" << c << endl; 
      } 

• Ziel: Klasse für komplexe Zahlen als Template mit beliebigen Datentypen für Real- und Imaginärteil. Voraussetzungen: Addition und Ausgabe mittels << müssen definiert sein!

• Beispiel: Klassendefinition für komplexe Zahlen als Template

  template <typename DATA>
  class Complex {
      DATA re, im;
  
  public:
      Complex<DATA>(DATA r=0.0, DATA i=0.0){ re=r; im=i; }
      Complex<DATA> operator+(Complex<DATA> op); 
      ...
  }; 

• Beispiel: Methodendefinition für komplexe Zahlen als Templates

  template <typename DATA>
  Complex<DATA> Complex<DATA>::operator+(Complex<DATA> op)
  {
      // Achtung, folgende Funktionen werden im Folgenden aufgerufen,
      // und muessen damit definiert sein:
      // 
      // 1) DATA operator+(DATA, DATA)
      // 2) Complex(DATA, DATA)
      //
      return Complex<DATA>(re + op.re, im + op.im);
  } 

• Beispiel: Anwendung der komplexen Zahlen als Templates

  int main(void)
  {
      Complex<double> a(1.0, 0.0);
      Complex<double> b(0.0, 1.0);
      Complex<double> c(0.0, 0.0);
     
      c = a + b;
         

• Klassen-Templates und friend-Funktionen sind komplizierter, da dem Compiler während des parsens der Klasse noch nicht bewusst ist, daß diese eine Template-Klasse ist. Abhilfe Schafft hier u.a. die friend-Funktion vorab zu deklarieren, wobei aber wiederum die Klasse vorher als Template deklariert werden muss (ohne sie im Detail zu beschreiben - Forward-Deklaration, Quelle):

• Beispiel: Klassen-Templates und friend-Funktionen

  template <typename DATA> class Complex;
  template <typename DATA> ostream& operator<< /* hier kein <DATA> */ (ostream &os, Complex<DATA> &c);
  
  template <typename DATA>
  class Complex {
      ...
      friend ostream& operator<<<DATA>(ostream &os, Complex<DATA> &c);
  };
  
  template <typename DATA>
  ostream& operator<< /*nix!*/ (ostream &os, Complex<DATA> &c)
  {
      // Achtung, folgende Funktion wird im Folgenden aufgerufen,
      // und muß damit definiert sein:
      //
      // ostream &operator<<(ostream &, DATA)
      // 
      return os << c.re << "+" << c.im << "i";
  }
  
  int main(void)
  {
      ...
      
      cout << a << " + " << b << " = " << c << endl;
      return 0;
  }
   

  (Quellcode)

4.5 Beispiele

1. Stack-Template in 4 Schritten - mehr
2. Baum-Template - mehr
3. Complex-Klasse und Anwendung: ASCII Mandelbrot (Quellcode: ASCII-Variant mit eigenen komplexen zahlene, ASCII-Variant mit komplexen Zahlene aus der C++ Template Library, Eigene grafische Variante; Fertiges Programm: XaoS)

4.6 Übungen

1. Vergleichen Sie die Stack-Klasse mit der stack-Klasse der STL. Welche Gemeinsamkeiten und Unterschiede bestehen?
2. Benutzen Sie die das Stack-Template aus der Vorlesung, um den RPN-Taschenrechner aus Übung 3.11.1 bzw. dem letzten Semester nachzuprogrammieren. (C Quellcode)
3. Diverse Aufgaben rund um Templates (Sauer Test Nr. 8)
4. Eine Person hat einen Namen, eine Personalnummer und ein Gehalt. PersonMitOrt ableiten von Person, und PersonMitGehald ableiten von PersonMitOrt. Ein gemischtes Feld von Personen, PersonMitOrt'en und PersonMitGehalt'en sortieren und ausgeben!
5. Klasse von Zahlen definieren, und Klassen für Fließkomma-, rationale und komplexe Zahlen ableiten. (vgl. Jobst Extra-Blatt, Aufgabe 2 und complex(7). Definieren Sie die Operationen Addition (+), Subtraktion (-), Multiplikation (*), Division (/) sowie die Ausgabe mittels iostream (<<).
6. Erstellen Sie eine Klasse fuer Vektoren beliebiger (anzugebender) Dimension. Definieren Sie Konstruktoren, abs(), ueberladen Sie die Operatoren +, - und *. Erstellen Sie eine Anwendung die die Funktionen testet! (Lösungsvorschlag)
7. Erstellen sie eine Klasse für eine Matrix, die eine eine beliebige Anzahl Zeilen und Spalten haben kann, und die entsprechende Anzahl Elemente aufnimmt. Mit der Matrix-Klasse sollen dann typische Operationen durchgeführt werden können:
   • Addition
   • Subtraktion
   • Skalarmultiplikation
   • Matrizen-Multiplikation
   • Potenzieren
   • Transponierte
   • Inverse
   Die Implementierung könnte auf folgende Weise erfolgen:
   • Festlegung der Matrix-Größe im Konstruktor, dynamische Speicherbelegung und -freigabe
   • Methode zum Eingeben von einzelnen Werten
   • Methode zum Ausgeben der Matrix
   • Eigene Methoden für die Operationen
   • Kopier-Konstruktor und Zuweisungs-Operator
   • sinnvolles Überladen verschiedener Operatoren unter Verwendung der bereits erstellten Methoden
   • Überladen der Vergleichsoperatoren für ein sinnvolles Kriterium (Summe aller Werte, Determinante, Rang, etc.)
   • Überladen des Ausgabe-Operators für cout
   Lösungsgrundlage: Vektor-Übung