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

Question

Question rapide:

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

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

Ce sont ces deux fonctions de la même dans tous les aspects ou est-il une différence? Je suis intéressé par une réponse pour le langage C, mais si il y a quelque chose intéressés dans le C++ cas, je voudrais savoir en tant que bien.

Answer 1

Le truc, c'est de lire la déclaration de 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. Donc:

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

La lecture en arrière truc en particulier est très pratique lorsque vous faites affaire avec la plus complexe des déclarations 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

Answer 2

const T et T const sont identiques. Attention à pointeur de priorité, cependant:

char const* est un pointeur vers une constante char (array), tandis que l' char* const est un pointeur constant vers un mutable char (tableau).

Answer 3

Il n'y a pas de différence. Ils déclarent "a" à être un entier qui ne peut pas être modifié.

Le lieu où les différences commencent à apparaître lorsque vous utilisez les pointeurs.

Deux de ces:

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 attribué à l', 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;
}

Answer 4

Prakash est exact que les déclarations sont les mêmes, bien qu'un peu plus d'explications sur le pointeur cas, peut-être dans l'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-correct.html#faq-18.5.

Answer 5

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