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

Aus Wikibooks
Zur Navigation springen Zur Suche springen


union[Bearbeiten]

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.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 union Abc {
 4      int a;           // = 4 Bytes  (32-bit, 64-bit)
 5      short b;         // = 2 Bytes  (32-bit, 64-bit)
 6      long double c;   // = 12 Bytes (32-bit), 16 Bytes (64-bit)
 7 };
 8 
 9 int main(void) {
10      Abc myUnion;        // Deklaration des Unions myUnion vom Typ Abc
11 
12      // die Größe des Unions ist immer konstant
13      std::cout << " Größe am Anfang: " << sizeof(myUnion) << "\n" << std::endl;
14 
15      myUnion.a = 32000;   // Zugriff auf die Elemente über den Punkt-Operator
16      std::cout << " a initialisiert. a = " << myUnion.a << std::endl;
17      std::cout << " Größe: " << sizeof(myUnion) << "\n" << std::endl;
18 
19      myUnion.b = -15000;  // jetzt hat a keinen gültigen Wert mehr
20      std::cout << " b initialisiert. a = " << myUnion.a << "; b = " << myUnion.b << std::endl;
21      std::cout << " Größe: " << sizeof(myUnion) << "\n" << std::endl;
22 
23      myUnion.c = 3.512;   // a und b haben keinen sinnvollen Wert mehr
24      std::cout << " Größe am Ende: " << sizeof(myUnion) << std::endl;
25 
26      return 0;
27 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Größe am Anfang: 16
2 
3  a initialisiert. a = 32000
4  Größe: 16
5 
6  b initialisiert. a = 50536; b = -15000
7  Größe: 16
8 
9  Größe am Ende: 16

static[Bearbeiten]

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[Bearbeiten]

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:

Nuvola-inspired-terminal.svg
 1 class Foo {
 2     mutable int i1;
 3     int i2;
 4     void Func() {
 5         i1++; i2++; // Erlaubt
 6     }
 7     void constFunc() const {
 8         i1++; // Erlaubt! i1 ist mutable.
 9         i2++; // Fehler: i2 ist nicht mutable, aber Member von Foo. Da constFunc const ist, darf es i2 nicht verändern.
10     }
11 };

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

volatile[Bearbeiten]

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,[1] kann jedoch ggf. einen Teil zu den dafür notwendigen Bedingungen beitragen.

Weblinks[Bearbeiten]

  1. stackoverflow.com: volatile and multi-threading, citating Bjarne Stroustrup