1// Literatur: Vorlesungsunterlagen SEN (FH Hagenberg, HSSE Semester 2)
2// C++ Referenz (http://www.cplusplus.com)
3
4// Klasse kapselt Members(Variablen), Methoden(Funktionen)
5// und regelt den Zugriff
6
7class aClass
8{
9private: // eigener Zugriff +friends
10 int mVar; // Member
11protected: // eigener Zugriff +abgeleitete Klassen +friends
12 void doSomething(){} // Methode
13public: // oeffentlicher Zugriff
14 aClass(){} // Constructor: Initialisierung des Objektes
15 ~aClass(){} // Destruktor: Freigabe der Resourcen
16};
17
18
19// Erzeugen von Instanzen (Objekten)
20// statisch - am Stack
21 aClass cl1;
22 cl1.setX(0);
23
24// dynamisch - am Heap
25 aClass *pCl2 = 0;
26 pCl2 = new aClass;
27 pCl2->setX(0);
28
29 delete pCl2;
30 pCl2 = 0;
31
32
33// this-Pointer
34// versteckter/impliziter Parameter bei jeder Methode
35 void doSomething()
36 {
37 this->setX(0);
38 }
39
40 aClass * const this; // so waere der this-Pointer deklariert
41
42
43// Konstante Methoden
44// Methode kann Members nicht veraendern
45 int doSomething() const
46 {
47 return mX;
48 }
49
50
51// Konstruktor Initialisierungsliste
52// Konstanten muessen initialisiert werden
53// explicit ... erlaubt keine implicite Konvertierung
54 class aClass
55 {
56 public:
57 aClass(): mConst(10), mVal(0) {}
58 explicit aClass(int value): mConst(10), mVal(value) {}
59 private:
60 int const mConst;
61 int mVal;
62 };
63
64 aClass cl = 100; // nicht erlaubt da implizite Konvertierung
65 // von int nach aClass nicht erlaubt
66
67
68// Copy-Konstruktor
69 class aClass
70 {
71 aClass(aClass const &cl): mVal(cl.mVal), ... {}
72 };
73
74 aClass cl1; // default CTOR
75 aClass cl2 = cl1; // Copy-CTOR
76 aClass cl3(cl1); // Copy-CTOR
77
78 aClass cl4;
79 cl4 = cl1; // Zuweisungsoperator =
80
81
82// friend-Funktion und Klassen
83 class aClass
84 {
85 friend void Function(aClass const &cl);
86 friend class bClass;
87 ...
88 };
89
90 void Function(aClass const &cl)
91 {
92 cl.getX();
93 ...
94 }
95
96
97// statische Member und Methoden
98// statische Member existieren 1x pro Klasse, nicht 1x pro Objekt
99 class aClass
100 {
101 ...
102 static int GetCnt() const
103 {
104 return cnt;
105 }
106
107 static int cnt;
108 };
109 int aClass::cnt = 0; // static-Member initialisieren
110
111 int count = Object::GetCnt(); // Aufruf statischer Methoden
112
113
114// Beziehungen zwischen Klassen
115 class aClass: public bClass // "ist ein"-Beziehung (Spezialisierung)
116 {
117 ...
118 cClass *mCCl; // "hat"-Beziehung (Aggregation)
119 };
120
121
122// Polymorphie
123// erforder einen Pointer oder eine Referenz
124 baseClass *pBase = new derivedClass1;
125 pBase = new derivedClass2;
126
127
128// Ueberladen
129// Unterscheidung am Rueckgabetyp alleine genuegt nicht
130 class aClass
131 {
132 ...
133 void doSomething(int val1, int val2);
134 void doSomething(int val1, double val2);
135 void doSomething(int val1, int val2, int val3);
136 };
137
138
139// statischer und dynamischer Datentyp
140 baseClass *pBase = new derivedClass;
141 // statischer Datentyp = baseClass
142 // dynamischer Datentyp = derivedClass
143
144 // Aufruf jener Funktion, welcher dem dynamischen Datentyp entspricht
145 virtual void doSomethingMethod()
146 // DTOR immer virtuell, damit Objekte zur Gaenze geloescht werden
147 virtual ~aClass()
148 // diese Methode muss in der abgeleiteten Klasse implementiert werden,
149 // somit ist Klasse abstrakt
150 virtual void doSomethingMethod() = 0;
151
152
153// Aufteilung in Header- und Source-Datei
154// *.h
155 #ifndef ACLASS_H
156 #define ACLASS_H
157
158 class aClass
159 {
160 public:
161 aClass();
162 ~aClass();
163
164 void doSomething();
165 private:
166 int mVal;
167 };
168
169// *.cpp
170 #include "aclass.h"
171
172 aClass::aClass()
173 {
174 ...
175 }
176 aClass::~aClass()
177 {
178 ...
179 }
180 void aClass::doSomething()
181 {
182 ...
183 }
184
185
186// Template Klasse
187// selbst die Implementierung muss in der Header-Datei erfolgen
188 template <typename T>
189 class Value
190 {
191 public:
192 Value(T const &val);
193 void Print() const;
194 private:
195 T value;
196 };
197
198 template <typename T>
199 Value<T>::Value(T const &val)
200 {
201 value = val;
202 }
203 template <typename T>
204 void Value<T>::Print() const
205 {
206 cout << value;
207 }
208
209 Value<int> val1(4);
210 val1.Print();
211
212 Value<double> val2(5.5);
213 val2.Print();
214
215
216// Operator Overloading
217 class aClass
218 {
219 ...
220 aClass operator +(aClass const &cl);
221 bool operator ==(aClass const &cl);
222 };
223 ostream &operator <<(ostream &out, aClass const &cl);
224
225
226// Vorwaertsdeklaration
227 class aClass;
228
229 class bClass
230 {
231 ...
232 private:
233 aClass mCl;
234 };
235
236 class aClass
237 {
238 ...
239 private:
240 bClass mCl;
241 };
