Konstanter Zeiger vs Zeiger auf Konstante

const int * ptr;

bedeutet, dass die angezeigten Daten konstant und unveränderlich sind, der Zeiger jedoch nicht.

int * const ptr;

bedeutet, dass der Zeiger konstant und unveränderlich ist, die angezeigten Daten jedoch nicht.

1) Konstante Zeiger: Diese Art von Zeigern kann die Adresse, auf die sie zeigen, nicht ändern. Dies bedeutet, dass angenommen wird, dass es einen Zeiger gibt, der auf eine Variable zeigt (oder die Adresse dieser Variablen speichert). Wenn wir nun versuchen, den Zeiger auf eine andere Variable zu verweisen (oder versuchen, die Zeigeradresse einer anderen Variablen zu speichern), sind konstante Zeiger dazu nicht in der Lage.

Ein konstanter Zeiger wird wie folgt deklariert: int *const ptr (die Position von 'const' macht den Zeiger 'ptr' zum konstanten Zeiger)

2) Zeiger auf Konstante: Diese Art von Zeigern kann den Wert, auf den sie zeigen, nicht ändern. Dies bedeutet, dass sie den Wert der Variablen, deren Adresse sie halten, nicht ändern können.

Ein Zeiger auf eine Konstante wird wie folgt deklariert: const int *ptr (Die Position von 'const' macht den Zeiger 'ptr' zum Zeiger auf eine Konstante.

Beispiel

Konstanter Zeiger

#include<stdio.h>

int main(void)
{
    int a[] = {10,11};
    int* const ptr = a;

    *ptr = 11;

    printf("\n value at ptr is  : [%d]\n",*ptr);
    printf("\n Address pointed by ptr  : [%p]\n",(unsigned int*)ptr);

    ptr++;
    printf("\n Address pointed by ptr  : [%p]\n",(unsigned int*)ptr);

    return 0;
}

Wenn wir nun den obigen Code kompilieren, beschwert sich der Compiler:

practice # gcc -Wall constant_pointer.c -o constant_pointer
constant_pointer.c: In function ‘main’:
constant_pointer.c:13: error: increment of read-only variable ‘ptr’

Daher sehen wir oben sehr deutlich, dass der Compiler sich darüber beschwert, dass wir die von einem konstanten Zeiger gehaltene Adresse nicht ändern können.

Zeiger auf Konstanten

#include<stdio.h>

int main(void)
{
    int a = 10;
    const int* ptr = &a;


    printf("\n value at ptr is  : [%d]\n",*ptr);
    printf("\n Address pointed by ptr  : [%p]\n",(unsigned int*)ptr);

    *ptr = 11;

    return 0;
}

Wenn nun der obige Code kompiliert wird, beschwert sich der Compiler:

practice # gcc -Wall pointer_to_constant.c -o pointer_to_constant
pointer_to_constant.c: In function ‘main’:
pointer_to_constant.c:12: error: assignment of read-only location ‘*ptr’

Daher sehen wir auch hier, dass der Compiler nicht zulässt, dass der Zeiger auf eine Konstante den Wert der Variablen ändert, auf die gezeigt wird.

Zitat

Verweis von This Thread

Konstante Zeiger

Lassen Sie uns zunächst verstehen, was ein konstanter Zeiger ist. Ein konstanter Zeiger ist ein Zeiger, der die gehaltene Adresse nicht ändern kann. Mit anderen Worten, wenn ein konstanter Zeiger auf eine Variable zeigt, kann er nicht auf eine andere Variable zeigen.

Ein konstanter Zeiger wird wie folgt deklariert:
<type of pointer> * const <name of pointer>
Eine Beispieldeklaration würde so aussehen:
int * const ptr;
Nehmen wir einen kleinen Code, um diese Art von Zeigern zu veranschaulichen:

#include<stdio.h>

int main(void)
{
    int var1 = 0, var2 = 0;
    int *const ptr = &var1;
    ptr = &var2;
    printf("%d\n", *ptr);

    return 0;
} 

Im obigen Beispiel:

• Wir haben zwei Variablen var1 und var2 deklariert
  
• Ein konstanter Zeiger "ptr" wurde deklariert und auf den Punkt var1 gesetzt
  
• Als nächstes wird ptr gemacht, um var2 zu zeigen.
  
• Schließlich versuchen wir, den Wert zu drucken, auf den ptr zeigt.
  

Zeiger auf Konstante

Wie aus dem Namen hervorgeht, ist ein Zeiger, durch den der Wert der Variablen, auf die er zeigt, nicht geändert werden kann, als Zeiger auf die Konstante bekannt. Diese Art von Zeigern kann die Adresse ändern, auf die sie zeigen, aber nicht den Wert, der an dieser Adresse gespeichert ist.

Ein Zeiger auf eine Konstante ist definiert als: const <type of pointer>* <name of pointer> Ein Beispiel für eine Definition könnte sein: const int* ptr; Nehmen wir einen kleinen Code, um einen Zeiger auf eine Konstante zu veranschaulichen:

 #include<stdio.h>

int main(void)
{
    int var1 = 0;
    const int* ptr = &var1;
    *ptr = 1;
    printf("%d\n", *ptr);

    return 0;
} 

Im obigen Code:

• Wir haben eine Variable var1 mit dem Wert 0 definiert
• wir haben einen Zeiger auf eine Konstante definiert, die auf die Variable var1 zeigt
• Mit diesem Zeiger haben wir versucht, den Wert von var1 zu ändern
• Mit printf wird der neue Wert gedruckt.

const int* ptr;

ist ein Zeiger auf eine Konstante (Inhalt). Sie dürfen den Zeiger ändern. z.B. ptr = NULL, ptr++, aber eine Änderung des Inhalts ist nicht möglich .

int * const ptr;

Ist ein konstanter Zeiger. Das Gegenteil ist möglich. Sie dürfen nicht den Zeiger ändern, aber Sie dürfen ändern, auf was er zeigt, z. *ptr += 5.

int i;
int j;

int * const ptr1 = &i;

Der Compiler stoppt die Änderung von ptr1.

const int * ptr2 = &i;

Der Compiler stoppt die Änderung von *ptr2.

ptr1 = &j; // error
*ptr1 = 7; // ok

ptr2 = &j; // ok
*ptr2 = 7; // error

Beachten Sie, dass Sie *ptr2 Immer noch ändern können, nur nicht durch buchstäbliche Eingabe von *ptr2:

i = 4;
printf("before: %d\n", *ptr2); // prints 4
i = 5;
printf("after: %d\n", *ptr2); // prints 5
*ptr2 = 6; // still an error

Sie können auch einen Zeiger mit beiden Funktionen haben:

const int * const ptr3 = &i;

ptr3 = &j; // error
*ptr3 = 7; // error

const int* ptr; hier denke wie * ptr ist konstant und * ptr kann nicht wieder geändert werden

int * const ptr; während hier wie ptr als Konstante denken und das kann nicht wieder geändert werden

Weitere Informationen zum Unterschied zwischen Const-Zeiger und Zeiger bei einem konstanten Wert finden Sie unter dem folgenden Link.

konstanter Zeiger gegen Zeiger auf einen konstanten Wert