// 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; };