Pointer-Zugriff ->

Der Pointer-Zugriff-Operator erlaubt es, auf untergeordnete Symbole einer Variablen vom Typ Pointer auf struct, Pointer auf class oder Pointer auf union zuzugreifen. Die Variable steht dabei links der Zeichen -> und das gewünschte Symbol auf der rechten Seite.

Name: Maria
Age : 33

#include <stdio.h>

struct Person{
  char* name;
  int age;
};

int main(){
  struct Person pers = {"Maria", 33};
  struct Person* p = &pers;
  printf("Name: %s\n", p->name);
  printf("Age : %d\n", p->age);
  return 0;
}

Siehe auch Feld-Zugriff-Operator ., Pointer-Member-Operator .->

Details

Der Pointer-Zugriff-Operator erwartet links einen lvalue und rechts ein Symbol und wird von links nach rechts abgearbeitet. Der Rückgabewert ist ein lvalue: Der Wert des gesuchten Symbols.

Auf der linken Seite des Pointer-Zugriff-Operators kann ein beliebiger Ausdruck stehen, der zu einem lvalue ausgewertet wird. Wenn der links stehende Ausdruck als const deklariert ist, so gilt dies auch für den Rückgabewert.

Der Pointer-Zugriff-Operator wird für Ausdrücke verwendet, welche einen Pointer auf einen Wert darstellen. Im Gegensatz dazu wird der Feld-Zugriff-Operator für Ausdrücke verwendet, welche direkt einen Wert oder eine Referenz auf einen solchen Wert darstellen.

Überladen des Operators

Im Gegensatz zum Feld-Zugriff-Operator kann der Pointer-Zugriff-Operator überladen werden, allerdings nur mit Einschränkungen. Das Überladen dieses Operators könnte man als eine Weiterleitung bezeichnen: Das gewünschte Symbol auf der rechten Seite des Operators wird nicht direkt in dem links angegebenen Objekt gesucht, sondern in dem Objekt, welches durch die Überladung zurückgegeben wird. Der Pointer-Zugriff-Operator muss somit einen Pointer zu ein Objekt zurückzugeben, welches ein gewünschtes Symbol beinhaltet. Dementsprechend sind die Prototypen für das Überladen des Pointer-Zugriff-Operators die folgenden (weitere Einschränkungen und Erläuterungen siehe Überladen von Operatoren):

inside class

PointerToObject operator ->();
PointerToObject operator ->() const;

Dieser Operator kann ausserhalb der Klasse NICHT überladen werden. Auch innerhalb der Klasse ist die Überladung nur sinnvoll, wenn ein Pointer auf ein Objekt (Deklariert mittels struct, class oder union) zurückgegeben wird. Versucht man einen nicht-Pointer mittels dieser Überladung zurückzugeben, so entsteht ein Fehler: Result of 'operator->()' yields non-pointer result. Versucht man, einen Pointer auf ein nicht-Objekt zurückzugeben, so wird das Symbol nicht gefunden werden. Die Überladung erwartet zudem keine Argumente.

Das Überladen des Pointer-Zugriff-Operators ist speziell nützlich bei Containerklassen. Containerklassen speichern irgendwelchen Inhalt in einer komplexen Datenstruktur. Um den Inhalt anzusprechen, bedient man sich häufig sogenannter Iteratoren. Im folgenden etwas ausführlicheren Beispiel wird somit eine Klasse für ein Listen-Element sowie eine Klasse für einen Iterator präsentiert. Mittels des überladenen Pointer-Zugriff-Operators der Iterator-Klasse kann direkt auf den Inhalt des Listen-Elements zugegriffen werden, ohne das Listen-Element selbst in irgend einer Weise anzusprechen oder die Speicherstruktur zu kennen.

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;
}