Constant Pointers & Pointers to Constants in C meistern

Folgend die Syntax eines konstanten Pointers:

data_type *const pointer_name = &variable;

In dieser Syntax ist data_type der Datentyp, auf den der Pointer zeigt, *const macht den Pointer selbst konstant, pointer_name ist der Name des Pointers, und &variable weist ihm die Speicheradresse einer Variable zu.

Beispiel für einen konstanten Pointer

In diesem Beispiel deklarieren wir einen konstanten Pointer ptr und initialisieren ihn mit der Adresse der Variable x. Dann ändern wir den Wert von x mittels ptr und geben ihn aus.

#include <stdio.h>
int main() {
    int x = 10;
    int y = 20;
    int *const ptr = &x; // konstanter Pointer auf int
    printf("Value of x: %d\n", *ptr);
    *ptr = 15; // Wert an der Adresse ändern erlaubt
    printf("Modified value of x: %d\n", *ptr);
    // ptr = &y; // Adresse ändern nicht erlaubt
    return 0;
}

Die Ausgabe zeigt, dass der Pointer fest auf x bleibt, aber der Wert von x aktualisiert werden kann:

Value of x: 10
Modified value of x: 15

Beispiel für einen Constant-Pointer-Fehler

Hier deklarieren wir einen konstanten Pointer ptr mit der Adresse von x und versuchen dann, ihn auf die Adresse von y zu setzen. Das ergibt einen Fehler, da ein konstanter Pointer nach Initialisierung nicht auf eine andere Speicherstelle zeigen kann.

#include <stdio.h>
int main() {
    int x = 10;
    int y = 20;
    int *const ptr = &x; // konstanter Pointer auf int
    printf("Value of x: %d\n", *ptr);
    // Versuch, Pointer auf y zu ändern
    ptr = &y; // Adresse eines konstanten Pointers ändern nicht erlaubt
    return 0;
}

Der Fehler:

error: assignment of read-only variable 'ptr'

Pointer to Constant (Pointer auf Konstante)

Ein Pointer auf Konstante bedeutet, dass der Wert, auf den er zeigt, nicht geändert werden kann, aber der Pointer selbst auf verschiedene Speicheradressen (oder Variablen) zeigen kann.

Folgend die Syntax für Pointer auf Konstante:

const data_type *pointer_name = &variable;
data_type const *pointer = &variable;

In dieser Syntax bedeutet const data_type oder data_type const, dass der Pointer auf einen konstanten Wert zeigt, pointer_name ist der Name des Pointers, und &variable weist ihm die Adresse einer Variable zu.

Beispiel für Pointer auf Konstante

In diesem Beispiel deklarieren wir einen Pointer ptr, der auf einen konstanten Wert zeigt, und weisen ihm die Adresse von Variable a zu. Dann lassen wir den Pointer auf eine andere Adresse von Variable b zeigen und geben den Wert aus.

#include <stdio.h>
int main() {
    int a = 5;
    int b = 30;
    const int *ptr = &a; // Pointer auf konstantes int
    printf("Value of a: %d\n", *ptr);
    // *ptr = 10; // Wert über Pointer nicht änderbar
    ptr = &b; // Pointer-Adresse ändern erlaubt
    printf("Now pointing to b: %d\n", *ptr);
    return 0;
}

Ausgabe – derselbe Pointer zeigt auf verschiedene Variablen:

Value of a: 5
Now pointing to b: 30

Beispiel für Pointer-auf-Konstante-Fehler

Hier deklarieren wir einen Pointer auf Konstante ptr mit der Adresse von a und versuchen dann, den Wert von a über den Pointer zu ändern. Das gibt einen Fehler, da ein Pointer auf Konstante das Modifizieren des Werts nicht erlaubt.

#include <stdio.h>
int main() {
    int a = 5;
    const int *ptr = &a; // Pointer auf konstantes int
    printf("Value of a: %d\n", *ptr);
    // Wert über Pointer auf Konstante nicht änderbar
    *ptr = 10;
    return 0;
}

Fehlerausgabe:

error: assignment of read-only location '*ptr'

Constant Pointer to Constant (Konstanter Pointer auf Konstante)

Ein konstanter Pointer auf eine Konstante ist ein Pointer, der weder seine Speicheradresse ändern kann, noch der Wert an dieser Adresse geändert werden kann. Beide Aktionen sind eingeschränkt – man kann nur den Wert lesen.

Folgend die Syntax für einen konstanten Pointer auf Konstante:

const data_type *const pointer_name = &variable;

In dieser Syntax:

• const data_type zeigt an, dass der Wert an der Speicherstelle nicht über den Pointer geändert werden kann.
• *const pointer_name bedeutet, der Pointer selbst kann nach Initialisierung keine andere Speicheradresse anzeigen.
• &variable weist dem Pointer die Speicheradresse der Variable zu.

Beispiel für konstanten Pointer auf Konstante

In diesem Beispiel deklarieren wir einen konstanten Pointer auf Konstante ptr und weisen ihm die Speicheradresse von Variable a zu. Dann geben wir den Wert von a über den Pointer aus.

#include <stdio.h>
int main() {
    int a = 10;
    const int *const ptr = &a; // konstanter Pointer auf Konstante
    printf("Value of a: %d\n", *ptr);
    // *ptr = 15; // Wert nicht änderbar
    // ptr = &b; // Pointer-Adresse nicht änderbar
    return 0;
}

Ausgabe:

Value of a: 10

Beispiel für Constant-Pointer-to-Constant-Fehler

In diesem Beispiel deklarieren wir einen konstanten Pointer auf Konstante ptr mit Variable a. Dann versuchen wir, den Wert über den Pointer zu modifizieren und den Pointer auf eine andere Variable zeigen zu lassen. Beide Operationen sind nicht erlaubt und resultieren in einem Compiler-Fehler.

#include <stdio.h>
int main() {
    int a = 10;
    int b = 20;
    const int *const ptr = &a; // konstanter Pointer auf Konstante
    printf("Value of a: %d\n", *ptr);
    // *ptr = 15; // Wert nicht änderbar
    // ptr = &b; // Pointer-Adresse nicht änderbar
    return 0;
}

Ausgabe (Fehler werden beim Kompilieren angezeigt):

Value of a: 10

Unterschied zwischen den konstanten Pointer-Typen

Die folgende Tabelle zeigt die Unterschiede zwischen einem konstanten Pointer, einem Pointer auf Konstante und einem konstanten Pointer auf Konstante.

Fazit

In diesem Kapitel haben wir konstante Pointer und Pointer auf Konstanten in C behandelt. Konstante Pointer fixieren die Adresse, erlauben aber Wertänderungen; Pointer auf Konstante erlauben Adressänderungen, aber nicht Wertänderungen; konstante Pointer auf Konstante beschränken beides.