C++-Programmierung/ Im Zusammenhang mit Klassen/ Zusammenfassung

union

Ein union kann mehrere Datentypen auf einer Speicheradresse vereinen. Es kann also immer nur eine Member abgespeichert werden. Man greift auf die Elemente des union über den Punkt-Operator zu. Diese Datenstruktur verbraucht genauso viel Speicher wie das größte Element.

#include <iostream>

union Abc {
     int a;           // = 4 Bytes  (32-bit, 64-bit)
     short b;         // = 2 Bytes  (32-bit, 64-bit)
     long double c;   // = 12 Bytes (32-bit), 16 Bytes (64-bit)
};

int main(void) {
     Abc myUnion;        // Deklaration des Unions myUnion vom Typ Abc

     // die Größe des Unions ist immer konstant
     std::cout << " Größe am Anfang: " << sizeof(myUnion) << "\n" << std::endl;

     myUnion.a = 32000;   // Zugriff auf die Elemente über den Punkt-Operator
     std::cout << " a initialisiert. a = " << myUnion.a << std::endl;
     std::cout << " Größe: " << sizeof(myUnion) << "\n" << std::endl;

     myUnion.b = -15000;  // jetzt hat a keinen gültigen Wert mehr
     std::cout << " b initialisiert. a = " << myUnion.a << "; b = " << myUnion.b << std::endl;
     std::cout << " Größe: " << sizeof(myUnion) << "\n" << std::endl;

     myUnion.c = 3.512;   // a und b haben keinen sinnvollen Wert mehr
     std::cout << " Größe am Ende: " << sizeof(myUnion) << std::endl;

     return 0;
}

Ausgabe:

Größe am Anfang: 16

 a initialisiert. a = 32000
 Größe: 16

 b initialisiert. a = 50536; b = -15000
 Größe: 16

 Größe am Ende: 16

static

In C++ gibt es, im Gegensatz zu C#, zwar keine statischen Klassen, jedoch können einzelne Membermethoden oder -variablen static sein. Das heißt, sie existieren nur ein Mal für alle Objekte der Klasse und sind auch nutzbar, wenn es noch keine Instanz dieser Klasse gibt. Statische Klassenvariablen sind nur in dem Modul gültig, wo sie deklariert wurden. Eine statische Methode kann nicht auf nicht-statische Membervariablen zugreifen; die static-Methode gehört ja nicht zu einem bestimmten Objekt.

Eine Funktion kann static "lokale" Variablen besitzen. Auf sie kann nur innerhalb der Funktion zugegriffen werden. Sie verhalten sich jedoch wie globale Variablen: Sie behalten ihren Wert zwischen Funktionsaufrufen. Ihre Initialisierung wird nur beim ersten Aufruf der Funktion ausgeführt.

mutable

Konstante Funktionen können eigentlich keine Membervariablen verändern. Variablen, die mit mutable gekennzeichnet sind, können jedoch auch von const-Funktionen verändert werden. Beispiel:

class Foo {
    mutable int i1;
    int i2;
    void Func() {
        i1++; i2++; // Erlaubt
    }
    void constFunc() const {
        i1++; // Erlaubt! i1 ist mutable.
        i2++; // Fehler: i2 ist nicht mutable, aber Member von Foo. Da constFunc const ist, darf es i2 nicht verändern.
    }
};

'mutable' ist nur in wenigen Fällen sinnvoll; meistens sollte stattdessen die Methode zu 'nicht-const' geändert werden.

volatile

Der Wert einer Variablen, die mit volatile gekennzeichnet ist, wird vor jedem Zugriff neu eingelesen. Die Variable darf der Compiler also nicht im schnellen Prozessorcache zwischenspeichern. Hauptsächlich wird volatile dann eingesetzt, wenn Hardware-nahe Routinen sicherstellen müssen, dass bei der Kommunikation mit der Hardware (über Ram-Bereiche) auch der aktuelle Wert verwendet wird.

volatile ist alleine ungeeignet, Variablen-Zugriffe (z.B. für den Austausch von Inhalten) zwischen verschiedenen parallel-laufenden Threads innerhalb eines Programms zu synchronisieren, kann jedoch ggf. einen Teil zu den dafür notwendigen Bedingungen beitragen.