C++ - OOP Reference

// Literatur: Vorlesungsunterlagen SEN (FH Hagenberg, HSSE Semester 2)
//            C++ Referenz (http://www.cplusplus.com)
 
// Klasse kapselt Members(Variablen), Methoden(Funktionen)
// und regelt den Zugriff
 
class aClass
{
private:                    // eigener Zugriff +friends
    int mVar;             // Member
protected:                  // eigener Zugriff +abgeleitete Klassen +friends
    void doSomething(){}  // Methode
public:                     // öffentlicher Zugriff
    aClass(){}            // Constructor: Initialisierung des Objektes
    ~aClass(){}           // Destruktor:  Freigabe der Resourcen
};
 
 
// Erzeugen von Instanzen (Objekten)
//      statisch - am Stack
    aClass cl1;
    cl1.setX(0);
 
//      dynamisch - am Heap
    aClass *pCl2 = 0;
    pCl2 = new aClass;
    pCl2->setX(0);
 
    delete pCl2;
    pCl2 = 0;
 
 
// this-Pointer
//      versteckter/impliziter Parameter bei jeder Methode
    void doSomething()
    {
        this->setX(0);
    }
 
    aClass * const this;        // so wäre der this-Pointer deklariert
 
 
// Konstante Methoden
//      Methode kann Members nicht verändern
    int doSomething() const
    {
        return mX;
    }
 
 
// Konstruktor Initialisierungsliste
//      Konstanten müssen initialisiert werden
//      explicit ... erlaubt keine implicite Konvertierung
    class aClass
    {
    public:
        aClass(): mConst(10), mVal(0) {}
        explicit aClass(int value): mConst(10), mVal(value) {}
    private:
        int const mConst;
        int mVal;
    };
 
    aClass cl = 100;        // nicht erlaubt da implizite Konvertierung
                            // von int nach aClass nicht erlaubt
 
 
// Copy-Konstruktor
    class aClass
    {
        aClass(aClass const &cl): mVal(cl.mVal), ... {}
    };
 
    aClass cl1;             // default CTOR
    aClass cl2 = cl1;       // Copy-CTOR
    aClass cl3(cl1);        // Copy-CTOR
 
    aClass cl4;
    cl4 = cl1;              // Zuweisungsoperator =
 
 
// friend-Funktion und Klassen
    class aClass
    {
        friend void Function(aClass const &cl);
        friend class bClass;
        ...
    };
 
    void Function(aClass const &cl)
    {
        cl.getX();
        ...
    }
 
 
// statische Member und Methoden
//      statische Member existieren 1x pro Klasse, nicht 1x pro Objekt
    class aClass
    {
        ...
        static int GetCnt() const
        {
            return cnt;
        }
 
        static int cnt;
    };
    int aClass::cnt = 0;            // static-Member initialisieren
 
    int count = Object::GetCnt();   // Aufruf statischer Methoden
 
 
// Beziehungen zwischen Klassen
    class aClass: public bClass     // "ist ein"-Beziehung (Spezialisierung)
    {
        ...
        cClass *mCCl;               // "hat"-Beziehung (Aggregation)
    };
 
 
// Polymorphie
//      erforder einen Pointer oder eine Referenz
    baseClass *pBase = new derivedClass1;
    pBase = new derivedClass2;
 
 
// Überladen
//      Unterscheidung am Rückgabetyp alleine genügt nicht
    class aClass
    {
        ...
        void doSomething(int val1, int val2);
        void doSomething(int val1, double val2);
        void doSomething(int val1, int val2, int val3);
    };
 
 
// statischer und dynamischer Datentyp
    baseClass *pBase = new derivedClass;
        // statischer Datentyp  = baseClass
        // dynamischer Datentyp = derivedClass
 
    // Aufruf jener Funktion, welcher dem dynamischen Datentyp entspricht
        virtual void doSomethingMethod()
    // DTOR immer virtuell, damit Objekte zur Gänze gelöscht werden
        virtual ~aClass()
    // diese Methode muss in der abgeleiteten Klasse implementiert werden,
    // somit ist Klasse abstrakt
        virtual void doSomethingMethod() = 0;
 
 
// Aufteilung in Header- und Source-Datei
//      *.h
    #ifndef ACLASS_H
    #define ACLASS_H
 
    class aClass
    {
    public:
        aClass();
        ~aClass();
 
        void doSomething();
    private:
        int mVal;
    };
 
//      *.cpp
    #include "aclass.h"
 
    aClass::aClass()
    {
        ...
    }
    aClass::~aClass()
    {
        ...
    }
    void aClass::doSomething()
    {
        ...
    }
 
 
// Template Klasse
//      selbst die Implementierung muss in der Header-Datei erfolgen
    template <typename T>
    class Value
    {
    public:
        Value(T const &val);
        void Print() const;
    private:
        T value;
    };
 
    template <typename T>
    Value<T>::Value(T const &val)
    {
        value = val;
    }
    template <typename T>
    void Value<T>::Print() const
    {
        cout << value;
    }
 
    Value<int> val1(4);
    val1.Print();
 
    Value<double> val2(5.5);
    val2.Print();
 
 
// Operator Overloading
    class aClass
    {
        ...
        aClass operator +(aClass const &cl);
        bool operator ==(aClass const &cl);
    };
    ostream &operator <<(ostream &out, aClass const &cl);
 
 
// Vorwärtsdeklaration
    class aClass;
 
    class bClass
    {
        ...
    private:
        aClass mCl;
    };
 
    class aClass
    {
        ...
    private:
        bClass mCl;
    };