You are here
C++ - Reference
// Literatur: Vorlesungsunterlagen SEN (FH Hagenberg, HSSE Semester 1) // C++ Referenz (http://www.cplusplus.com) // Präprozessoranweisungen // beginnen mit # #include <stdio> // Systemheader #include "myModul.h" // benutzerdefinierte Header #ifdef SYMBOL // bedingte Compilierung #ifndef SYMBOL #if SYMBOL == 1 ... #else ... #endif #define SYMBOL #define SYMBOL 1 #undef SYMBOL #define square(x) x*x // Makros cout << square(2); #define assign(x,y) x=(y) assign(x,3); // Modulisierung // asdf.h ... Headerdatei #ifndef ASDF_H #define ASDF_H #include <string> void DoSomething(std::string str); #endif // asdf.cpp ... Sourcedatei #include "asdf.h" using namespace std; void DoSomething(string str) { ... } // Namespaces // Deklarationen in gemeinsamen Namensraum zusammenfassen namespace mySpace { void doSomething() { ... } } mySpace::doSomething(); using namespace mySpace::doSomething; doSomething(); using namespace mySpace; doSomething(); namespace // anonyme Namespaces { // nur in eigenen Datei sichtbar void doSomething() { ... } } doSomething(); // Datentypen bool // true, false char // 1 Byte -128 bis 127 unsigned char // 1 Byte 0 bis 255 int // 2 Byte -32 768 bis 32 767 // 4 Byte -2 147 483 648 bis 2 147 483 647 unsigned int // 2 Byte 0 bis 65 535 // 4 Byte 0 bis 4 294 967 295 long // 8 Byte unsigned long // 8 Byte float // 4 Byte +/- 3,4E+/-38 ( 7 digits) double // 8 Byte +/- 1,7E+/-308 (15 digits) char str[] = "hello"; // gespeichert wird: hello\0 string // basic_string<char> ... 8 Bit pro Zeichen wstring // basic_string<wchar_t> ... 16 Bit pro Zeichen size_t s = sizeof(var); int arr[] = {...}; size_t arrElems = sizeof(arr) / sizeof(int); // Arrays int values[10]; values[0] = 0; ... values[9] = 0; values[9] = *(values + 9) int values[] = {1,2}; int values[10] = {1,2}; // values[2] ... values[9] sind 0 int values[10] = {}; // alle values sind 0 int values[2][3]; int values[2][3] = {{1,2,3},{4,5,6}} values[0][0] = 0; ... values[1][2] = 0; values[1][2] = *(values + (1 * 3) + 2); // Enumerationstypen enum eColor {red, green, blue, yellow}; // intern integer als Datentyp eColor c = red; enum eColor {red = 2, green, blue, yellow}; // Typdefinitionen typedef unsigned int uint; uint number; typedef int tArr[2][2]; tArr arr; // Pointer, dynamische Variablen int value = 10; int *pInt = 0; pInt = new int; *pInt = 5; cout << *pInt << endl; delete pInt; pInt = 0; pInt = &value; *pInt = 5; int *arr = new int[10]; arr[0] = 0; ... arr[9] = 0; delete[] arr; arr = 0; int const * const pt = &var; // konstanter Pointer auf // konstanten Integer-Wert *pt = 1; // Fehler, da "int const" pt = 0; // Fehler, da "* const" //Probleme: Memory-Leaks ... Speicherfreigabe wurde vergessen // Dangling-Pointer ... Speicher wurde freigegeben, // Pointer zeigt aber noch auf Speicher- // bereich // Funktionspointer void f1() { ... } void (*pFunction)(); pFunction = f1; pFunction(); // Strukturen struct sValues { int val1; int val2; int val3; }; sValues values; values.val1 = 0; sValues *pValues = new sValues; (*pValues).val1 = 0; pValues->val1 = 0; delete pValues; pValues = 0; struct // anonyme Datenstrukturen { int val1; int val2; int val3; } values1, values2; values1.val1 = 0; values2.val1 = 0; // Bitfelder struct BitField { unsigned int a:3; // 000 - 1111 unsigned int b:2; // 00 - 11 unsigned int c:3; // 000 - 111 }; BitField bf; bf.a = 5; bf.b = 1; bf.c = 4; // Unions union uint32 { unsigned int integerVal; unsigned char charVal[4]; }; uint32 val; val.integerVal = 0; val.charVal[0] = 0xff; // arithmetische Operatoren + // Addition - // Subtraktion * // Multiplikation / // Division % // Modulo (Divisionsrest) i += 2; // i = i + 2; i -= 2; i /= 2; i *= 2; i++; // Postincrement: i = i + 1; ++i; // Preincrement i--; // Postdecrement --i; // Preincrement // Vergleichsoperatoren == // gleich != // ungleich < // kleiner <= // kleiner gleich > // größer >= // größer gleich // logische Operatoren && // und (mit Kurzschlussauswertung) & // und || // oder (mit Kurzschlussauswertung) | // oder ! // nicht // Bitoperationen & // bitweises und | // bitweises oder ~ // bitweises nicht ^ // XOR (exclusives oder) >> // Rechtsshift << // Linksshift // Alternativeoperator y = (x < 0) ? 0 : 1; if (x < 0) y = 0; else y = 1; // Casts // C - Casts int x; double y; x = (int)y; y = (double)x; // C++ - Casts dynamic_cast // konvertiert einen Zeiger eines Klassentyps auf einen // Zeiger in gleichen Ableitungskette // übernimmt Typprüfung, nur auf Zeiger und Referenzen von // polymorphen Typen static_cast // ohne Typprüfung, auch für nicht-polymorphen Typen (~ wie C-Casts) const_cast // Qualifier const und volatile wird entfernt reinterpret_cast // Zeiger kann in beliebigen anderen Zeiger konvertiert werden baseClass *pCl = 0; derivedClass cl; pCl = dynamic_cast<baseClass *>(&cl); // Anweisungen break // Schleife wird beendet continue // Sprung zum Schleifenstart goto A; // beliebiges Sprungziel A: ... // Vorwärtsdeklaration int doSomething(); int main() { ... doSomething(); ... } void doSomething() { ... } // Parameterübergabe // "call by value" - Eingabeparameter void doSomething(int param) // "call by reference" - Übergangsparameter void doSomething(int ¶m) // "call by reference", bestimmte Anzahl void doSomething(int arr[10]) // "call by reference", beliebige Anzahl void doSomething(int arr[], size_t elems) = void doSomething(int *arr, size_t elems) // "call by value" void doSomething(int const arr[], size_t elems) = void doSomething(int const *arr, size_t elems) // "call by value", mehrdimensionales Array void doSomething(int const arr[][cols]); // Default-Parameter (nur im Header oder im main) void doSomething(int val = 0) // Variablenspezifizierung static // - Lokale Variablen bleiben beim Verlassen des umschließenden // Blocks erhalten // - Globale Variablen haben damit nur Datei-Sichtbarkeit // - Member Variablen: es existiert nur eine Instanz für alle // Objekte der selben Klasse // - frei stehende Funktionen haben damit nur Datei-Sichtbarkeit // - Methoden: können ohne Instanz einer Klasse aufgerufen werden, // können aber nur auf statische Member Variablen zugreifen extern // Angabe, dass Variable oder Funktion in einer anderen Quelldatei // definiert ist mutable // Member Variablen: die Variable kann auch bei konstanten Objekten // einer Klasse verändert werden auto // Speicher automatisch belegen und frei geben register // es wird versucht die Variable in einem Register abzulegen // (zwecks Performance) volatile // Variable kann Externe verändert werden und sollte durch den // Compiler nicht optimiert werden const // Veränderungen sind nicht zulässig // Schleifen und Bedingte Ausführung if(...) { ... } else if(...) { ... } else { .... } for (int i=0; i<max; i++) { ... } while(...) { ... } do { ... } while(...); switch(nr) { case 0: ... break; case 1: ... break; default: } // Fehlerbehandlung #include <cassert> assert(NoFailure() == true); try { if(...) throw "Fehler in ..."; } catch(char const *error) { } catch(...) { } try { if(...) throw (string("Fehler in ...")); } catch(string const &str) { } // Rekursion int fakulty(int x) { if (x <= 1) // Abbruchbedingung return 1; return (fakulty(x-1) * x); // Rekursion } // Templates template <typename T> void swap(T &x, T &y) { T tmp = x; x = y; y = tmp; } swap(int1, int2); swap(str1, str2);
