const int vs. int const as paramètre de fonction en C++ et C

l'astuce consiste à lire la déclaration à l'envers (de droite à gauche):

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

les Deux sont la même chose. Par conséquent:

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

le truc de la lecture à l'envers est particulièrement pratique lorsqu'il s'agit de déclarations plus complexes comme:

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

Il n'y a pas de différence. Ils déclarent tous les deux que" a " est un entier qui ne peut pas être modifié.

l'endroit où les différences commencent à apparaître est lorsque vous utilisez des pointeurs.

les deux:

const int *a
int const *a

déclarer "a" à être un pointeur vers un entier qui ne change pas. "a" peut être attribué, mais "*" impossible.

int * const a

déclare "une" à une constante pointeur vers un entier. "*" peut être affecté, mais "un" ne peut pas.

const int * const a

déclare "un" un pointeur constant sur une constante de type entier. Ni "un", ni "*" peut être attribué.

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 est correct que les déclarations sont les mêmes, bien qu'un peu plus d'explication de l'affaire pointeur pourrait être en ordre.

"const int* p" est un pointeur vers un int qui ne permettent pas l'int d'être changé par le pointeur. "int* const p" est un pointeur vers un int qui ne peut pas être modifié pour pointer vers un autre int.

voir http://www.parashift.com/c++ - faq-lite/const-correctness.html#faq-18.5 .

const int est identique à int const , comme c'est le cas pour tous les types scalaires en C. En général, déclarer un paramètre de fonction scalaire comme const n'est pas nécessaire, puisque la sémantique appel-valeur de C signifie que toute modification de la variable est locale à sa fonction d'enclos.

ce n'est pas une réponse directe mais un conseil connexe. Pour garder les choses droites, j'utilise toujours la convection "mettre const à l'extérieur", où par "extérieur" je veux dire l'extrême gauche ou l'extrême droite. De cette façon il n'y a pas de confusion -- la const s'applique à la chose la plus proche (soit le type ou le * ). Par exemple,

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

Oui, ils sont même pour int

et différent pour int*

je pense que dans ce cas, ils sont les mêmes, mais voici un exemple où l'ordre importe:

const int* cantChangeTheData;
int* const cantChangeTheAddress;

ce sont les mêmes, mais en C++ il y a une bonne raison pour toujours utiliser const sur la droite. Vous serez cohérent partout parce que les fonctions de membre const doit être déclaré de cette façon:

int getInt() const;

il change le pointeur this dans la fonction de Foo * const à Foo const * const . voir ici.