Aby uniknąć nieporozumień, zawsze Dołącz kwalifikator const.

int       *      mutable_pointer_to_mutable_int;
int const *      mutable_pointer_to_constant_int;
int       *const constant_pointer_to_mutable_int;
int const *const constant_pointer_to_constant_int;

const zawsze modyfikuje rzecz, która pojawia się przed nią (po lewej stronie), z wyjątkiem sytuacji, gdy jest to pierwsza rzecz w deklaracji typu, gdzie modyfikuje rzecz, która pojawia się po niej (po prawej stronie).

Więc te dwa są takie same:

int const *i1;
const int *i2;

Definiują wskaźniki do const int. Możesz zmienić miejsce, w którym i1 i i2 punkty, ale nie możesz zmienić wartości, na którą wskazują.

To:

int *const i3 = (int*) 0x12345678;

Definiuje wskaźnik const na liczbę całkowitą i inicjalizuje go, aby wskazywał na Miejsce Pamięci 12345678. Możesz zmienić wartość int pod adresem 12345678, ale nie możesz zmienić adresu, na który wskazuje i3.

const * char jest nieprawidłowym kodem C i jest bez znaczenia. Może chciałeś zapytać o różnicę między A const char * i a char const *, a może o różnicę między A const char * i a char * const?

Zobacz też:

• czym są wskaźniki const (w przeciwieństwie do wskaźników do obiektów const)?
• Const in C
• różnica między deklaracjami const w C++
• C++ const question
• Dlaczego mogę zmienić wartości const char * zmienna?

const char* jest wskaźnikiem do postaci stałej
char* const jest stałym wskaźnikiem do znaku
const char* const jest stałym wskaźnikiem do stałego znaku

1) const char * x Tutaj X jest w zasadzie wskaźnikiem znakowym, który wskazuje na stałą wartość

2) char * const x {[2] } odnosi się do wskaźnika znakowego, który jest stały, ale miejsce, w którym wskazuje, może zostać zmienione.

3) const char * const x jest kombinacją 1 i 2, czyli jest stałym wskaźnikiem znakowym wskazującym na stałą wartość.

4) const * char x spowoduje błąd kompilatora. to nie może być zadeklarowane.

5) znak const * x jest równy punktowi 1.

Zasada jest taka , że jeśli constma nazwę var, to wskaźnik będzie stały, ale można zmienić lokalizację Wskazywania, w przeciwnym razie wskaźnik będzie wskazywał na stałą lokalizację, a wskaźnik może wskazywać na inną lokalizację, ale zawartości Wskazywania nie można zmienić.

Rule of thumb: Czytaj definicję od prawej do lewej!

const int *foo;

Oznacza " foo Punkty (*) na int, które nie mogą się zmienić (const)".
Dla programisty oznacza to "nie zmienię wartości tego, na co foo wskazuje".

• *foo = 123; lub foo[0] = 123; byłoby nieważne.
• foo = &bar; jest dozwolone.

int *const foo;

Oznacza " foo nie można zmienić (const) i punktów (*) na int".
Na programista oznacza to "nie zmienię adresu pamięci , do którego odnosi się foo".

• *foo = 123; lub foo[0] = 123; jest dozwolone.
• foo = &bar; byłoby nieważne.

const int *const foo;

Oznacza " foo cannot change (const) and points (*) to an int that cannot change (const)".
Dla programisty oznacza to: "nie zmienię wartości tego, na co foo wskazuje, ani nie zmienię adresu , który foo odnosi się do".

• *foo = 123; lub foo[0] = 123; byłoby nieważne.
• foo = &bar; byłoby nieważne.

Pierwszy to błąd składni. Może chodziło Ci o różnicę między

const char * mychar

I

char * const mychar

W takim przypadku pierwszy jest wskaźnikiem do danych, które nie mogą się zmienić, a drugi jest wskaźnikiem, który zawsze będzie wskazywał na ten sam adres.

Kolejna zasada kciuka to sprawdzanie gdzie const jest :

1. Przed * => wartość przechowywana jest stała
2. po * => Wskaźnik sam w sobie jest stałą

Wiele odpowiedzi dostarcza konkretnych technik, reguł kciuków itp., aby zrozumieć tę konkretną instancję deklaracji zmiennej. Jednak istnieje ogólna technika rozumienia dowolnej deklaracji:

Zgodnie Z Ruchem Wskazówek Zegara / Spirali

A)

const char *a;

Zgodnie z ruchem wskazówek zegara / spirali {[2] } jest wskaźnik do znaku, który jest stały. Co oznacza, że znak jest stały, ale wskaźnik może się zmieniać. tzn. a = "other string"; jest w porządku, ale a[2] = 'c'; zawiedzie aby skompilować

B)

char * const a;

Zgodnie z regułą, {[2] } jest wskaźnikiem const do znaku. tzn. możesz zrobić a[2] = 'c'; ale nie możesz zrobić a = "other string";

Zakładam, że masz na myśli const char * i char * const .

Pierwszy, const char *, jest wskaźnikiem do stałego znaku. Sam wskaźnik jest zmienny.

Drugi, char * const jest stałym wskaźnikiem do znaku. Wskaźnik nie może się zmienić, znak wskazuje na can.

I wtedy jest const char * const, gdzie wskaźnik i znak nie mogą się zmienić.

Oto szczegółowe wyjaśnienie z kodem

/*const char * p;
char * const p; 
const char * const p;*/ // these are the three conditions,

// const char *p;const char * const p; pointer value cannot be changed

// char * const p; pointer address cannot be changed

// const char * const p; both cannot be changed.

#include<stdio.h>

/*int main()
{
    const char * p; // value cannot be changed
    char z;
    //*p = 'c'; // this will not work
    p = &z;
    printf(" %c\n",*p);
    return 0;
}*/

/*int main()
{
    char * const p; // address cannot be changed
    char z;
    *p = 'c'; 
    //p = &z;   // this will not work
    printf(" %c\n",*p);
    return 0;
}*/



/*int main()
{
    const char * const p; // both address and value cannot be changed
    char z;
    *p = 'c'; // this will not work
    p = &z; // this will not work
    printf(" %c\n",*p);
    return 0;
}*/

1. stały wskaźnik : stały wskaźnik może wskazywać tylko jedną zmienną danego typu danych podczas całego programu.możemy zmienić wartość zmiennej wskazywanej przez wskaźnik. Inicjalizacja powinna być dokonywana w czasie samej deklaracji.

Składnia:

datatype *const var;

char *const jest pod tą sprawą.

/*program to illustrate the behaviour of constant pointer */

#include<stdio.h>
int main(){
  int a=10;
  int *const ptr=&a;
  *ptr=100;/* we can change the value of object but we cannot point it to another variable.suppose another variable int b=20; and ptr=&b; gives you error*/
  printf("%d",*ptr);
  return 0;
}

1. wskaźnik do wartości const : w tym wskaźniku można wskazać dowolną liczbę zmiennych danego typu nie możemy jednak zmienić wartości obiektu wskazywanego przez wskaźnik w danym momencie.

Składnia:

const datatype *varlub datatype const *var

const char* jest pod tą sprawą.

/* program to illustrate the behavior of pointer to a constant*/

   #include<stdio.h>
   int main(){
       int a=10,b=20;
       int const *ptr=&a;
       printf("%d\n",*ptr);
       /*  *ptr=100 is not possible i.e we cannot change the value of the object pointed by the pointer*/
       ptr=&b;
       printf("%d",*ptr);
       /*we can point it to another object*/
       return 0;
    }

Char * const i const char*?

1. wskazując na stałą wartość

const char * p; // wartość nie może być zmieniona

1. stały wskaźnik do wartości

char * const p; // nie można zmienić adresu

1. stały wskaźnik do stałej wartości

const char * const p; // obu nie da się zmienić.

Modyfikator const jest nakładany na termin bezpośrednio po jego lewej stronie. Jedynym wyjątkiem od tego jest, gdy nie ma nic po jego lewej stronie, to odnosi się do tego, co jest natychmiast po jego prawej stronie.

Są to wszystkie równoważne sposoby powiedzenia " stały wskaźnik do stałej char":

• const char * const
• const char const *
• char const * const
• char const const *

Dwie zasady

1. If const is between char and *, it will affect the left one.
2. If const is not between char and *, it will affect the nearest one.

Np.

1. char const *. This is a pointer points to a constant char.
2. char * const. This is a constant pointer points to a char.

Chciałbym zwrócić uwagę, że użycie int const * (lub const int *) Nie dotyczy wskaźnika wskazującego na zmienną const int, ale że ta zmienna jest const dla tego konkretnego wskaźnika.

Na przykład:

int var = 10;
int const * _p = &var;

Powyższy kod kompiluje się doskonale. _p wskazuje na zmienną const, chociaż sama var nie jest stała.

// Some more complex constant variable/pointer declaration.
// Observing cases when we get error and warning would help
// understanding it better.

int main(void)
{
  char ca1[10]= "aaaa"; // char array 1
  char ca2[10]= "bbbb"; // char array 2

  char *pca1= ca1;
  char *pca2= ca2;

  char const *ccs= pca1;
  char * const csc= pca2;
  ccs[1]='m';  // Bad - error: assignment of read-only location ‘*(ccs + 1u)’
  ccs= csc;    // Good

  csc[1]='n';  // Good
  csc= ccs;    // Bad - error: assignment of read-only variable ‘csc’

  char const **ccss= &ccs;     // Good
  char const **ccss1= &csc;    // Bad - warning: initialization from incompatible pointer type

  char * const *cscs= &csc;    // Good
  char * const *cscs1= &ccs;   // Bad - warning: initialization from incompatible pointer type

  char ** const cssc=   &pca1; // Good
  char ** const cssc1=  &ccs;  // Bad - warning: initialization from incompatible pointer type
  char ** const cssc2=  &csc;  // Bad - warning: initialization discards ‘const’
                               //                qualifier from pointer target type

  *ccss[1]= 'x'; // Bad - error: assignment of read-only location ‘**(ccss + 8u)’
  *ccss= ccs;    // Good
  *ccss= csc;    // Good
  ccss= ccss1;   // Good
  ccss= cscs;    // Bad - warning: assignment from incompatible pointer type

  *cscs[1]= 'y'; // Good
  *cscs= ccs;    // Bad - error: assignment of read-only location ‘*cscs’
  *cscs= csc;    // Bad - error: assignment of read-only location ‘*cscs’
  cscs= cscs1;   // Good
  cscs= cssc;    // Good

  *cssc[1]= 'z'; // Good
  *cssc= ccs;    // Bad - warning: assignment discards ‘const’
                 //                qualifier from pointer target type
  *cssc= csc;    // Good
  *cssc= pca2;   // Good
  cssc= ccss;    // Bad - error: assignment of read-only variable ‘cssc’
  cssc= cscs;    // Bad - error: assignment of read-only variable ‘cssc’
  cssc= cssc1;   // Bad - error: assignment of read-only variable ‘cssc’
}