über "int const *p" und "const int *p "

Hier betrachten wir 4 Arten von Zeigern Erklärungen:

1. int * w;
   Es heißt, w ist ein Zeiger auf einen Wert vom Typ integer. Können wir beide ändern den Zeiger und seine Inhalte. Wenn wir initialisieren w, während die Erklärung wie folgt:
   int * w = &a;
   
   Dann unten angegebenen Operationen sind sinnvoll:
   
   w = &b;(true)
   
   *w = 1;(true)

2. int * const x;
   
   Es bedeutet, x ist ein konstanter Zeiger, die Punkte auf einen Wert vom Typ integer. Wenn wir initialisieren x während der Erklärung wie folgt:
   
   int * const x = &a;
   
   Dann können wir nicht tun: x = &b;(wrong) denn x ist ein konstanter Zeiger und kann nicht verändert werden.
   
   Es ist jedoch möglich, das zu tun: *x = 1;(true), weil der Inhalt von x nicht konstant ist.

3. int const * y; //beide bedeuten das gleiche
   
   const int * y;
   
   Es bedeutet, dass y ein Zeiger verweist auf eine Konstante Ganzzahl. Wenn wir initialisieren y, während die Erklärung wie folgt:
   
   int const * y = &a;
   
   Dann ist es möglich zu tun: y=&b;(true) weil y eine nicht-Konstante Zeiger, die zeigen können, überall.
   
   Dennoch können wir nicht: *y=1;(wrong) weil die variable, die die y-Punkte, ist eine Konstante, variable und kann nicht geändert werden.

4. int const * const z; //beide bedeuten das gleiche
   
   const int * const z;
   
   Es bedeutet, dass z ein konstanter Zeiger, der zeigt auf eine Konstante Ganzzahl. Wenn wir initialisieren z während der Erklärung wie folgt:
   
   int const * const z = &a;
   
   Daher, nicht von unten angegebenen Operationen sind sinnvoll:
   
   z = &b;(wrong)

*z = 1;(wrong)

const int *p = &i1;
int const *p2 = &i1;

Diese beiden erklären nicht-const-Zeiger auf const Daten.

Ist, mit p Sie können nicht ändern, die Daten die es verweist. Sie können jedoch ändern, der pointer selbst, zum Beispiel durch die Zuordnung als p = &i2 die legal ist. Aber *p = 87987 ist illegal, da die Daten p verweist const!

--

int * const p = &i1;

Dieser erklärt const-Zeiger auf non-const-Daten. Das ist p=&i2 ist illegal, aber *p = 98789 legal ist.

--

const int * const p = &i1;

Dieser erklärt const Zeiger auf const Daten. Das heißt, jetzt beide p=&i2 und *p=87897 sind illegal.

Nein, die const - Schlüsselwort vor der * bedeutet, dass die variable, die Sie zeigen wird ein "const" - variable, und nur Sie kann nicht geändert werden.

1. Wenn Sie möchten, dass ein Zeiger, der kann nicht neu zugewiesen werden, dann müssen Sie deklarieren es als Foo* const p = &bar;
2. Wenn Sie möchten, dass ein Zeiger verweist auf ein "const" - Objekt kann nicht neu zugewiesen werden, deklarieren Sie Sie als const Foo* const p = &bar

Ist es völlig in Ordnung einen Zeiger von const int* foo zugewiesen werden, um einen Zeiger von const int* const bar so, wie es ist in Ordnung zu haben eine int's Wert zugewiesen const int. Denken Sie in der gleichen Weise.

Lapidar; jede Kombination von read/write int & Zeiger;

int main() {

  int a,b;

  int* w;                       //read/write int, read/write pointer
  w= &b;                        //good
  *w= 1;                        //good

  int* const x = &a;            //read only pointer, read/write int 
  //x = &b;                    //compilation error
  *x = 0;                       //good

  int const * y;                //read/write ptr, read only int 
  const int * y2;               //"    "    "
  y = &a;                       //good
  //*y = 0;                    //compilation error
  y2 = &a;                      //good
  //*y2 = 0;                   //compilation error

  int const * const z = &a;     //read only ptr and read only int 
  const int * const z2 = &b;    //"    "   "   "   
  //*z = 0;                    //compilation error
  //z = &a;                    //compilation error
  //*z2 = 0;                   //compilation error
  //z2 = &a;                   //compilation error

}