-------------------------------------------
 Ü B U N G S F R A G E N  ( Grundlagen C++ )
 -------------------------------------------
  
1.  Was bedeutet der kleine Unterschied zwischen den folgenden Zeilen genau?
    
    int* pa = new int ( 13 );
    int* pb = new int [ 13 ];
    
2.  Was gibt folgendes Programm auf dem Bildschirm aus?
    
    #include <iostream.h>
    
    void main() {
    
        int* pa, *pb, *temp;
    
        pa = new int(13);
        pb = new int(15);
    
        temp = pa;
        pb   = pa;
    
        cout << "Inhalt von pa:  " << *pa   << endl;
        cout << "Inhalt von pb:  " << *pb   << endl;
        cout << "Inhalt von temp:" << *temp << endl;
    }    

3.  Beschreiben Sie genau,
    a.  auf welche zwei Arten Objekte in C++ angelegt werden können und
    b.  wodurch diese Objektarten sich unterscheiden?

4.  Wie lauten die wesentlichen Regeln, die ein Konstruktor befolgen muss?

5.  Schreiben Sie einen Konstruktor der Klasse STUDENT, der folgende
    zwei Objektaufrufe verarbeiten kann:
    
    void main () {

        STUDENT* zwei = new STUDENT("Meier" );
        STUDENT* drei = new STUDENT("Mayer", 2000);
    }
    
6.  Warum darf es nur einen Destruktor in einer Klasse geben?

7.  Beschreiben Sie genau den Vorgang der Objektzerstörung mit Destruktor
    bei statischen und bei dynamischen Objekten.

8.  Wie wird der Destruktor für folgendes Array aufgerufen?
    
    int* pb = new int [ 13 ];
    
9.  Erklären Sie, unter welchen Umständen in einer Klasse ein
    Standard-Operator (<  >, =, == usw.) überschrieben werden muss.

10. Implementieren Sie in der folgenden Klasse eine Methode, die
    den == Operator (Vergleichsoperator) für DATA-Objekte überschreibt
    (Parameter mit Referenz, Rückgabewert bool).
    
    class DATA {

         int  data;
         char name[20];

     public:
         DATA(int temp, char* name2) {
            data = temp;
            strcpy(name,name2);
         }
     };
    
11. Schreiben Sie für obige Klasse eine vollständige main-Funktion, die
    a.  zwei DATA-Objekte erzeugt (ein Stack-Objekt und ein Heap (Zeiger)-Objekt,
        jeweils mit Parameterübergabe beim Konstruktoraufruf) und
    b.  deren Inhalte mittels des überschriebenen == Operators vergleicht und
    c.  das Resultat (gleich / ungleich) auf dem Bildschirm ausgibt.

12. Beschreiben Sie genau, wann (unter welchen Umständen) eine Klasse
    eine friend-Funktion benötigt.

13. Implementieren Sie für die obige DATA-Klasse eine Friend-Funktion,
    die den << Operator überschreibt:

14. Welche elementaren Regeln gelten für Referenzen?

15. Was sind die Vorteile von Referenzen gegenüber Pointern zum Beispiel
    beim Aufruf einer Funktion?

16. Schreiben Sie für folgende Klassen ein main-Programm, das einen FH_Student
    in einen UNI_Student umwandelt.
    
    #include <stdio.h>
    
    // Basisklasse /////////////////////////////////////////////
    
    class Student {
    
      private:
        char*  nachname;
    
      public:
        Student() {
        }
        Student(char* nn) {
            nachname = nn;
        }
        void zeige() {
            printf("STUDENT.zeige() aufgerufen\n");
        }
    };
    // abgeleitete Klasse 1 /////////////////////////////////////
    
    class FH_Student : public Student {
    
     public:
       FH_Student(char* n) : Student(n) {
       }
       void zeige() {
          printf("FH_STUDENT.zeige() aufgerufen\n");
       }
    };
    
    // abgeleitete Klasse 2 /////////////////////////////////////
    
    class UNI_Student : public Student {
    
     public:
       UNI_Student(char* n) : Student(n) {
       }
       void zeige() {
            printf("UNI_STUDENT.zeige() aufgerufen\n");
       }
    };
    
17. Was muss in der Klasse Student verändert werden, damit beim Aufruf von
    zeige() die korrekte Subklassen-Methode (FH_Student bzw. UNI_Student) aufgerufen wird?

18. Schreiben Sie ein C++-Programm, das folgende geometrische zweidimensionale
    Grundformen abbildet:
    
    Basisklasse GeomForm:
    
        Attribute:
            Hoehe
            Breite
            Radius1
    
        Virtuelle Methoden:
            Fläche berechnen
            Umfang berechnen
    
    
    Davon abgeleitete Klassen:
    
     - Klasse Viereck
    
     - Klasse Kreis
    
    Die Attribute sind Bestandteil der Basisklasse.
    Definieren Sie für jede Klasse einen Konstruktor mit Übergabeparameter,
    in dem die Basisklassen-Attribute initialisiert werden.
    Überschreiben Sie die virtuellen Methoden in den einzelnen Klassen, so dass
    sie die korrekte Fäche und den Umfang berechnen und ausgeben.
    Hinweis: Kreisfläche: r*r*pi, Kreisumfang: 2*r*pi.
    
    Erzeugen Sie in main( ) einen Vektor, der aus Zeigern auf die Basisklasse besteht.
    Erzeugen Sie in jedem Element des Vektors ein dynamisches Objekt jeder Klasse.
    Rufen Sie die Methoden für jedes Objekt auf.