Beherrschen von Konstantenzeigern und Zeigern auf Konstanten in C

In C ein Zeiger ist eine Variable, die die Speicheradresse einer anderen Variablen und das const-Schlüsselwort speichert wird verwendet, um eine Variable oder einen Zeiger zu definieren, dessen Wert nach der Initialisierung nicht mehr geändert werden kann. Wenn wir Zeiger kombinieren mit const Schlüsselwort:Wir können zwei Dinge kontrollieren:

• Ob sich die im Zeiger gespeicherte Adresse ändern kann.
• Ob sich der an dieser Adresse gespeicherte Wert ändern kann.

In diesem Kapitel werden wir uns die drei Hauptvarianten von Konstantenzeigern ansehen −

• Konstanter Zeiger
• Zeiger auf Konstante
• Konstantenzeiger auf Konstante

Konstanter Zeiger

Ein konstanter Zeiger bedeutet, dass der Zeiger selbst konstant ist. Sobald es so initialisiert ist, dass es auf einen Speicherort zeigt, kann es nicht mehr auf einen anderen Ort verweisen, aber der an diesem Ort gespeicherte Wert kann immer noch geändert werden.

Es folgt die Syntax eines Konstantenzeigers −

data_type *const pointer_name = &variable;

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

Beispiel für einen Konstantenzeiger

In diesem Beispiel deklarieren wir einen konstanten Zeiger ptr und initialisieren Sie es mit der Adresse der Variablen x . Dann ändern wir den Wert von x mit ptr und wir geben seinen Wert aus.

#include <stdio.h>
int main() {
 int x = 10;
 int y = 20;
 int *const ptr = &x; // constant pointer to int
 printf("Value of x: %d\n", *ptr);
 *ptr = 15; // can change the value at address
 printf("Modified value of x: %d\n", *ptr);
 // ptr = &y; // changing pointer address is not allowed
 return 0;
}

Unten ist die Ausgabe dargestellt des obigen Programms, was zeigt, dass der Zeiger auf x fixiert bleibt , sondern der Wert vonx kann aktualisiert werden.

Value of x: 10
Modified value of x: 15

Beispiel für einen Konstantenzeigerfehler

Hier ist ein Beispiel, in dem wir einen konstanten Zeiger ptr deklarieren und initialisieren Sie es mit der Adresse der Variablen x . Dann versuchen wir, es auf die Adresse der Variablen y zu verweisen . Dies führt zu einemFehler weil ein konstanter Zeiger nicht auf einen anderen Speicherort verweisen kann, sobald er initialisiert wurde.

#include <stdio.h>
int main() {
 int x = 10;
 int y = 20;
 int *const ptr = &x; // constant pointer to int
 printf("Value of x: %d\n", *ptr);
 // Attempting to change the pointer to point to y
 ptr = &y; // cannot change the address of a constant pointer
 return 0;
}

Sie können den Fehler unten sehen , was darauf hinweist, dass wir die Adresse eines konstanten Zeigers nicht ändern können.

error: assignment of read-only variable 'ptr'

Zeiger auf Konstante

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

Im Folgenden finden Sie die Syntax für einen Zeiger auf eine Konstante −

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

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

Beispiel für einen Zeiger auf eine Konstante

In diesem Beispiel deklarieren wir einen Zeigerptr das auf einen konstanten Wert zeigt und ihm die Adresse der Variable a zuweist . Dann veranlassen wir den Zeiger, auf eine andere Adresse der Variable b zu zeigen und geben Sie den Wert aus.

#include <stdio.h>
int main() {
 int a = 5;
 int b = 30;
 const int *ptr = &a; // pointer to constant int
 printf("Value of a: %d\n", *ptr);
 // *ptr = 10; //we cannot modify value through pointer
 ptr = &b; // canging pointer address
 printf("Now pointing to b: %d\n", *ptr);
 return 0;
}

Es folgt die Ausgabe des obigen Programms, das denselben Zeiger zeigt, der auf verschiedene Variablen zeigt.

Value of a: 5
Now pointing to b: 30

Beispiel eines Zeigers auf einen konstanten Fehler

Hier ist ein Beispiel, in dem wir einen Zeiger auf die Konstante ptr deklarieren und initialisieren Sie es mit der Adresse der Variablena . Dann versuchen wir, den Wert von a zu ändern durch den Zeiger. Dies führt zu einem Fehler weil ein Zeiger auf eine Konstante es nicht zulässt, den Wert zu ändern, auf den er zeigt.

#include <stdio.h>
int main() {
 int a = 5;
 const int *ptr = &a; // pointer to constant int
 printf("Value of a: %d\n", *ptr);
 // we cnnot modify value through pointer to constant
 *ptr = 10; 
 return 0;
}

Unten sehen Sie die Ausgabe , was einen Fehler anzeigt Dies zeigt an, dass wir den Wert nicht durch einen Zeiger auf eine Konstante ändern können.

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

Konstantenzeiger auf Konstante

Ein konstanter Zeiger auf eine Konstante ist ein Zeiger, der seine Speicheradresse nicht ändern kann, und der an dieser Speicheradresse gespeicherte Wert kann ebenfalls nicht geändert werden. Beide Aktionen sind eingeschränkt, sodass wir nur den Wert lesen können, sonst nichts.

Im Folgenden finden Sie die Syntax für einen Konstantenzeiger auf eine Konstante −

const data_type *const pointer_name = &variable;

In dieser Syntax −

• const data_type zeigt an, dass der Wert am Speicherort nicht über den Zeiger geändert werden kann.
• *const pointer_name bedeutet, dass der Zeiger selbst nach der Initialisierung nicht auf eine andere Speicheradresse zeigen kann.
• &variabel weist den Zeiger auf die Speicheradresse der Variablen zu.

Beispiel eines Konstantenzeigers auf eine Konstante

In diesem Beispiel deklarieren wir einen konstanten Zeiger auf die Konstante ptr und weisen Sie ihm die Speicheradresse der Variablen a zu . Anschließend geben wir den Wert von a aus mit dem Zeiger.

#include <stdio.h>
int main() {
 int a = 10;
 const int *const ptr = &a; // constant pointer to constant
 printf("Value of a: %d\n", *ptr);
 // *ptr = 15; // we cannot modify value
 // ptr = &b; // we annot change pointer location
 return 0;
}

Es folgt die Ausgabe des obigen Programms −

Value of a: 10

Beispiel eines konstanten Zeigers auf einen konstanten Fehler

In diesem Beispiel deklarieren wir einen konstanten Zeiger auf die Konstanteptr und initialisieren Sie es mit einer Variablen a . Dann versuchen wir, den Wert über den Zeiger zu ändern und den Zeiger auch auf eine andere Variable zeigen zu lassen. Beide Vorgänge sind nicht zulässig und führen zu einem Compilerfehler .

#include <stdio.h>
int main() {
 int a = 10;
 int b = 20;
 const int *const ptr = &a; // constant pointer to constant
 printf("Value of a: %d\n", *ptr);
 // *ptr = 15; // we cnnot modify value
 // ptr = &b; // we cannot change pointer address
 return 0;
}

Unten sehen Sie die Ausgabe Zeigt die Fehler an −

Value of a: 10

Unterschied zwischen Konstantenzeigertypen

Die folgende Tabelle zeigt die Unterschiede ein konstanter Zeiger, ein Zeiger auf eine Konstante und ein konstanter Zeiger auf eine Konstante.

Variante Definition Kann die Adresse geändert werden? Kann sich der Wert ändern? Beispielsyntax Konstanter ZeigerEin Zeiger, dessen Adresse fest ist, aber der Wert an dieser Adresse kann geändert werden.NeinJa

int *const p = &x;

Zeiger auf KonstanteEin Zeiger, der auf verschiedene Adressen zeigen kann, aber den Wert an der angegebenen Stelle nicht ändern kann.JaNein

const int *p = &x;

Konstanter Zeiger auf KonstanteEin Zeiger, dessen Adresse fest ist und dessen Wert an dieser Adresse nicht geändert werden kann.NeinNein

const int *const p = &x;

Schlussfolgerung

In diesem Kapitel haben wir Konstantenzeiger und Zeiger auf Konstanten in C behandelt. Konstantenzeiger Korrigieren Sie die Adresse, erlauben Sie jedoch das Ändern des Werts, Zeiger auf Konstante erlauben das Ändern der Adresse, aber nicht des Werts, und konstante Zeiger auf konstant beides einschränken.