C++ - Reference | wedi

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 &param)
 
    // "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);