const int vs. int const jako parametr funkcji w C++ i C

Sztuką jest odczytanie deklaracji wstecz (od prawej do lewej):

const int a = 1; // read as "a is an integer which is constant"
int const a = 1; // read as "a is a constant integer"

Oba są tym samym. Dlatego:

a = 2; // Can't do because a is constant

Sztuczka z czytaniem od tyłu jest szczególnie przydatna, gdy masz do czynienia z bardziej złożonymi deklaracjami, takimi jak:

const char *s;      // read as "s is a pointer to a char that is constant"
char c;
char *const t = &c; // read as "t is a constant pointer to a char"

*s = 'A'; // Can't do because the char is constant
s++;      // Can do because the pointer isn't constant
*t = 'A'; // Can do because the char isn't constant
t++;      // Can't do because the pointer is constant

Nie ma żadnej różnicy. Obie deklarują "a" jako liczbę całkowitą, której nie można zmienić.

Miejsce, w którym zaczynają się pojawiać różnice, jest wtedy, gdy używasz wskaźników.

Oba:

const int *a
int const *a

Zadeklaruj" a " jako wskaźnik na liczbę całkowitą, która się nie zmienia. "a" może być przypisane do, ale "*a" nie może.

int * const a

Deklaruje " a " jako stały wskaźnik do liczby całkowitej. "*a " może być przypisane do, ale "a" nie może.

const int * const a

Deklaruje "a" jako stały wskaźnik do a stała liczba całkowita. Ani "a", ani "*a " nie mogą być przypisane do.

static int one = 1;

int testfunc3 (const int *a)
{
  *a = 1; /* Error */
  a = &one;
  return *a;
}

int testfunc4 (int * const a)
{
  *a = 1;
  a = &one; /* Error */
  return *a;
}

int testfunc5 (const int * const a)
{
  *a = 1;   /* Error */
  a = &one; /* Error */
  return *a;
}

Prakash ma rację, że deklaracje są takie same, chociaż przydałoby się trochę więcej wyjaśnienia sprawy wskaźnika.

"const int * p" jest wskaźnikiem do int, który nie pozwala na zmianę int przez ten wskaźnik. "int * const p" jest wskaźnikiem do int, którego nie można zmienić na inny int.

Zobacz http://www.parashift.com/c++ - faq-lite / const-poprawność.html#faq-18.5.

const int jest identyczna z int const, co jest prawdą dla wszystkich typów skalarnych w C. Ogólnie deklarowanie parametru funkcji skalarnej jako {[2] } nie jest potrzebne, ponieważ semantyka wywołania przez wartość C oznacza, że wszelkie zmiany w zmiennej są lokalne dla jej funkcji zamykającej.

To nie jest bezpośrednia odpowiedź, ale powiązana wskazówka. Aby wszystko było proste, zawsze używam konwekcji "put const on the outside", gdzie przez "outside" mam na myśli lewą lub prawą stronę. W ten sposób nie ma zamieszania-const odnosi się do najbliższej rzeczy (albo typu, albo *). Np.,

int * const foo = ...; // Pointer cannot change, pointed to value can change
const int * bar = ...; // Pointer can change, pointed to value cannot change
int * baz = ...; // Pointer can change, pointed to value can change
const int * const qux = ...; // Pointer cannot change, pointed to value cannot change

Yes, they are same for just int

I inne dla int*

Myślę, że w tym przypadku są takie same, ale tutaj jest przykład, gdzie liczy się porządek:

const int* cantChangeTheData;
int* const cantChangeTheAddress;

Są takie same, ale w C++ jest dobry powód, aby zawsze używać const po prawej stronie. Będziesz zawsze spójny, ponieważ funkcje składowe const muszą być zadeklarowane w ten sposób:

int getInt() const;

Zmienia wskaźnik this w funkcji z Foo * const na Foo const * const. Zobacz tutaj.