Ich möchte den Unterschied zwischen wissen
const int* ptr;
und
int * const ptr;
und wie es funktioniert.
Es ist ziemlich schwierig für mich, das zu verstehen oder mich daran zu erinnern. Bitte helfen Sie.
Venkatesh K
Ich möchte den Unterschied zwischen wissen
const int* ptr;
und
int * const ptr;
und wie es funktioniert.
Es ist ziemlich schwierig für mich, das zu verstehen oder mich daran zu erinnern. Bitte helfen Sie.
hackt
const int* ptr;
erklärt ptr
ein Zeiger auf const int
Typ. Sie können ändern ptr
sich selbst, sondern das Objekt, auf das von gezeigt wird ptr
dürfen nicht geändert werden.
const int a = 10;
const int* ptr = &a;
*ptr = 5; // wrong
ptr++; // right
Während
int * const ptr;
erklärt ptr
a const
Zeiger auf int
Typ. Sie dürfen nicht modifizieren ptr
aber das Objekt zeigte auf von ptr
können geändert werden.
int a = 10;
int *const ptr = &a;
*ptr = 5; // right
ptr++; // wrong
Im Allgemeinen würde ich eine Erklärung wie diese bevorzugen, die sie leicht lesbar und verständlich macht (von rechts nach links gelesen):
int const *ptr; // ptr is a pointer to constant int
int *const ptr; // ptr is a constant pointer to int
im zweiten Fall eines konstanten Zeigers können wir nicht zeigen NULL
nach der initialisierung?
– Jayesh Bhoi
31. August 2016 um 11:39 Uhr
Ich habe gerade festgestellt, dass auch dieser Code int i = 10; const int* ptr = &i;
funktioniert. was bedeutet ptr
muss nicht immer auf einen konstanten Wert zeigen. Sie können damit auch auf einen Variablenwert zeigen. Es ist nur so, dass Sie den Wert, auf den verwiesen wird, niemals ändern können ptr
.
– RBT
21. September 2016 um 1:04 Uhr
Auch wenn es sich um ein Duplikat handelt, ist diese Antwort bei weitem die beste …
– GeertVc
30. September 2017 um 12:46 Uhr
@JinKwon Natürlich kannst du das tun, aber es wird eine ganz andere Bedeutung haben.
– Hacken
26. Juni 2021 um 8:39 Uhr
@JinKwon const int * const a
erklärt a
wie const
Zeiger auf a const int
. In diesem Fall auch nicht a
geändert werden soll, noch das Objekt, auf das gezeigt wird a
durch *a
.
– Hacken
26. Juni 2021 um 9:00 Uhr
const int * ptr;
bedeutet, dass die Daten, auf die gezeigt wird, 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.
ein Zeiger auf const
sagt nichts darüber aus, ob das Objekt, auf das der Zeiger zeigt, ist const
. Definieren eines Zeigers als Zeiger auf const
wirkt sich nur auf das aus, was wir mit dem Zeiger tun können.
– Benutzer11748261
11. Januar 2020 um 7:49 Uhr
1) Konstante Zeiger: Diese Art von Zeigern kann die Adresse, auf die sie zeigen, nicht ändern. Angenommen, es gibt einen Zeiger, der auf eine Variable zeigt (oder die Adresse dieser Variablen speichert). Wenn wir nun versuchen, den Zeiger auf eine andere Variable zu zeigen (oder versuchen, den Zeiger dazu zu bringen, die Adresse einer anderen Variablen zu speichern), dann 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’ als konstanten Zeiger)
2) Zeiger auf Konstante: Diese Art von Zeigern kann den Wert, auf den sie zeigen, nicht ändern. Das 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’ zu einem Zeiger auf 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 sich der Compiler darüber beschwert, dass wir die Adresse eines konstanten Zeigers 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;
}
Nun, wenn der obige Code kompiliert ist, 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 dem Zeiger auf eine Konstante nicht erlaubt, den Wert der Variablen zu ändern, auf die gezeigt wird.
Weg
Referenzieren
Dieser Thread
Konstante Zeiger
Lassen Sie uns zuerst verstehen, was ein konstanter Zeiger ist. Ein konstanter Zeiger ist ein Zeiger, der die Adresse, die er hält, nicht ändern kann. Mit anderen Worten, wir können sagen, dass, sobald ein konstanter Zeiger auf eine Variable zeigt, er nicht mehr auf eine andere Variable zeigen kann.
Ein konstanter Zeiger wird wie folgt deklariert:
<type of pointer> * const <name of pointer>
Eine Beispieldeklaration würde wie folgt 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:
Zeiger auf Konstante
Wie aus dem Namen hervorgeht, wird ein Zeiger, durch den der Wert einer Variablen, auf die er zeigt, nicht geändert werden kann, als Zeiger auf eine Konstante bezeichnet. 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:
Sergej L.
const int* ptr;
ist ein Zeiger auf Konstante (Inhalt). Sie dürfen den Zeiger ändern. z.B ptr = NULL
, ptr++
aber Änderung des Inhalts ist nicht möglich.
int * const ptr;
Ist ein konstanter Zeiger. Das Gegenteil ist möglich. Sie sind nicht erlaubt, den Zeiger zu ändern, aber Sie sind darf ändern, worauf es zeigt, z *ptr += 5
.
Benutzer253751
int i;
int j;
int * const ptr1 = &i;
Der Compiler wird Sie daran hindern, Änderungen vorzunehmen ptr1
.
const int * ptr2 = &i;
Der Compiler wird Sie daran hindern, Änderungen vorzunehmen *ptr2
.
ptr1 = &j; // error
*ptr1 = 7; // ok
ptr2 = &j; // ok
*ptr2 = 7; // error
Beachten Sie, dass Sie noch Änderungen vornehmen können *ptr2
nur nicht durch wörtliches Eintippen *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
Gemeinschaft
Bitte beachten Sie den folgenden Link zum besseren Verständnis des Unterschieds zwischen Const-Zeiger und Zeiger auf einen konstanten Wert.
konstanter Zeiger vs. Zeiger auf einen konstanten Wert
Lesen Sie Kapitel 3. Entschlüsseln von Deklarationen in C des Buches Deep C Secrets von Peter Linden, Sie werden lernen, wie Sie jede komplexe Dekalation mit beliebigen Kombinationen von Zeigern, Konstanten usw. entschlüsseln können
– Tiefer Gedanke
31. Januar 2014 um 9:56 Uhr
Das Dupe ist hier: stackoverflow.com/q/890535/694576 nicht dort, wo es nahe war, da es bei letzterem um C++ geht.
– alk
26. September 2015 um 11:16 Uhr
@ user694733 auf der anderen Seite gibt es mir ein Gefühl dafür, wie viel Entwickler zur Community beitragen wollen, dass der Status der Frage für sie keine Rolle spielt … manchmal 🙂
– RBT
21. September 2016 um 0:28 Uhr