1// Literatur: Vorlesungsunterlagen SEN (FH Hagenberg, HSSE Semester 1)
2// C++ Referenz (http://www.cplusplus.com)
3
4// Praeprozessoranweisungen
5// beginnen mit #
6 #include <stdio> // Systemheader
7 #include "myModul.h" // benutzerdefinierte Header
8
9 #ifdef SYMBOL // bedingte Compilierung
10 #ifndef SYMBOL
11 #if SYMBOL == 1
12 ...
13 #else
14 ...
15 #endif
16
17 #define SYMBOL
18 #define SYMBOL 1
19 #undef SYMBOL
20
21 #define square(x) x*x // Makros
22 cout << square(2);
23
24 #define assign(x,y) x=(y)
25 assign(x,3);
26
27
28// Modulisierung
29// asdf.h ... Headerdatei
30 #ifndef ASDF_H
31 #define ASDF_H
32
33 #include <string>
34
35 void DoSomething(std::string str);
36
37 #endif
38
39// asdf.cpp ... Sourcedatei
40 #include "asdf.h"
41
42 using namespace std;
43
44 void DoSomething(string str)
45 {
46 ...
47 }
48
49
50// Namespaces
51// Deklarationen in gemeinsamen Namensraum zusammenfassen
52 namespace mySpace
53 {
54 void doSomething()
55 {
56 ...
57 }
58 }
59
60 mySpace::doSomething();
61
62 using namespace mySpace::doSomething;
63 doSomething();
64
65 using namespace mySpace;
66 doSomething();
67
68
69 namespace // anonyme Namespaces
70 { // nur in eigenen Datei sichtbar
71 void doSomething()
72 {
73 ...
74 }
75 }
76 doSomething();
77
78
79// Datentypen
80 bool // true, false
81 char // 1 Byte -128 bis 127
82 unsigned char // 1 Byte 0 bis 255
83 int // 2 Byte -32 768 bis 32 767
84 // 4 Byte -2 147 483 648 bis 2 147 483 647
85 unsigned int // 2 Byte 0 bis 65 535
86 // 4 Byte 0 bis 4 294 967 295
87 long // 8 Byte
88 unsigned long // 8 Byte
89 float // 4 Byte +/- 3,4E+/-38 ( 7 digits)
90 double // 8 Byte +/- 1,7E+/-308 (15 digits)
91
92 char str[] = "hello"; // gespeichert wird: hello\0
93 string // basic_string<char> ... 8 Bit pro Zeichen
94 wstring // basic_string<wchar_t> ... 16 Bit pro Zeichen
95
96 size_t s = sizeof(var);
97
98 int arr[] = {...};
99 size_t arrElems = sizeof(arr) / sizeof(int);
100
101
102// Arrays
103 int values[10];
104 values[0] = 0;
105 ...
106 values[9] = 0;
107 values[9] = *(values + 9)
108
109 int values[] = {1,2};
110 int values[10] = {1,2}; // values[2] ... values[9] sind 0
111 int values[10] = {}; // alle values sind 0
112
113 int values[2][3];
114 int values[2][3] = {{1,2,3},{4,5,6}}
115 values[0][0] = 0;
116 ...
117 values[1][2] = 0;
118 values[1][2] = *(values + (1 * 3) + 2);
119
120
121// Enumerationstypen
122 enum eColor {red, green, blue, yellow}; // intern integer als Datentyp
123 eColor c = red;
124
125 enum eColor {red = 2, green, blue, yellow};
126
127
128// Typdefinitionen
129 typedef unsigned int uint;
130 uint number;
131
132 typedef int tArr[2][2];
133 tArr arr;
134
135
136// Pointer, dynamische Variablen
137 int value = 10;
138 int *pInt = 0;
139 pInt = new int;
140
141 *pInt = 5;
142 cout << *pInt << endl;
143
144 delete pInt;
145 pInt = 0;
146
147 pInt = &value;
148 *pInt = 5;
149
150
151 int *arr = new int[10];
152 arr[0] = 0;
153 ...
154 arr[9] = 0;
155 delete[] arr;
156 arr = 0;
157
158 int const * const pt = &var; // konstanter Pointer auf
159 // konstanten Integer-Wert
160 *pt = 1; // Fehler, da "int const"
161 pt = 0; // Fehler, da "* const"
162
163 //Probleme: Memory-Leaks ... Speicherfreigabe wurde vergessen
164 // Dangling-Pointer ... Speicher wurde freigegeben,
165 // Pointer zeigt aber noch auf Speicher-
166 // bereich
167
168
169// Funktionspointer
170 void f1()
171 {
172 ...
173 }
174
175 void (*pFunction)();
176 pFunction = f1;
177 pFunction();
178
179
180// Strukturen
181 struct sValues
182 {
183 int val1;
184 int val2;
185 int val3;
186 };
187
188 sValues values;
189 values.val1 = 0;
190
191 sValues *pValues = new sValues;
192 (*pValues).val1 = 0;
193 pValues->val1 = 0;
194 delete pValues;
195 pValues = 0;
196
197 struct // anonyme Datenstrukturen
198 {
199 int val1;
200 int val2;
201 int val3;
202 } values1, values2;
203 values1.val1 = 0;
204 values2.val1 = 0;
205
206
207// Bitfelder
208 struct BitField
209 {
210 unsigned int a:3; // 000 - 1111
211 unsigned int b:2; // 00 - 11
212 unsigned int c:3; // 000 - 111
213 };
214
215 BitField bf;
216 bf.a = 5;
217 bf.b = 1;
218 bf.c = 4;
219
220
221// Unions
222 union uint32
223 {
224 unsigned int integerVal;
225 unsigned char charVal[4];
226 };
227
228 uint32 val;
229 val.integerVal = 0;
230 val.charVal[0] = 0xff;
231
232
233// arithmetische Operatoren
234 + // Addition
235 - // Subtraktion
236 * // Multiplikation
237 / // Division
238 % // Modulo (Divisionsrest)
239
240 i += 2; // i = i + 2;
241 i -= 2;
242 i /= 2;
243 i *= 2;
244
245 i++; // Postincrement: i = i + 1;
246 ++i; // Preincrement
247 i--; // Postdecrement
248 --i; // Preincrement
249
250
251// Vergleichsoperatoren
252 == // gleich
253 != // ungleich
254 < // kleiner
255 <= // kleiner gleich
256 > // groesser
257 >= // groesser gleich
258
259
260// logische Operatoren
261 && // und (mit Kurzschlussauswertung)
262 & // und
263 || // oder (mit Kurzschlussauswertung)
264 | // oder
265 ! // nicht
266
267
268// Bitoperationen
269 & // bitweises und
270 | // bitweises oder
271 ~ // bitweises nicht
272 ^ // XOR (exclusives oder)
273 >> // Rechtsshift
274 << // Linksshift
275
276
277// Alternativeoperator
278 y = (x < 0) ? 0 : 1;
279
280 if (x < 0)
281 y = 0;
282 else
283 y = 1;
284
285
286// Casts
287// C - Casts
288 int x;
289 double y;
290
291 x = (int)y;
292 y = (double)x;
293
294// C++ - Casts
295 dynamic_cast
296 // konvertiert einen Zeiger eines Klassentyps auf einen
297 // Zeiger in gleichen Ableitungskette
298 // uebernimmt Typpruefung, nur auf Zeiger und Referenzen von
299 // polymorphen Typen
300 static_cast
301 // ohne Typpruefung, auch fuer nicht-polymorphen Typen (~ wie C-Casts)
302 const_cast
303 // Qualifier const und volatile wird entfernt
304 reinterpret_cast
305 // Zeiger kann in beliebigen anderen Zeiger konvertiert werden
306
307 baseClass *pCl = 0;
308 derivedClass cl;
309 pCl = dynamic_cast<baseClass *>(&cl);
310
311
312// Anweisungen
313 break // Schleife wird beendet
314 continue // Sprung zum Schleifenstart
315
316 goto A; // beliebiges Sprungziel
317 A: ...
318
319
320// Vorwaertsdeklaration
321 int doSomething();
322
323 int main()
324 {
325 ...
326 doSomething();
327 ...
328 }
329
330 void doSomething()
331 {
332 ...
333 }
334
335
336// Parameteruebergabe
337 // "call by value" - Eingabeparameter
338 void doSomething(int param)
339 // "call by reference" - Uebergangsparameter
340 void doSomething(int ¶m)
341
342 // "call by reference", bestimmte Anzahl
343 void doSomething(int arr[10])
344 // "call by reference", beliebige Anzahl
345 void doSomething(int arr[], size_t elems)
346 =
347 void doSomething(int *arr, size_t elems)
348 // "call by value"
349 void doSomething(int const arr[], size_t elems)
350 =
351 void doSomething(int const *arr, size_t elems)
352 // "call by value", mehrdimensionales Array
353 void doSomething(int const arr[][cols]);
354
355 // Default-Parameter (nur im Header oder im main)
356 void doSomething(int val = 0)
357
358
359// Variablenspezifizierung
360 static
361 // - Lokale Variablen bleiben beim Verlassen des umschliessenden
362 // Blocks erhalten
363 // - Globale Variablen haben damit nur Datei-Sichtbarkeit
364 // - Member Variablen: es existiert nur eine Instanz fuer alle
365 // Objekte der selben Klasse
366 // - frei stehende Funktionen haben damit nur Datei-Sichtbarkeit
367 // - Methoden: koennen ohne Instanz einer Klasse aufgerufen werden,
368 // koennen aber nur auf statische Member Variablen zugreifen
369 extern
370 // Angabe, dass Variable oder Funktion in einer anderen Quelldatei
371 // definiert ist
372 mutable
373 // Member Variablen: die Variable kann auch bei konstanten Objekten
374 // einer Klasse veraendert werden
375 auto
376 // Speicher automatisch belegen und frei geben
377 register
378 // es wird versucht die Variable in einem Register abzulegen
379 // (zwecks Performance)
380 volatile
381 // Variable kann Externe veraendert werden und sollte durch den
382 // Compiler nicht optimiert werden
383 const
384 // Veraenderungen sind nicht zulaessig
385
386
387// Schleifen und Bedingte Ausfuehrung
388 if(...)
389 {
390 ...
391 }
392 else if(...)
393 {
394 ...
395 }
396 else
397 {
398 ....
399 }
400
401 for (int i=0; i<max; i++)
402 {
403 ...
404 }
405
406 while(...)
407 {
408 ...
409 }
410
411 do
412 {
413 ...
414 }
415 while(...);
416
417 switch(nr)
418 {
419 case 0:
420 ...
421 break;
422 case 1:
423 ...
424 break;
425 default:
426 }
427
428
429// Fehlerbehandlung
430 #include <cassert>
431 assert(NoFailure() == true);
432
433 try
434 {
435 if(...)
436 throw "Fehler in ...";
437 }
438 catch(char const *error)
439 {
440 }
441 catch(...)
442 {
443 }
444
445 try
446 {
447 if(...)
448 throw (string("Fehler in ..."));
449 }
450 catch(string const &str)
451 {
452 }
453
454
455// Rekursion
456 int fakulty(int x)
457 {
458 if (x <= 1) // Abbruchbedingung
459 return 1;
460
461 return (fakulty(x-1) * x); // Rekursion
462 }
463
464
465// Templates
466 template <typename T>
467 void swap(T &x, T &y)
468 {
469 T tmp = x;
470 x = y;
471 y = tmp;
472 }
473
474 swap(int1, int2);
475 swap(str1, str2);
