Konstanter Zeiger vs. Zeiger auf Konstante [duplicate]

Lesezeit: 7 Minuten

Benutzeravatar von Venkatesh K
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.

  • 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

Benutzeravatar von hackks
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.

Zitat

Der Benutzeravatar von G
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:

  • 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 zum Punkt var2 geführt.
  • Schließlich versuchen wir, den Wert auszugeben, auf den ptr zeigt.

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:

  • Wir haben eine Variable var1 mit dem Wert 0 definiert
  • wir haben einen Zeiger auf eine Konstante definiert, die auf die Variable var1 zeigt
  • Nun haben wir versucht, über diesen Zeiger den Wert von var1 zu ändern
  • Benutzte printf, um den neuen Wert zu drucken.

Benutzeravatar von Sergey L
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.

Benutzeravatar von user253751
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 *ptr2nur 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

Benutzeravatar der Community
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

1426200cookie-checkKonstanter Zeiger vs. Zeiger auf Konstante [duplicate]

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy