• Software
• Seitenartikel

C++ Zeiger und Referenzen

Einführung in C++ Zeiger und Referenzen. Anlegen von Zeiger und Referenzen und Übergabe an eine Methode.

Zeiger und Referenzen
Variablen liegen bekanntlich im Hauptspeicher eines Rechners. Jede Zelle dieses Hauptspeicher ist über ihre Adresse eindeutig identifizierbar. Somit besitzen alle im Speicher enthaltenen Daten eine Adresse.

Eine Variable, die nun keine echten Daten, sonder eine Adresse beinhaltet, nennt man Pointer (Zeiger). Unter C und C++ muss zur Deklaration und Definition eines Pointers der >>*<<-Operator verwenden werden. Möchte man auf den Wert des abgespeicherten Pointers zugreifen, muss ebenfalls der >>*<<-Operator verwendet werden.


Der >>*<<-Operator wird also abhängig vom Kontext unterschiedlich benutzt. Bei Deklarationen und Definitionen bedeutet er >>Pointer<<, und bei Zuweisungen und Bedingungen >>Inhalt von<<.


Alle Daten im Speicher sind durch einen Typ gekennzeichnet. Dieser Typ besagt zwei Dinge:
1. Platzbedarf in Byte zur Speicherung der Daten
2. Die Bedeutung der abgespeicherten Daten - also ob es sich etwa um einen String oder um spezifische Datenstrukturen handelt

Daraus erhält man auch den Platz an Speicher, welchen ein Pointer im Hauptspeicher belegt.


Verwenden von Variablen, Zeigern und Referenzen
gerade für Programmierneulinge ist es sehr schwer den Unterschied zwischen "normalen" Variablen, Zeigern und Referenzen zu verstehen. Zugegeben es ist auch etwas verwirrend. Befolgen Sie daher folgende Regeln:

* Eine Variable liefert standardmäßig den Variablenwert.
* Die Adresse einer Variablen erhält man durch das davor stellen des &-Zeichens (Referenz).

* Ein Zeiger liefert standardmäßig die Adresse auf den gezeigten Speicherplatz.
* Den Wert auf den eine Adresse zeigt, erhält man durch das davor stellen eines *-Zeichens.


Adressen und Referenzen sind im Grunde das Selbe. Beide liefern den Speicherort einer Variablen, nur werden sie unterschiedlich eingesetzt!

#include <iostream>
using namespace std;
 
int main ( )
{
  int var;
  var = 10;
 
  int *pointer = new int();
  *pointer = 20;
 
  int& ref = *pointer;
 
 
  // Variable
  cout << var;  // var = 10
  cout << &var; // &var = 0012FF60
 
 
  // Zeiger
  cout << *pointer; // *pointer = 20
  cout << pointer;  // pointer = 004765E0
 
 
  // Referenz
  cout << ref;  // ref = 20
  cout << &ref; // &ref = 004765E0
 
 
  // Methode Zeigeradresse übergeben
  methode1(pointer);
 
 
  // Methode Zeigerwert übergeben
  methode2(*pointer);
 
 
 return 0;
}

void methode1( int* i )
{
  cout << "Wert = " << *i; // *i = 20
  cout << "Adresse = " << i; // i = 004765E0
}
 

void methode2( int i )
{
  cout << "Wert = " << i; // i = 20
  cout << "Adresse = " << &i; // &i = 004765E0
}

int i; // Variable deklarieren
int *aPtr; // Pointer mit der Adresse eines Int-Wertes
aPtr = &i; // Adresse von i wird an den Pointer übergeben

// Zeiger, der auf ein Zeigerarray zeigt
struct Entry
{
  int key;
  int value;
};
 
Entry** arrPtr;
arrPtr = new int*[100];
 
// Zugriff auf das Zeigerarray
cout << arrPtr[10]->key << endl;
 
 
 
// Zeiger, der auf einen Character-Zeiger zeigt
char **charPtr;