konstanter Zeiger vs. Zeiger auf einen konstanten Wert [duplicate]

Was ist der Unterschied zwischen den folgenden Deklarationen?

char * const a;
const char * a;

Um den Unterschied zu verstehen, habe ich dieses kleine Programm geschrieben:

#include <stdio.h>
#include <stdlib.h>


int main (int argc, char **argv)
{
    char a="x";
    char b = 'y';

    char * const pc1 = &a;
    const char * pc2 = &a;

    printf ("Before\n");
    printf ("pc1=%p\n", pc1);
    printf ("*pc1=%c\n", *pc1);
    printf ("pc2=%p\n", pc2);
    printf ("*pc2=%c\n", *pc2);

    *pc1 = b;
/*     pc1 = &b; */

/*     *pc2 = b; */
    pc2 = &b;

    printf ("\n\n");

    printf ("After\n");
    printf ("pc1=%p\n", pc1);
    printf ("*pc1=%c\n", *pc1);
    printf ("pc2=%p\n", pc2);
    printf ("*pc2=%c\n", *pc2);

    return EXIT_SUCCESS;
}

Ich habe das Programm (mit gcc 3.4) kompiliert und ausgeführt. Die Ausgabe hebt den Unterschied ziemlich gut hervor:

Before
pc1=ffbfd7e7
*pc1=x
pc2=ffbfd7e7
*pc2=x


After
pc1=ffbfd7e7
*pc1=y
pc2=ffbfd7e6
*pc2=x

Allerdings musste ich das kleine Programm schreiben, um die Antwort zu bekommen. Falls ich nicht an der Maschine bin (z. B. bei einem Vorstellungsgespräch), könnte ich die Frage nicht beantworten.

Kann jemand bitte erklären, indem er das obige Beispiel kommentiert, wie die const Schlüsselwort funktioniert?

char * const a;

bedeutet, dass der Zeiger konstant und unveränderlich ist, die angezeigten Daten jedoch nicht.
Du könntest benutzen const_cast(in C++) oder C-Style-Cast, um die Konstanz in diesem Fall zu verwerfen, da die Daten selbst nicht konstant sind.

const char * a;

bedeutet, dass auf die Daten, auf die gezeigt wird, nicht unter Verwendung des Zeigers a geschrieben werden kann. Verwendung einer const_cast(C++) oder C-Style-Cast, um die in diesem Fall verursachte Konstanz wegzuwerfen Undefiniertes Verhalten.

Um komplizierte Typen zu analysieren, beginnen Sie bei der Variablen, gehen nach links und spiralförmig nach außen. Wenn es keine Arrays oder Funktionen gibt, um die Sie sich Sorgen machen müssen (weil diese rechts vom Variablennamen sitzen), wird dies zu einem Fall von Rechts-nach-Links-Lesen.

Also mit char *const a; Sie haben adie ein const Zeiger (*) zu einem char. Mit anderen Worten, Sie können das Zeichen ändern, das a zeigt auf, aber du kannst es nicht machen a auf etwas anderes hinweisen.

Umgekehrt mit const char* b; Sie haben bwas ein Zeiger ist (*) zu einem char welches ist const. Du kannst das schaffen b Zeigen Sie auf ein beliebiges Zeichen, aber Sie können den Wert dieses Zeichens nicht mit ändern *b = ...;.

Sie können natürlich auch beide Geschmacksrichtungen gleichzeitig haben: const char *const c;.

char * const a;

*a ist beschreibbar, aber a ist nicht; mit anderen Worten, Sie können den Wert ändern wies auf durch aaber Sie können nicht ändern a selbst. a ist ein ständiger Zeiger auf char.

const char * a; 

a ist beschreibbar, aber *a ist nicht; mit anderen Worten, Sie können ändern a (zeigt auf eine neue Position), aber Sie können den Wert nicht ändern wies auf durch a.

Beachten Sie, dass dies identisch ist mit

char const * a;

In diesem Fall, a ist ein Zeiger auf a const char.

Jetzt, da Sie den Unterschied zwischen kennen char * const a und const char * a. Oft sind wir verwirrt, ob es sich um einen konstanten Zeiger oder einen Zeiger auf eine konstante Variable handelt.

Wie ist es zu lesen? Befolgen Sie den folgenden einfachen Schritt, um zwischen den oberen beiden zu unterscheiden.

Mal sehen, wie die folgende Erklärung zu lesen ist

char * const a;

von rechts nach links lesen

Beginnen Sie jetzt mit a,

1 . grenzt an a Es gibt const.

Zeichen * (const a);

—> Also a ist ein constant (????).

2 . Jetzt gehen Sie mit *

verkohlen (* (const a));

—> Also a ist ein constant pointer zu (????).

3 . Gehen Sie mit und es gibt char

(char (* (const a)));

—> a ist ein constant pointer zu character Variable

a is constant pointer to character variable. 

Ist es nicht leicht zu lesen?

Ähnlich für die zweite Deklaration

const char * a;

Jetzt wieder mit beginnen a,

1 . Grenzt an a Es gibt *

—> Also a ist ein pointer zu (????)

2 . Jetzt gibt es da char

—> also a ist pointer character,

Na das macht doch keinen Sinn!!! Also mischen pointer und character

—> also a ist character pointer zu (?????)

3 . Jetzt hast du constant

—> also a ist character pointer zu constant Variable

Aber obwohl Sie erkennen können, was Deklaration bedeutet, lassen Sie es vernünftiger klingen.

a is pointer to constant character variable

Der einfachste Weg, den Unterschied zu verstehen, besteht darin, an die verschiedenen Möglichkeiten zu denken. Es müssen zwei Objekte betrachtet werden, der Zeiger und das Objekt, auf das gezeigt wird (in diesem Fall ist ‘a’ der Name des Zeigers, das Objekt, auf das gezeigt wird, ist unbenannt und vom Typ char). Die Möglichkeiten sind:

1. nichts ist konstant
2. der Zeiger ist konstant
3. das Objekt, auf das gezeigt wird, ist const
4. Sowohl der Zeiger als auch das Objekt, auf das gezeigt wird, sind konstant.

Diese verschiedenen Möglichkeiten können in C wie folgt ausgedrückt werden:

1. Zeichen * ein;
2. char * const a;
3. const char * a;
4. const char * const a;

Ich hoffe, dies verdeutlicht die möglichen Unterschiede

Der erste ist ein konstanter Zeiger auf ein Zeichen und der zweite ein Zeiger auf ein konstantes Zeichen. Sie haben nicht alle Fälle in Ihrem Code berührt:

char * const pc1 = &a; /* You can't make pc1 point to anything else */
const char * pc2 = &a; /* You can't dereference pc2 to write. */

*pc1 = 'c' /* Legal. */
*pc2 = 'c' /* Illegal. */

pc1 = &b; /* Illegal, pc1 is a constant pointer. */
pc2 = &b; /* Legal, pc2 itself is not constant. */

Ich erkläre es erst mündlich und dann mit einem Beispiel:

Ein Zeigerobjekt kann als konstanter Zeiger oder als Zeiger auf ein konstantes Objekt (oder beides) deklariert werden:

EIN konstanter Zeiger kann nicht neu zugewiesen werden, um auf ein anderes Objekt als das ursprünglich zugewiesene zu zeigen, aber es kann verwendet werden, um das Objekt zu ändern, auf das es zeigt (als “Pointee” bezeichnet).
Referenzvariablen sind daher eine alternative Syntax für Konstantenzeiger.

EIN Zeiger auf ein konstantes Objektandererseits kann neu zugewiesen werden, um auf ein anderes Objekt desselben Typs oder eines konvertierbaren Typs zu zeigen, aber es kann nicht verwendet werden, um ein Objekt zu ändern.

EIN const Zeiger auf ein konstantes Objekt kann auch deklariert werden und kann weder verwendet werden, um den Pointee zu ändern, noch neu zugewiesen werden, um auf ein anderes Objekt zu zeigen.

Beispiel:

void Foo( int * ptr,
         int const * ptrToConst,
         int * const constPtr,
         int const * const constPtrToConst ) 
{ 
    *ptr = 0; // OK: modifies the "pointee" data 
    ptr = 0; // OK: modifies the pointer 

    *ptrToConst = 0; // Error! Cannot modify the "pointee" data
     ptrToConst = 0; // OK: modifies the pointer 

    *constPtr = 0; // OK: modifies the "pointee" data 
    constPtr = 0; // Error! Cannot modify the pointer 

    *constPtrToConst = 0; // Error! Cannot modify the "pointee" data 
    constPtrToConst = 0; // Error! Cannot modify the pointer 
}

Freue mich zu helfen! Viel Glück!