Verständnis von Pointern

Was ist ein Zeiger

Sie können sich Zeiger als Koordinaten vorstellen. Sie zeigen uns auf bestimmte Speicherorte und ermöglichen uns den Zugriff auf die in diesen Speicherorten gespeicherten Daten.

Wenn Sie einen Zeiger deklarieren, erstellen Sie eine Variable, die die Speicheradresse einer anderen Variable enthält. Sie können einen Zeiger mit den Operatoren * und & erstellen.

pointer


              1234
            
int value = 42;

// `p_value` now holds the memory address of `value`
int* p_value = &value;

Null-Zeiger

Sie können spezielle Schlüsselwörter verwenden, um einen Null-Zeiger darzustellen: null oder nullptr. Ein Null-Zeiger zeigt auf keine gültige Speicheradresse. Es ist im Wesentlichen ein Zeiger ohne Ziel.

Sie können auch den Integer-Zeiger auf null (oder nullptr) initialisieren. Dies tun wir, wenn wir den Zeiger nicht sofort mit einem bestimmten Wert verknüpfen möchten.

null_pointer


              123
            
int* p_int = null; // `p_int` is initialized to be null

double* p_double = nullptr; // `p_double` is initialized to be null

Zeiger neu zuweisen

Zeiger können neu zugewiesen werden, um auf verschiedene Speicheradressen zu zeigen. Allerdings kann das Neuzuweisen eines Zeigers ohne ordnungsgemäße Verwaltung zu Problemen wie Speicherlecks oder hängenden Zeigern führen.

reassigning_pointers


              12345
            
int x = 42; // Create an integer variable and assign a value to it
int y = 43; // Create another integer variable

int* p_int = &x; // Make the `p_int` variable point to the address of the integer variable `x`
p_int = &y; // Reassign the `p_int` variable to `y`

Zeigerarithmetik

Die Zeigerarithmetik ist ein faszinierender Aspekt von Zeigern. Sie ermöglicht es Ihnen, den Speicher zu durchlaufen, indem Sie die Adresse erhöhen oder verringern, die von einem Zeiger gehalten wird.

Betrachten Sie zum Beispiel den folgenden Code, in dem wir ein Array von Ganzzahlen erstellen und dann einen Zeiger definieren, um die Adresse des Arrays zu halten. Da ein Array mehrere Elemente enthält, speichert ein Zeiger standardmäßig die Adresse des ersten Elements, das in diesem Fall die Ganzzahl 1 ist.

pointer_arithmetic


              1234567891011
            
// Defining an array of integers
int arr[5] = {1, 2, 3, 4, 5};

// The pointer holds the memory address of the first element in the array
int* p_int = arr; 

// Incrementing the pointer makes the pointer point to the second value
p_int = p_int + 1;

// Dereference the pointer to get the actual second value
int second_element = *p_int; // Equals to `2`

Um auf das zweite Element zuzugreifen, erhöhen Sie den Zeiger um 1 und dereferenzieren Sie ihn dann mit dem (*) Operator. Das Dereferenzieren gibt den Wert zurück, der an der Speicheradresse gespeichert ist, die vom Zeiger gehalten wird (in diesem Fall die Ganzzahl 2). Folgen Sie den Kommentaren im Code, um jeden Schritt zu verstehen!

War alles klar?

Danke für Ihr Feedback!

Abschnitt 1. Kapitel 1