'const int' vs 'int const' comme paramètres de fonction en C ++ et C

Considérer:

int testfunc1 (const int a)
{
  return a;
}

int testfunc2 (int const a)
{
  return a;
}

Ces deux fonctions sont-elles les mêmes dans tous les aspects ou y a-t-il une différence?

Je suis intéressé par une réponse pour le langage C, mais s'il y a quelque chose d'intéressant dans le langage C ++, j'aimerais aussi savoir.

const Tet T constsont identiques. Avec les types de pointeur, cela devient plus compliqué:

1. const char* est un pointeur vers une constante char
2. char const* est un pointeur vers une constante char
3. char* const est un pointeur constant vers un (mutable) char

En d'autres termes, (1) et (2) sont identiques. La seule façon de faire le pointeur (plutôt que la pointee) constest d'utiliser un suffixe- const.

C'est pourquoi beaucoup de gens préfèrent toujours mettre constdu bon côté du type (style «East const»): cela rend son emplacement par rapport au type cohérent et facile à retenir (il semble aussi anecdotique de faciliter l'enseignement aux débutants ).

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

L'astuce de lecture à l'envers est particulièrement utile lorsque vous avez affaire à des déclarations plus complexes telles que:

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.

Ces deux:

const int *a
int const *a

déclarez "a" comme étant un pointeur vers un entier qui ne change pas. "a" peut être attribué à, mais "* a" ne le peut pas.

int * const a

déclare "a" comme étant un pointeur constant vers un entier. "* a" peut être attribué à, mais "a" ne le peut pas.

const int * const a

déclare "a" comme étant un pointeur constant vers un entier constant. Ni "a" ni "* a" ne peuvent être attribués.

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 a raison de dire que les déclarations sont les mêmes, même si un peu plus d'explications sur la casse du pointeur pourraient être nécessaires.

"const int * p" est un pointeur vers un int qui ne permet pas de modifier l'int à travers ce pointeur. "int * const p" est un pointeur vers un int qui ne peut pas être modifié pour pointer vers un autre int.

Voir https://isocpp.org/wiki/faq/const-correctness#const-ptr-vs-ptr-const .

const intest 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 cela constn'est pas nécessaire, car la sémantique appel par valeur de C signifie que toute modification de la variable est locale à sa fonction englobante.

Ce n'est pas une réponse directe mais une astuce connexe. Pour garder les choses droites, j'utilise toujours la convection "mis constà l'extérieur", où par "extérieur" j'entends l'extrême gauche ou l'extrême droite. De cette façon, il n'y a pas de confusion - le const s'applique à la chose la plus proche (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

Ce sont les mêmes, mais en C ++, il y a une bonne raison de toujours utiliser const sur la droite. Vous serez cohérent partout car les fonctions membres const doivent être déclarées de cette façon:

int getInt() const;

Il change le thispointeur de la fonction de Foo * constà Foo const * const. Vois ici.

Oui, ils sont les mêmes pour juste int

et différent pour int*

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

const int* cantChangeTheData;
int* const cantChangeTheAddress;