Dereferenz *

Mittels des Dereferenz-Operators kann auf einen Wert zugegriffen werden, welcher als Pointer vorliegt. Der Stern * steht dabei links des Ausdruckes, der eine Adresse darstellt und zu welchem der Wert angesprochen werden soll.

a: 100

#include <stdio.h>

int main(){
  int a = 100;
  int* aptr = &a;
  printf("a: %d\n", *aptr);
  return 0;
}

Siehe auch Adress-Operator &, Feld-Member-Operator .*, Pointer-Member-Operator .->

Details

Der Dereferenz-Operator erwartet einen Operanden als rvalue und wird von rechts nach links abgearbeitet. Der Rückgabewert ist ein lvalue und hat als Typ eine Referenz & auf den Typ des Operanden ohne den Pointer.

Der Dereferenz-Operator ist das direkte Gegenstück zum Adress-Operator. Während der Adress-Operator zu einem lvalue den Pointer zurückgibt, wandelt der Dereferenz-Operator ebendiesen Pointer wieder zurück in einen lvalue.

Der Dereferenz-Operator wird auch Indirektions-Operator genannt, beide Begriffe sind etwas verwirrend. Mit Dereferenz ist gemeint, dass ein Pointer nicht einen eigentlichen Wert speichert, sondern nur einen Index (eine Referenz) auf einen lvalue representiert, welcher durch den Dereferenz-Operator dereferenziert, also angesprochen wird. Der Begriff ist verwirrend, da schlussendlich eine Referenz & auf den gesuchten Wert zurückgegeben wird. Mit Indirektion ist gemeint, dass der Pointer nicht der eigentliche Wert, sondern nur eine Umleitung (eine Indirektion) an den Speicherort darstellt. Mittels des Indirektions-Operators kann dieser Wert indirekt angesprochen werden. Auf dieser Seite wird der Name Dereferenz verwendet.

Der Dereferenz-Operator kann für beliebige Ausdrücke verwendet werden, welche zu einem Pointer auswerten. Dieser Operator funktioniert somit insbesondere für Pointer auf Variablen, aber auch beispielsweise für Pointer auf Elemente von Arrays. Sehr nützlich ist dieser Operator, wenn ein Array sequentiell abgearbeitet werden soll:

0,1,2,3,4

#include <stdio.h>

int main(){
  int i;
  int a[5];
  int* aptr = a;
  for(i=0; i<5; ++i){
    *aptr++ = i;
  }
  printf("%d,%d,%d,%d,%d\n", a[0], a[1], a[2], a[3], a[4]);
  return 0;
}

Man beachte hierbei, dass aufgrund der Operatorenrangordnung Klammern nicht nötig sind.

Überladen des Operators

Die semantische Bedeutung des Dereferenz-Operators ist das Ansprechen des Wertes, der durch den gegebenen Operanden referenziert ist. Dies kann beispielsweise für eine Container-Klasse verwendet werden, welche mittels des Dereferenz-Operators Zugriff auf den Inhalt bietet, ihn jedoch in einer für den Programmierer versteckten, komplexen Struktur abspeichert. Auch jegliche andere Semantik wäre denkbar.

Die Prototypen für das Überladen des Dereferenz-Operators sind die folgenden (Einschränkungen und Erläuterungen siehe Überladen von Operatoren):

inside class


outside class

Type operator *();
Type operator *() const;

Type operator *(Type);

Vorsicht ist geboten bei dem Prototypen ausserhalb der Klasse: Wenn er innerhalb der Klasse steht, wird er von den Compilern nicht als Fehler erkannt, da er einem Prototypen des Multiplikations-Operators entspricht.

Das folgende etwas ausführlichere Beispiel präsentiert eine Klasse für ein Listen-Element. Um die Liste abzuarbeiten, bedient man sich häufig sogenannter Iteratoren. Mittels des überladenen Dereferenz-Operators der Iterator-Klasse kann direkt auf den Inhalt des Listen-Elements zugegriffen werden, ohne sowohl das Listen-Element als auch den Iterator selbst in irgend einer Weise anzusprechen oder die Speicherstruktur zu kennen. Man beachte bei diesem Beispiel, dass der Dereferenz-Operator durch die Überladung nicht auf einen Pointer angewendet wird, sondern auf eine Klasseninstanz.

Maria: 33
Tommy: 32
Jim: 35
Tanja: 34

#include <cstdio>

class Person{
  const char* name;
  int age;
public:
  Person(const char* newname, int newage)
    : name(newname), age(newage){}
  void printInfo(){printf("%s: %d\n", name, age);}
};

class ListElement{
  Person content;
  ListElement* next;
  friend class Iterator;
public:
  ListElement(const char* newname, int newage, ListElement* nelem)
    : content(newname, newage), next(nelem){}
};

class Iterator{
  ListElement* cur;
public:
  Iterator(ListElement& newcurrent){cur = &newcurrent;}
  operator bool(){return cur!=NULL;}
  Iterator& operator ++(){
    if(cur){cur = (*cur).next;}
    return *this;
  }
  Person& operator *(){
    return cur->content;
  }
};

int main(){
  ListElement e4("Tanja", 34, NULL);
  ListElement e3("Jim",   35, &e4);
  ListElement e2("Tommy", 32, &e3);
  ListElement e1("Maria", 33, &e2);

  for(Iterator e(e1);e;++e){
    (*e).printInfo();
  }

  return 0;
}