Mit Hilfe von Zeigerarithmetik ist es möglich, durch zusammenhängende Speicherbereiche zu navigieren. Erfahren Sie, wie Zeigerarithmetik funktioniert.
Zeigerarithmetik bietet Ihnen wertvolle Möglichkeiten, mit Hilfe von Pointern durch zusammenhängende Speicherbereiche zu navigieren. Allerdings müssen Sie sich – wie es beim Thema Zeiger immer der Fall ist – über die Gefahren der Zeigerarithmetik bewusst sein.
Was ist Zeigerarithmetik?
Wie Sie natürlich wissen, können Sie mit Variablen rechnen. Sie können die Werte mit Hilfe von Rechenoperationen wie Addition oder Subtraktion verändern. Ganz wichtig ist dabei: Sie verändern den Wert der Variablen.
Mit Zeigern können Sie auch rechnen. Sie können den Wert eines Zeigers um fünf erhöhen. Dabei müssen Sie allerdings beachten, dass der Wert eines Zeigers eine Speicheradresse ist. Wenn Sie eine Speicheradresse um fünf erhöhen, springt der Zeiger fünf Speicherstellen weiter. Stellen wir uns einen Zeiger auf eine int-Variable vor. Definieren wir int einmal auf eine Größe von vier Byte.
Sie erhöhen den Wert des Zeigers um eins. Damit zeigt der Pointer auf die nächste Speicherstelle, die vier Byte entfernt ist. Erhöhen Sie den Wert des Zeigers um fünf, zeigt der Pointer auf die Speicherstelle, die 4 * 5 Byte, also 20 Byte, entfernt liegt. Sie sehen, dass Sie auf diese Art durch zusammenhängende Speicherbereiche navigieren können. Indem Sie Werte subtrahieren, können Sie in die andere Richtung navigieren.
Zeigerarithmetik in C / C++
Deklarieren Sie einen Zeiger auf eine int-Variable. Wenn Sie den Zeiger dereferenzieren und dann den Wert erhöhen, wird wirklich der Wert des referenzierten Objekts, also der int-Variable, erhöht. Dereferenzieren Sie den Zeiger nicht, verändern Sie die im Zeiger gespeicherte Speicheradresse. Wie bei gewöhnlichen Variablen funktioniert dies mit den Operatoren + und -. Sie können auch ++ und — einsetzen, wenn Sie nur eine Speicherstelle weiter springen möchten.
int zahl = 5;
int * myPointer = &zahl;
myPointer zeigt auf die Speicheradresse der Variablen zahl. Nun können Sie bspw. in einer Schleife den Wert des Zeigers schrittweise erhöhen, wie Sie im folgenden Codeausschnitt sehen können.
for (int i = 0; i < 10; i++)
{
myPointer++;
}
Anschließend zeigt myPointer nicht mehr auf die Variable zahl, sondern auf die nächsten Speicherbereiche. Selbstverständlich müssen Sie darauf achten, dass die Werte in diesen Speicherbereichen auch definiert sind. Das ist eine der größten Gefahren bei Zeigerarithmetik. Wenn Sie hier unvorsichtig sind, können sich sehr schwer auffindbare Fehler in Ihr Programm einschleichen. Behandeln Sie daher dieses Thema mit äußerster Vorsicht und setzen Sie Zeigerarithmetik nur ein, wenn es unbedingt vonnöten ist.
Beispiel
Beobachten Sie in diesem Programm, wie sich die Zeiger verhalten, wenn Sie Zeigerarithmetik einsetzen.
/* Dieses Beispiel zeigt die Verwendung von Zeigerarithemtik.*/
#include
#include
#include
int main()
{
int zahl = 5;
int zahl2 = 9;
int * myPointer = &zahl; // Ein Zeiger, der auf zahl zeigt.
cout << „Der Zeiger zeigt auf die Speicheradresse “ << myPointer << endl;
cout << „Der Zeiger zeigt auf den Wert “ << *myPointer << endl;
// In einer Schleife wird die Adresse von myPointer erhöht.
for (int i = 0; i < 10; i++)
{
myPointer++;
cout << „Der Zeiger zeigt auf die Speicheradresse “ << myPointer << endl;
cout << „Der Zeiger zeigt auf den Wert “ << *myPointer << endl;
}
getch();
// Dem Zeiger wird eine andere Adresse zugewiesen.
myPointer = &zahl2;
cout << „———————————————————-“ << endl;
cout << „Der Zeiger zeigt auf die Speicheradresse “ << myPointer << endl;
cout << „Der Zeiger zeigt auf den Wert “ << *myPointer << endl;
// In einer Schleife wird die Adresse von myPointer verändert.
for (int i = 0; i < 10; i++)
{
myPointer = myPointer + i;
cout << „Der Zeiger zeigt auf die Speicheradresse “ << myPointer << endl;
cout << „Der Zeiger zeigt auf den Wert “ << *myPointer << endl;
}
getch();
}